int initDataObjInfoWithInp (dataObjInfo_t *dataObjInfo, dataObjInp_t *dataObjInp) { char *rescName, *dataType, *filePath; keyValPair_t *condInput; condInput = &dataObjInp->condInput; memset (dataObjInfo, 0, sizeof (dataObjInfo_t)); rstrcpy (dataObjInfo->objPath, dataObjInp->objPath, MAX_NAME_LEN); rescName = getValByKey (condInput, RESC_NAME_KW); if (rescName != NULL) { rstrcpy (dataObjInfo->rescName, rescName, LONG_NAME_LEN); } snprintf (dataObjInfo->dataMode, SHORT_STR_LEN, "%d", dataObjInp->createMode); dataType = getValByKey (condInput, DATA_TYPE_KW); if (dataType != NULL) { rstrcpy (dataObjInfo->dataType, dataType, NAME_LEN); } else { rstrcpy (dataObjInfo->dataType, "generic", NAME_LEN); } filePath = getValByKey (condInput, FILE_PATH_KW); if (filePath != NULL) { rstrcpy (dataObjInfo->filePath, filePath, MAX_NAME_LEN); } #ifdef FILESYSTEM_META /* copy over the source file metadata if provided */ copyFilesystemMetadata(condInput, &dataObjInfo->condInput); #endif /* FILESYSTEM_META */ return (0); }
// =-=-=-=-=-=-=- // function which determines resource name based on // keyval pair and a given string error resolve_resource_name( const std::string& _resc_name, keyValPair_t* _cond_input, std::string& _out ) { if ( _resc_name.empty() ) { char* name = 0; name = getValByKey( _cond_input, BACKUP_RESC_NAME_KW ); if ( name ) { _out = std::string( name ); return SUCCESS(); } name = getValByKey( _cond_input, DEST_RESC_NAME_KW ); if ( name ) { _out = std::string( name ); return SUCCESS(); } name = getValByKey( _cond_input, DEF_RESC_NAME_KW ); if ( name ) { _out = std::string( name ); return SUCCESS(); } return ERROR( INT_RESC_STATUS_DOWN, "failed to resolve resource name" ); } else { _out = _resc_name; return SUCCESS(); } } // resolve_resource_name
int _rsProcStat (rsComm_t *rsComm, procStatInp_t *procStatInp, genQueryOut_t **procStatOut) { int status; rodsServerHost_t *rodsServerHost; int remoteFlag; rodsHostAddr_t addr; procStatInp_t myProcStatInp; char *tmpStr; if (getValByKey (&procStatInp->condInput, ALL_KW) != NULL) { status = _rsProcStatAll (rsComm, procStatInp, procStatOut); return status; } if (getValByKey (&procStatInp->condInput, EXEC_LOCALLY_KW) != NULL) { status = localProcStat (rsComm, procStatInp, procStatOut); return status; } bzero (&addr, sizeof (addr)); bzero (&myProcStatInp, sizeof (myProcStatInp)); if (*procStatInp->addr != '\0') { /* given input addr */ rstrcpy (addr.hostAddr, procStatInp->addr, LONG_NAME_LEN); remoteFlag = resolveHost (&addr, &rodsServerHost); } else if ((tmpStr = getValByKey (&procStatInp->condInput, RESC_NAME_KW)) != NULL) { rescGrpInfo_t *rescGrpInfo = NULL; status = _getRescInfo (rsComm, tmpStr, &rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "_rsProcStat: _getRescInfo of %s error. stat = %d", tmpStr, status); return status; } rstrcpy (procStatInp->addr, rescGrpInfo->rescInfo->rescLoc, NAME_LEN); rodsServerHost = (rodsServerHost_t*)rescGrpInfo->rescInfo->rodsServerHost; if (rodsServerHost == NULL) { remoteFlag = SYS_INVALID_SERVER_HOST; } else { remoteFlag = rodsServerHost->localFlag; } } else { /* do the IES server */ remoteFlag = getRcatHost (MASTER_RCAT, NULL, &rodsServerHost); } if (remoteFlag < 0) { rodsLog (LOG_ERROR, "_rsProcStat: getRcatHost() failed. erro=%d", remoteFlag); return (remoteFlag); } else if (remoteFlag == REMOTE_HOST) { addKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW, ""); status = remoteProcStat (rsComm, &myProcStatInp, procStatOut, rodsServerHost); rmKeyVal (&myProcStatInp.condInput, EXEC_LOCALLY_KW); } else { status = localProcStat (rsComm, procStatInp, procStatOut); } return status; }
int rsRsyncFileToData( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) { char * fileChksumStr = getValByKey( &dataObjInp->condInput, RSYNC_CHKSUM_KW ); if ( fileChksumStr == NULL ) { rodsLog( LOG_ERROR, "rsRsyncFileToData: RSYNC_CHKSUM_KW input is missing" ); return CHKSUM_EMPTY_IN_STRUCT_ERR; } addKeyVal( &dataObjInp->condInput, ORIG_CHKSUM_KW, fileChksumStr ); // =-=-=-=-=-=-=- // determine the resource hierarchy if one is not provided if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) { std::string hier; irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm, dataObjInp, hier ); if ( !ret.ok() ) { std::stringstream msg; msg << __FUNCTION__; msg << " :: failed in irods::resolve_resource_hierarchy for ["; msg << dataObjInp->objPath << "]"; irods::log( PASSMSG( msg.str(), ret ) ); return ret.code(); } // =-=-=-=-=-=-=- // we resolved the redirect and have a host, set the hier str for subsequent // api calls, etc. addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() ); } // if keyword char *dataObjChksumStr = NULL; dataObjInfo_t *dataObjInfoHead = NULL; int status = _rsDataObjChksum( rsComm, dataObjInp, &dataObjChksumStr, &dataObjInfoHead ); if ( status < 0 && status != CAT_NO_ACCESS_PERMISSION && status != CAT_NO_ROWS_FOUND ) { /* XXXXX CAT_NO_ACCESS_PERMISSION mean the chksum was calculated but * cannot be registered. But the chksum value is OK. */ rodsLog( LOG_ERROR, "rsRsyncFileToData: _rsDataObjChksum of %s error. status = %d", dataObjInp->objPath, status ); } freeAllDataObjInfo( dataObjInfoHead ); if ( dataObjChksumStr != NULL && strcmp( dataObjChksumStr, fileChksumStr ) == 0 ) { free( dataObjChksumStr ); return 0; } free( dataObjChksumStr ); return SYS_SVR_TO_CLI_PUT_ACTION; }
int fillL1desc( int l1descInx, dataObjInp_t *dataObjInp, dataObjInfo_t *dataObjInfo, int replStatus, rodsLong_t dataSize ) { keyValPair_t *condInput; char *tmpPtr; char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ); if ( dataObjInfo->rescHier[0] == '\0' && resc_hier ) { snprintf( dataObjInfo->rescHier, sizeof( dataObjInfo->rescHier ), "%s", resc_hier ); } condInput = &dataObjInp->condInput; char* in_pdmo = getValByKey( condInput, IN_PDMO_KW ); if ( in_pdmo != NULL ) { rstrcpy( L1desc[l1descInx].in_pdmo, in_pdmo, MAX_NAME_LEN ); } else { rstrcpy( L1desc[l1descInx].in_pdmo, "", MAX_NAME_LEN ); } if ( dataObjInp != NULL ) { /* always repl the .dataObjInp */ L1desc[l1descInx].dataObjInp = ( dataObjInp_t* )malloc( sizeof( dataObjInp_t ) ); replDataObjInp( dataObjInp, L1desc[l1descInx].dataObjInp ); L1desc[l1descInx].dataObjInpReplFlag = 1; } else { /* XXXX this can be a problem in rsDataObjClose */ L1desc[l1descInx].dataObjInp = NULL; } L1desc[l1descInx].dataObjInfo = dataObjInfo; if ( dataObjInp != NULL ) { L1desc[l1descInx].oprType = dataObjInp->oprType; } L1desc[l1descInx].replStatus = replStatus; L1desc[l1descInx].dataSize = dataSize; if ( condInput != NULL && condInput->len > 0 ) { if ( ( tmpPtr = getValByKey( condInput, REG_CHKSUM_KW ) ) != NULL ) { L1desc[l1descInx].chksumFlag = REG_CHKSUM; rstrcpy( L1desc[l1descInx].chksum, tmpPtr, NAME_LEN ); } else if ( ( tmpPtr = getValByKey( condInput, VERIFY_CHKSUM_KW ) ) != NULL ) { L1desc[l1descInx].chksumFlag = VERIFY_CHKSUM; rstrcpy( L1desc[l1descInx].chksum, tmpPtr, NAME_LEN ); } } #ifdef LOG_TRANSFERS ( void )gettimeofday( &L1desc[l1descInx].openStartTime, ( struct timezone * )0 ); #endif return 0; }
/* resolveDataObjReplStatus - a dirty copy may be deleted leaving no * dirty copy. In that case, pick the newest copy and mark it dirty */ int resolveDataObjReplStatus( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp ) { int status; dataObjInfo_t *dataObjInfoHead = NULL; dataObjInfo_t *newestDataObjInfo = NULL; dataObjInfo_t *tmpDataObjInfo; if ( getValByKey( &dataObjUnlinkInp->condInput, RESC_NAME_KW ) == NULL && getValByKey( &dataObjUnlinkInp->condInput, REPL_NUM_KW ) == NULL ) { return 0; } status = getDataObjInfo( rsComm, dataObjUnlinkInp, &dataObjInfoHead, ACCESS_DELETE_OBJECT, 1 ); if ( status < 0 ) { return status; } tmpDataObjInfo = dataObjInfoHead; while ( tmpDataObjInfo != NULL ) { if ( tmpDataObjInfo->replStatus == 0 ) { if ( newestDataObjInfo == NULL ) { newestDataObjInfo = tmpDataObjInfo; } else if ( atoi( tmpDataObjInfo->dataModify ) > atoi( newestDataObjInfo->dataModify ) ) { newestDataObjInfo = tmpDataObjInfo; } } else { newestDataObjInfo = NULL; break; } tmpDataObjInfo = tmpDataObjInfo->next; } /* modify the repl status */ if ( newestDataObjInfo != NULL ) { keyValPair_t regParam; char tmpStr[MAX_NAME_LEN]; modDataObjMeta_t modDataObjMetaInp; memset( ®Param, 0, sizeof( regParam ) ); memset( &modDataObjMetaInp, 0, sizeof( modDataObjMetaInp ) ); snprintf( tmpStr, MAX_NAME_LEN, "%d", NEWLY_CREATED_COPY ); addKeyVal( ®Param, REPL_STATUS_KW, tmpStr ); modDataObjMetaInp.dataObjInfo = newestDataObjInfo; modDataObjMetaInp.regParam = ®Param; status = rsModDataObjMeta( rsComm, &modDataObjMetaInp ); clearKeyVal( ®Param ); } freeAllDataObjInfo( dataObjInfoHead ); return status; }
int _rsRmCollRecur( rsComm_t *rsComm, collInp_t *rmCollInp, collOprStat_t **collOprStat ) { int status; ruleExecInfo_t rei; int trashPolicy; dataObjInfo_t *dataObjInfo = NULL; /* check for specColl and permission */ status = resolvePathInSpecColl( rsComm, rmCollInp->collName, WRITE_COLL_PERM, 0, &dataObjInfo ); if ( status < 0 && status != CAT_NO_ROWS_FOUND ) { return status; } if ( status == COLL_OBJ_T && dataObjInfo->specColl != NULL && dataObjInfo->specColl->collClass == LINKED_COLL ) { rstrcpy( rmCollInp->collName, dataObjInfo->objPath, MAX_NAME_LEN ); free( dataObjInfo->specColl ); dataObjInfo->specColl = NULL; } if ( status != COLL_OBJ_T || dataObjInfo->specColl == NULL ) { /* a normal coll */ if ( rmCollInp->oprType != UNREG_OPR && getValByKey( &rmCollInp->condInput, FORCE_FLAG_KW ) == NULL && getValByKey( &rmCollInp->condInput, RMTRASH_KW ) == NULL && getValByKey( &rmCollInp->condInput, ADMIN_RMTRASH_KW ) == NULL ) { initReiWithDataObjInp( &rei, rsComm, NULL ); status = applyRule( "acTrashPolicy", NULL, &rei, NO_SAVE_REI ); trashPolicy = rei.status; if ( trashPolicy != NO_TRASH_CAN ) { status = rsMvCollToTrash( rsComm, rmCollInp ); if ( status >= 0 && collOprStat != NULL ) { if ( *collOprStat == NULL ) { *collOprStat = ( collOprStat_t* )malloc( sizeof( collOprStat_t ) ); memset( *collOprStat, 0, sizeof( collOprStat_t ) ); } ( *collOprStat )->filesCnt = 1; ( *collOprStat )->totalFileCnt = 1; rstrcpy( ( *collOprStat )->lastObjPath, rmCollInp->collName, MAX_NAME_LEN ); } return status; } } } /* got here. will recursively phy delete the collection */ status = _rsPhyRmColl( rsComm, rmCollInp, dataObjInfo, collOprStat ); if ( dataObjInfo != NULL ) { freeDataObjInfo( dataObjInfo ); } return status; }
int fillL1desc (int l1descInx, dataObjInp_t *dataObjInp, dataObjInfo_t *dataObjInfo, int replStatus, rodsLong_t dataSize) { keyValPair_t *condInput = NULL; char *tmpPtr; if (dataObjInp != NULL) { condInput = &dataObjInp->condInput; #if 0 if (getValByKey (&dataObjInp->condInput, REPL_DATA_OBJ_INP_KW) != NULL) { L1desc[l1descInx].dataObjInp = malloc (sizeof (dataObjInp_t)); replDataObjInp (dataObjInp, L1desc[l1descInx].dataObjInp); L1desc[l1descInx].dataObjInpReplFlag = 1; } else { L1desc[l1descInx].dataObjInp = dataObjInp; } #else /* always repl the .dataObjInp */ L1desc[l1descInx].dataObjInp = (dataObjInp_t*)malloc (sizeof (dataObjInp_t)); replDataObjInp (dataObjInp, L1desc[l1descInx].dataObjInp); L1desc[l1descInx].dataObjInpReplFlag = 1; #endif } else { /* XXXX this can be a problem in rsDataObjClose */ L1desc[l1descInx].dataObjInp = NULL; } L1desc[l1descInx].dataObjInfo = dataObjInfo; if (dataObjInp != NULL) { L1desc[l1descInx].oprType = dataObjInp->oprType; } L1desc[l1descInx].replStatus = replStatus; L1desc[l1descInx].dataSize = dataSize; if (condInput != NULL && condInput->len > 0) { if ((tmpPtr = getValByKey (condInput, REG_CHKSUM_KW)) != NULL) { L1desc[l1descInx].chksumFlag = REG_CHKSUM; rstrcpy (L1desc[l1descInx].chksum, tmpPtr, NAME_LEN); } else if ((tmpPtr = getValByKey (condInput, VERIFY_CHKSUM_KW)) != NULL) { L1desc[l1descInx].chksumFlag = VERIFY_CHKSUM; rstrcpy (L1desc[l1descInx].chksum, tmpPtr, NAME_LEN); } } #ifdef LOG_TRANSFERS (void)gettimeofday(&L1desc[l1descInx].openStartTime, (struct timezone *)0); #endif return (0); }
int _call_file_modified_for_replica( rsComm_t* rsComm, regReplica_t* regReplicaInp ) { int status = 0; dataObjInfo_t* destDataObjInfo = regReplicaInp->destDataObjInfo; irods::file_object_ptr file_obj( new irods::file_object( rsComm, destDataObjInfo ) ); char* pdmo_kw = getValByKey( ®ReplicaInp->condInput, IN_PDMO_KW ); if ( pdmo_kw != NULL ) { file_obj->in_pdmo( pdmo_kw ); } irods::error ret = fileModified( rsComm, file_obj ); if ( !ret.ok() ) { std::stringstream msg; msg << __FUNCTION__; msg << " - Failed to signal resource that the data object \""; msg << destDataObjInfo->objPath; msg << "\" was registered"; ret = PASSMSG( msg.str(), ret ); irods::log( ret ); status = ret.code(); } return status; } // _call_file_modified_for_replica
int rsNcGetVarsByType (rsComm_t *rsComm, ncGetVarInp_t *ncGetVarInp, ncGetVarOut_t **ncGetVarOut) { int l1descInx; int status = 0; if (getValByKey (&ncGetVarInp->condInput, NATIVE_NETCDF_CALL_KW) != NULL) { /* just do nc_inq_YYYY */ status = _rsNcGetVarsByType (ncGetVarInp->ncid, ncGetVarInp, ncGetVarOut); return status; } l1descInx = ncGetVarInp->ncid; if (l1descInx < 2 || l1descInx >= NUM_L1_DESC) { rodsLog (LOG_ERROR, "rsNcGetVarsByType: l1descInx %d out of range", l1descInx); return (SYS_FILE_DESC_OUT_OF_RANGE); } if (L1desc[l1descInx].inuseFlag != FD_INUSE) return BAD_INPUT_DESC_INDEX; if (L1desc[l1descInx].openedAggInfo.ncAggInfo != NULL) { status = rsNcGetVarsByTypeForColl (rsComm, ncGetVarInp, ncGetVarOut); } else { status = rsNcGetVarsByTypeForObj (rsComm, ncGetVarInp, ncGetVarOut); } return status; }
int getSetValFromKeyValPair(char *varMap, keyValPair_t **inptr, char **varValue, void *newVarValue) { char varName[NAME_LEN]; char *varMapCPtr; char *Cptr; int i; keyValPair_t *ptr; ptr = *inptr; if (varMap == NULL) { i = getSetLeafValue(varValue,inptr, (void **) inptr, (char*)newVarValue, RE_PTR); return(i); } if (ptr == NULL) return(NULL_VALUE_ERR); i = getVarNameFromVarMap(varMap, varName, &varMapCPtr); if (i != 0) return(i); Cptr = (char *) getValByKey(ptr,varName); /**** may need to do a st value by key ****/ if (Cptr == NULL) return(UNMATCHED_KEY_OR_INDEX); *varValue = Cptr; return(0); }
/* rsDataCopy - Do the copy data transfer. * Input - * dataCopyInp_t dataCopyInp: * dataOprInp: - mostly setup by initDataOprInp() * int oprType - SAME_HOST_COPY_OPR, COPY_TO_REM_OPR, COPY_TO_LOCAL_OPR * int numThreads * int srcL3descInx - the source L3descInx * int destL3descInx - the target L3descInx * int srcRescTypeInx; * int destRescTypeInx; * rodsLong_t offset * rodsLong_t dataSize * keyValPair_t condInput - valid input - * EXEC_LOCALLY_KW - all operations except remote-remote copy * have the keyword set. * * portalOprOut_t portalOprOut - the resource server portal info. */ int rsDataCopy( rsComm_t *rsComm, dataCopyInp_t *dataCopyInp ) { int status; int l3descInx; rodsServerHost_t *rodsServerHost; dataOprInp_t *dataOprInp; dataOprInp = &dataCopyInp->dataOprInp; if ( getValByKey( &dataOprInp->condInput, EXEC_LOCALLY_KW ) != NULL || dataCopyInp->portalOprOut.numThreads == 0 ) { /* XXXXX do it locally if numThreads == 0 */ status = _rsDataCopy( rsComm, dataCopyInp ); } else { if ( dataOprInp->destL3descInx > 0 ) { l3descInx = dataOprInp->destL3descInx; } else { l3descInx = dataOprInp->srcL3descInx; } rodsServerHost = FileDesc[l3descInx].rodsServerHost; if ( rodsServerHost != NULL && rodsServerHost->localFlag != LOCAL_HOST ) { addKeyVal( &dataOprInp->condInput, EXEC_LOCALLY_KW, "" ); status = remoteDataCopy( rsComm, dataCopyInp, rodsServerHost ); clearKeyVal( &dataOprInp->condInput ); } else { status = _rsDataCopy( rsComm, dataCopyInp ); } } return status; }
int rsNcGetVarsByType( rsComm_t *rsComm, ncGetVarInp_t *ncGetVarInp, ncGetVarOut_t **ncGetVarOut ) { int l1descInx; int status = 0; if ( getValByKey( &ncGetVarInp->condInput, NATIVE_NETCDF_CALL_KW ) != NULL ) { /* just do nc_inq_YYYY */ status = _rsNcGetVarsByType( ncGetVarInp->ncid, ncGetVarInp, ncGetVarOut ); return status; } l1descInx = ncGetVarInp->ncid; l1desc_t& my_desc = irods::get_l1desc( l1descInx ); if ( l1descInx < 2 || l1descInx >= NUM_L1_DESC ) { rodsLog( LOG_ERROR, "rsNcGetVarsByType: l1descInx %d out of range", l1descInx ); return ( SYS_FILE_DESC_OUT_OF_RANGE ); } if ( my_desc.inuseFlag != FD_INUSE ) { return BAD_INPUT_DESC_INDEX; } openedAggInfo_t * openedAggInfo = boost::any_cast< openedAggInfo_t >( &my_desc.pluginData ); if (openedAggInfo != NULL && openedAggInfo->ncAggInfo != NULL ) { status = _rsNcGetVarsByTypeForColl( rsComm, ncGetVarInp, ncGetVarOut ); } else { status = _rsNcGetVarsByTypeForObj( rsComm, ncGetVarInp, ncGetVarOut ); } return status; }
// =-=-=-=-=-=-=- // JMC - backport 4590 int procDataObjOpenForWrite( rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t **dataObjInfoHead, dataObjInfo_t **compDataObjInfo ) { int status = 0; /* put the copy with destResc on top */ status = requeDataObjInfoByDestResc( dataObjInfoHead, &dataObjInp->condInput, 1, 1 ); /* status < 0 means there is no copy in the DEST_RESC */ if ( status < 0 && ( *dataObjInfoHead )->specColl == NULL && getValByKey( &dataObjInp->condInput, DEST_RESC_NAME_KW ) != NULL ) { /* we don't have a copy, so create an empty dataObjInfo */ status = createEmptyRepl( rsComm, dataObjInp, dataObjInfoHead ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "procDataObjForOpenWrite: createEmptyRepl of %s failed", ( *dataObjInfoHead )->objPath ); return status; } } else { /* The target data object exists */ status = 0; } if ( *compDataObjInfo != NULL ) { dequeDataObjInfo( dataObjInfoHead, *compDataObjInfo ); } return status; }
int rsDataGet( rsComm_t *rsComm, dataOprInp_t *dataOprInp, portalOprOut_t **portalOprOut ) { int status; int remoteFlag; int l3descInx; rodsServerHost_t *rodsServerHost; l3descInx = dataOprInp->srcL3descInx; if ( getValByKey( &dataOprInp->condInput, EXEC_LOCALLY_KW ) != NULL ) { remoteFlag = LOCAL_HOST; } else { rodsServerHost = FileDesc[l3descInx].rodsServerHost; if ( rodsServerHost == NULL ) { rodsLog( LOG_NOTICE, "rsDataGet: NULL rodsServerHost" ); return SYS_INTERNAL_NULL_INPUT_ERR; } remoteFlag = rodsServerHost->localFlag; } if ( remoteFlag == LOCAL_HOST ) { status = _rsDataGet( rsComm, dataOprInp, portalOprOut ); } else { addKeyVal( &dataOprInp->condInput, EXEC_LOCALLY_KW, "" ); status = remoteDataGet( rsComm, dataOprInp, portalOprOut, rodsServerHost ); clearKeyVal( &dataOprInp->condInput ); } return status; }
irods::error operator()( irods::plugin_context&, rsComm_t* _comm, types_t... _t ) { #ifdef IRODS_ENABLE_SYSLOG bool logger_updated = false; const auto update_logger = [&logger_updated](auto&& _arg) { // If there exists multiple objects containing verbose flags, // then only allow one update. What happens if subsequent calls // are made (hopefully, the condition objects are passed through // unchanged)? if (logger_updated) { return; } // _arg's type will be deduced as <type>& if it's an lvalue. // For pointers, this means the type will we T*&. Therefore, we // must either remove the reference or add a reference so that // std::is_same compares the correct types. using T = std::remove_reference_t<decltype(_arg)>; if constexpr (std::is_same_v<dataObjInp_t*, T>) { logger_updated = true; const auto* value = getValByKey(&_arg->condInput, VERY_VERBOSE_KW); irods::experimental::log::write_to_error_object(value); } else if constexpr (std::is_same_v<dataObjCopyInp_t*, T>)
void createKVP(struct map *m, char *key, char *val){ if(m->key == NULL){ m->key = (char *) malloc(sizeof(strlen(key))); m->val = (char *) malloc(sizeof(strlen(val))); strcpy(m->key,key); strcpy(m->val,val); m->next = NULL; return; } if(getValByKey(m,key) != NULL){ modifyValByKey(m,key,val); return; } struct map *temp,*curr; temp=m; while(temp->next != NULL){ temp=temp->next; } curr = (struct map *)malloc(sizeof(struct map)); curr->key = (char *) malloc(sizeof(strlen(key))); curr->val = (char *) malloc(sizeof(strlen(val))); strcpy(curr->key,key); strcpy(curr->val,val); curr->next=NULL; temp->next=curr; }
/// @brief Selects the dataObjInfo in the specified list whose resc hier matches that of the cond input irods::error selectObjInfo( dataObjInfo_t * _dataObjInfoHead, keyValPair_t* _condInput, dataObjInfo_t** _rtn_dataObjInfo ) { irods::error result = SUCCESS(); *_rtn_dataObjInfo = NULL; char* resc_hier = getValByKey( _condInput, RESC_HIER_STR_KW ); if ( !resc_hier ) { std::stringstream msg; msg << __FUNCTION__; msg << " - No resource hierarchy specified in keywords."; result = ERROR( SYS_INVALID_INPUT_PARAM, msg.str() ); } else { for ( dataObjInfo_t* dataObjInfo = _dataObjInfoHead; result.ok() && *_rtn_dataObjInfo == NULL && dataObjInfo != NULL; dataObjInfo = dataObjInfo->next ) { if ( strcmp( resc_hier, dataObjInfo->rescHier ) == 0 ) { *_rtn_dataObjInfo = dataObjInfo; } } if ( *_rtn_dataObjInfo == NULL ) { std::stringstream msg; msg << __FUNCTION__; msg << " - Failed to find a data obj matching resource hierarchy: \""; msg << resc_hier; msg << "\""; result = ERROR( HIERARCHY_ERROR, msg.str() ); } } return result; }
int rsRuleExecSubmit (rsComm_t *rsComm, ruleExecSubmitInp_t *ruleExecSubmitInp, char **ruleExecId) { rodsServerHost_t *rodsServerHost; int status; *ruleExecId = NULL; if (ruleExecSubmitInp == NULL || ruleExecSubmitInp->packedReiAndArgBBuf == NULL || ruleExecSubmitInp->packedReiAndArgBBuf->len <= 0 || ruleExecSubmitInp->packedReiAndArgBBuf->buf == NULL) { rodsLog(LOG_NOTICE, "rsRuleExecSubmit error. NULL input"); return (SYS_INTERNAL_NULL_INPUT_ERR); } #if 0 status = getAndConnRcatHost(rsComm, MASTER_RCAT, NULL, &rodsServerHost); #else status = getAndConnReHost (rsComm, &rodsServerHost); #endif if (status < 0) { return(status); } if (rodsServerHost->localFlag == LOCAL_HOST) { #ifdef RODS_CAT status = _rsRuleExecSubmit (rsComm, ruleExecSubmitInp); if (status >= 0) { *ruleExecId = strdup (ruleExecSubmitInp->ruleExecId); } #else rodsLog(LOG_NOTICE, "rsRuleExecSubmit error. ICAT is not configured on this host"); return (SYS_NO_ICAT_SERVER_ERR); #endif } else { if (getValByKey (&ruleExecSubmitInp->condInput, EXEC_LOCALLY_KW) != NULL) { rodsLog (LOG_ERROR, "rsRuleExecSubmit: reHost config error. reServer not running locally"); return SYS_CONFIG_FILE_ERR; } else { addKeyVal (&ruleExecSubmitInp->condInput, EXEC_LOCALLY_KW, ""); } status = rcRuleExecSubmit(rodsServerHost->conn, ruleExecSubmitInp, ruleExecId); } if (status < 0) { rodsLog (LOG_ERROR, "rsRuleExecSubmit: rcRuleExecSubmit failed, status = %d", status); } return (status); }
int _rsRegColl (rsComm_t *rsComm, collInp_t *collCreateInp) { #ifdef RODS_CAT int status; collInfo_t collInfo; char *tmpStr; memset (&collInfo, 0, sizeof (collInfo)); rstrcpy (collInfo.collName, collCreateInp->collName, MAX_NAME_LEN); if ((tmpStr = getValByKey (&collCreateInp->condInput, COLLECTION_TYPE_KW)) != NULL) { rstrcpy (collInfo.collType, tmpStr, NAME_LEN); if ((tmpStr = getValByKey (&collCreateInp->condInput, COLLECTION_INFO1_KW)) != NULL) { rstrcpy (collInfo.collInfo1, tmpStr, NAME_LEN); } if ((tmpStr = getValByKey (&collCreateInp->condInput, COLLECTION_INFO2_KW)) != NULL) { rstrcpy (collInfo.collInfo2, tmpStr, NAME_LEN); } } #ifdef FILESYSTEM_META /* if the "collection" keyword has been set, it provides the name of another collection to retrieve directory metadata from (usually during a icp or irsync operation */ tmpStr = getValByKey(&collCreateInp->condInput, COLLECTION_KW); if (tmpStr != NULL) { rsQueryDirectoryMeta(rsComm, tmpStr, &collInfo.condInput); } else { /* otherwise copy over the source directory metadata if provided */ copyFilesystemMetadata(&collCreateInp->condInput, &collInfo.condInput); } #endif /* FILESYSTEM_META */ status = chlRegColl (rsComm, &collInfo); return (status); #else return (SYS_NO_RCAT_SERVER_ERR); #endif }
int filePathRegRepl (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath, rescInfo_t *rescInfo) { dataObjInfo_t destDataObjInfo, *dataObjInfoHead = NULL; regReplica_t regReplicaInp; char *rescGroupName = NULL; int status; status = getDataObjInfo (rsComm, phyPathRegInp, &dataObjInfoHead, ACCESS_READ_OBJECT, 0); if (status < 0) { rodsLog (LOG_ERROR, "filePathRegRepl: getDataObjInfo for %s", phyPathRegInp->objPath); return (status); } status = sortObjInfoForOpen (rsComm, &dataObjInfoHead, NULL, 0); if (status < 0) return status; destDataObjInfo = *dataObjInfoHead; rstrcpy (destDataObjInfo.filePath, filePath, MAX_NAME_LEN); destDataObjInfo.rescInfo = rescInfo; rstrcpy (destDataObjInfo.rescName, rescInfo->rescName, NAME_LEN); if ((rescGroupName = getValByKey (&phyPathRegInp->condInput, RESC_GROUP_NAME_KW)) != NULL) { rstrcpy (destDataObjInfo.rescGroupName, rescGroupName, NAME_LEN); } memset (®ReplicaInp, 0, sizeof (regReplicaInp)); regReplicaInp.srcDataObjInfo = dataObjInfoHead; regReplicaInp.destDataObjInfo = &destDataObjInfo; if (getValByKey (&phyPathRegInp->condInput, SU_CLIENT_USER_KW) != NULL) { addKeyVal (®ReplicaInp.condInput, SU_CLIENT_USER_KW, ""); addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, ""); } else if (getValByKey (&phyPathRegInp->condInput, IRODS_ADMIN_KW) != NULL) { addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, ""); } status = rsRegReplica (rsComm, ®ReplicaInp); clearKeyVal (®ReplicaInp.condInput); freeAllDataObjInfo (dataObjInfoHead); return status; }
int initDataObjInfoWithInp( dataObjInfo_t *dataObjInfo, dataObjInp_t *dataObjInp ) { char *rescName = 0, *dataType = 0, *filePath = 0; keyValPair_t *condInput = 0; condInput = &dataObjInp->condInput; memset( dataObjInfo, 0, sizeof( dataObjInfo_t ) ); rstrcpy( dataObjInfo->objPath, dataObjInp->objPath, MAX_NAME_LEN ); rescName = getValByKey( condInput, RESC_NAME_KW ); if ( rescName != NULL ) { rstrcpy( dataObjInfo->rescName, rescName, NAME_LEN ); } char* rescHier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ); if ( rescHier ) { rstrcpy( dataObjInfo->rescHier, rescHier, MAX_NAME_LEN ); } else { rstrcpy( dataObjInfo->rescHier, rescName, MAX_NAME_LEN ); // in kw else } irods::error ret = resc_mgr.hier_to_leaf_id(dataObjInfo->rescHier,dataObjInfo->rescId); if( !ret.ok() ) { irods::log(PASS(ret)); } snprintf( dataObjInfo->dataMode, SHORT_STR_LEN, "%d", dataObjInp->createMode ); dataType = getValByKey( condInput, DATA_TYPE_KW ); if ( dataType != NULL ) { rstrcpy( dataObjInfo->dataType, dataType, NAME_LEN ); } else { rstrcpy( dataObjInfo->dataType, "generic", NAME_LEN ); } filePath = getValByKey( condInput, FILE_PATH_KW ); if ( filePath != NULL ) { rstrcpy( dataObjInfo->filePath, filePath, MAX_NAME_LEN ); } return 0; }
/** * \fn rcExecMyRule( rcComm_t *conn, execMyRuleInp_t *execMyRuleInp, msParamArray_t **outParamArray ) * * \brief Execute my rule. * * \user client * * \ingroup rules * * \since 1.0 * * * \remark none * * \note none * * \param[in] conn - A rcComm_t connection handle to the server. * \param[in] execMyRuleInp * \param[out] outParamArray * * \return integer * \retval 0 on success. * \sideeffect none * \pre none * \post none * \sa none **/ int rcExecMyRule( rcComm_t *conn, execMyRuleInp_t *execMyRuleInp, msParamArray_t **outParamArray ) { int status = procApiRequest( conn, EXEC_MY_RULE_AN, execMyRuleInp, NULL, ( void ** )outParamArray, NULL ); while ( status == SYS_SVR_TO_CLI_MSI_REQUEST ) { /* it is a server request */ msParam_t *myParam = NULL, *putParam = NULL; if ( ( myParam = putParam = getMsParamByLabel( *outParamArray, CL_PUT_ACTION ) ) || ( myParam = getMsParamByLabel( *outParamArray, CL_GET_ACTION ) ) ) { //putParam is non-null if it's a put, null if it's a get dataObjInp_t * dataObjInp = ( dataObjInp_t * ) myParam->inOutStruct; char * locFilePath; char myDir[MAX_NAME_LEN], myFile[MAX_NAME_LEN]; // locFilePath should be the return of getValByKey if it exists, // otherwise use the filename from splitPathByKey if ( ( locFilePath = getValByKey( &dataObjInp->condInput, LOCAL_PATH_KW ) ) || ( ( status = splitPathByKey( dataObjInp->objPath, myDir, MAX_NAME_LEN, myFile, MAX_NAME_LEN, '/' ) ) >= 0 && ( locFilePath = ( char * ) myFile ) ) ) { status = putParam ? rcDataObjPut( conn, dataObjInp, locFilePath ) : rcDataObjGet( conn, dataObjInp, locFilePath ); rcOprComplete( conn, status ); } else { rodsLogError( LOG_ERROR, status, "rcExecMyRule: splitPathByKey for %s error", dataObjInp->objPath ); rcOprComplete( conn, USER_FILE_DOES_NOT_EXIST ); } clearKeyVal( &dataObjInp->condInput ); } else { rcOprComplete( conn, SYS_SVR_TO_CLI_MSI_NO_EXIST ); } /* free outParamArray */ clearMsParamArray( *outParamArray, 1 ); free( *outParamArray ); *outParamArray = NULL; /* read the reply from the earlier call */ status = branchReadAndProcApiReply( conn, EXEC_MY_RULE_AN, ( void ** )outParamArray, NULL ); if ( status < 0 ) { rodsLogError( LOG_DEBUG, status, "rcExecMyRule: readAndProcApiReply failed. status = %d", status ); } } return status; }
int resolveLinkedPath( rsComm_t *rsComm, char *objPath, specCollCache_t **specCollCache, keyValPair_t *condInput ) { int linkCnt = 0; specColl_t *curSpecColl; char prevNewPath[MAX_NAME_LEN]; specCollCache_t *oldSpecCollCache = NULL; int status; *specCollCache = NULL; if ( getValByKey( condInput, TRANSLATED_PATH_KW ) != NULL ) { return 0; } addKeyVal( condInput, TRANSLATED_PATH_KW, "" ); while ( getSpecCollCache( rsComm, objPath, 0, specCollCache ) >= 0 && ( *specCollCache )->specColl.collClass == LINKED_COLL ) { oldSpecCollCache = *specCollCache; if ( linkCnt++ >= MAX_LINK_CNT ) { rodsLog( LOG_ERROR, "resolveLinkedPath: linkCnt for %s exceeds %d", objPath, MAX_LINK_CNT ); return SYS_LINK_CNT_EXCEEDED_ERR; } curSpecColl = &( *specCollCache )->specColl; if ( strcmp( curSpecColl->collection, objPath ) == 0 && getValByKey( condInput, NO_TRANSLATE_LINKPT_KW ) != NULL ) { return 0; } rstrcpy( prevNewPath, objPath, MAX_NAME_LEN ); status = getMountedSubPhyPath( curSpecColl->collection, curSpecColl->phyPath, prevNewPath, objPath ); if ( status < 0 ) { return status; } } if ( *specCollCache == NULL ) { *specCollCache = oldSpecCollCache; } return linkCnt; }
int openSpecColl( rsComm_t *rsComm, dataObjInp_t *dataObjInp, int parentInx ) { int specCollInx; dataObjInfo_t *dataObjInfo = NULL; int status; int l3descInx; status = resolvePathInSpecColl( rsComm, dataObjInp->objPath, //READ_COLL_PERM, 0, &dataObjInfo); UNKNOWN_COLL_PERM, 0, &dataObjInfo ); if ( status < 0 || NULL == dataObjInfo ) { // JMC cppcheck - nullptr rodsLog( LOG_NOTICE, "rsQuerySpecColl: resolveSpecColl error for %s, status = %d", dataObjInp->objPath, status ); return status; } if ( dataObjInfo->specColl->collClass == LINKED_COLL ) { rodsLog( LOG_ERROR, "rsQuerySpecColl: %s is a linked collection", dataObjInp->objPath ); return SYS_UNKNOWN_SPEC_COLL_CLASS; } char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ); if ( resc_hier ) { strncpy( dataObjInfo->rescHier, resc_hier, MAX_NAME_LEN ); irods::error ret = resc_mgr.hier_to_leaf_id(resc_hier,dataObjInfo->rescId); if( !ret.ok() ) { irods::log(PASS(ret)); } } l3descInx = l3Opendir( rsComm, dataObjInfo ); if ( l3descInx < 0 ) { rodsLog( LOG_NOTICE, "openSpecColl: specCollOpendir error for %s, status = %d", dataObjInp->objPath, l3descInx ); return l3descInx; } specCollInx = allocSpecCollDesc(); if ( specCollInx < 0 ) { freeDataObjInfo( dataObjInfo ); return specCollInx; } SpecCollDesc[specCollInx].l3descInx = l3descInx; SpecCollDesc[specCollInx].dataObjInfo = dataObjInfo; SpecCollDesc[specCollInx].parentInx = parentInx; return specCollInx; }
int rsPhyPathReg (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp) { int status; if (getValByKey (&phyPathRegInp->condInput, NO_CHK_FILE_PERM_KW) != NULL && rsComm->proxyUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) { return SYS_NO_API_PRIV; } status = irsPhyPathReg (rsComm, phyPathRegInp); return (status); }
int rsGetHostForGet( rsComm_t* rsComm, dataObjInp_t* dataObjInp, char** outHost ) { // =-=-=-=-=-=-=- // default behavior *outHost = strdup( THIS_ADDRESS ); // =-=-=-=-=-=-=- // working on the "home zone", determine if we need to redirect to a different // server in this zone for this operation. if there is a RESC_HIER_STR_KW then // we know that the redirection decision has already been made if ( isColl( rsComm, dataObjInp->objPath, NULL ) < 0 ) { std::string hier; if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) { irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm, dataObjInp, hier ); if ( !ret.ok() ) { std::stringstream msg; msg << __FUNCTION__; msg << " :: failed in irods::resolve_resource_hierarchy for ["; msg << dataObjInp->objPath << "]"; irods::log( PASSMSG( msg.str(), ret ) ); return ret.code(); } // =-=-=-=-=-=-=- // we resolved the redirect and have a host, set the hier str for subsequent // api calls, etc. addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() ); } // if keyword // =-=-=-=-=-=-=- // extract the host location from the resource hierarchy std::string location; irods::error ret = irods::get_loc_for_hier_string( hier, location ); if ( !ret.ok() ) { irods::log( PASSMSG( "rsGetHostForGet - failed in get_loc_for_hier_string", ret ) ); return -1; } // =-=-=-=-=-=-=- // set the out variable *outHost = strdup( location.c_str() ); } // if not a collection return 0; }
int _rsRegReplica (rsComm_t *rsComm, regReplica_t *regReplicaInp) { #ifdef RODS_CAT int status; dataObjInfo_t *srcDataObjInfo; dataObjInfo_t *destDataObjInfo; int savedClientAuthFlag; srcDataObjInfo = regReplicaInp->srcDataObjInfo; destDataObjInfo = regReplicaInp->destDataObjInfo; #if 0 status = checkDupReplica (rsComm, srcDataObjInfo->dataId, destDataObjInfo->rescName, destDataObjInfo->filePath); if (status >= 0) { destDataObjInfo->replNum = status; return status; } #endif if (getValByKey (®ReplicaInp->condInput, SU_CLIENT_USER_KW) != NULL) { savedClientAuthFlag = rsComm->clientUser.authInfo.authFlag; rsComm->clientUser.authInfo.authFlag = LOCAL_PRIV_USER_AUTH; status = chlRegReplica (rsComm, srcDataObjInfo, destDataObjInfo, ®ReplicaInp->condInput); /* restore it */ rsComm->clientUser.authInfo.authFlag = savedClientAuthFlag; } else { status = chlRegReplica (rsComm, srcDataObjInfo, destDataObjInfo, ®ReplicaInp->condInput); if (status >= 0) status = destDataObjInfo->replNum; } if (status == CAT_SUCCESS_BUT_WITH_NO_INFO || status == CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME) { int status2; /* register a repl with a copy with the same resource and phyPaht. * could be caused by 2 staging at the same time */ status2 = checkDupReplica (rsComm, srcDataObjInfo->dataId, destDataObjInfo->rescName, destDataObjInfo->filePath); if (status2 >= 0) { destDataObjInfo->replNum = status2; destDataObjInfo->dataId = srcDataObjInfo->dataId; return status2; } } return (status); #else return (SYS_NO_RCAT_SERVER_ERR); #endif }
int rsSpecificQuery( rsComm_t *rsComm, specificQueryInp_t *specificQueryInp, genQueryOut_t **genQueryOut ) { rodsServerHost_t *rodsServerHost; int status; char *zoneHint = ""; /* zoneHint = getZoneHintForGenQuery (genQueryInp); (need something like this?) */ zoneHint = getValByKey( &specificQueryInp->condInput, ZONE_KW ); status = getAndConnRcatHost( rsComm, SLAVE_RCAT, ( const char* )zoneHint, &rodsServerHost ); if ( status < 0 ) { return status; } if ( rodsServerHost->localFlag == LOCAL_HOST ) { std::string svc_role; irods::error ret = get_catalog_service_role(svc_role); if(!ret.ok()) { irods::log(PASS(ret)); return ret.code(); } if( irods::CFG_SERVICE_ROLE_PROVIDER == svc_role ) { status = _rsSpecificQuery( rsComm, specificQueryInp, genQueryOut ); } else if( irods::CFG_SERVICE_ROLE_CONSUMER == svc_role ) { rodsLog( LOG_NOTICE, "rsSpecificQuery error. RCAT is not configured on this host" ); return SYS_NO_RCAT_SERVER_ERR; } else { rodsLog( LOG_ERROR, "role not supported [%s]", svc_role.c_str() ); status = SYS_SERVICE_ROLE_NOT_SUPPORTED; } } else { status = rcSpecificQuery( rodsServerHost->conn, specificQueryInp, genQueryOut ); } if ( status < 0 && status != CAT_NO_ROWS_FOUND ) { rodsLog( LOG_NOTICE, "rsSpecificQuery: rcSpecificQuery failed, status = %d", status ); } return status; }
int svrUnregColl( rsComm_t *rsComm, collInp_t *rmCollInp ) { int status; #ifdef RODS_CAT collInfo_t collInfo; #endif rodsServerHost_t *rodsServerHost = NULL; status = getAndConnRcatHost( rsComm, MASTER_RCAT, ( const char* )rmCollInp->collName, &rodsServerHost ); if ( status < 0 || NULL == rodsServerHost ) { // JMC cppcheck - nullptr return status; } if ( rodsServerHost->localFlag == LOCAL_HOST ) { #ifdef RODS_CAT memset( &collInfo, 0, sizeof( collInfo ) ); rstrcpy( collInfo.collName, rmCollInp->collName, MAX_NAME_LEN ); if ( getValByKey( &rmCollInp->condInput, ADMIN_RMTRASH_KW ) != NULL ) { status = chlDelCollByAdmin( rsComm, &collInfo ); if ( status >= 0 ) { chlCommit( rsComm ); } } else { status = chlDelColl( rsComm, &collInfo ); } #else status = SYS_NO_RCAT_SERVER_ERR; #endif } else { collOprStat_t *collOprStat = NULL;; addKeyVal( &rmCollInp->condInput, UNREG_COLL_KW, "" ); status = _rcRmColl( rodsServerHost->conn, rmCollInp, &collOprStat ); if ( collOprStat != NULL ) { free( collOprStat ); } } return status; }