C++ rodsLogError函数代码示例

int
bulkPutDirUtil( rcComm_t **myConn, char *srcDir, char *targColl,
                rodsEnv *myRodsEnv, rodsArguments_t *rodsArgs, dataObjInp_t *dataObjOprInp,
                bulkOprInp_t *bulkOprInp, rodsRestart_t *rodsRestart ) {
    int status;
    bulkOprInfo_t bulkOprInfo;

    /* do large files first */
    bzero( &bulkOprInfo, sizeof( bulkOprInfo ) );
    bulkOprInfo.flags = BULK_OPR_LARGE_FILES;

    status = putDirUtil( myConn, srcDir, targColl, myRodsEnv, rodsArgs,
                         dataObjOprInp, bulkOprInp, rodsRestart, &bulkOprInfo );

    if ( status < 0 ) {
        rodsLogError( LOG_ERROR, status,
                      "bulkPutDirUtil: Large files bulkPut error for %s", srcDir );
        return status;
    }

    /* now bulk put the small files */
    bzero( &bulkOprInfo, sizeof( bulkOprInfo ) );
    bulkOprInfo.flags = BULK_OPR_SMALL_FILES;
    rstrcpy( dataObjOprInp->objPath, targColl, MAX_NAME_LEN );
    rstrcpy( bulkOprInp->objPath, targColl, MAX_NAME_LEN );
    bulkOprInfo.bytesBuf.len = 0;
    bulkOprInfo.bytesBuf.buf = malloc( BULK_OPR_BUF_SIZE );

    status = putDirUtil( myConn, srcDir, targColl, myRodsEnv, rodsArgs,
                         dataObjOprInp, bulkOprInp, rodsRestart, &bulkOprInfo );

    if ( status < 0 ) {
        rodsLogError( LOG_ERROR, status,
                      "bulkPutDirUtil: Small files bulkPut error for %s", srcDir );
        return status;
    }

    if ( bulkOprInfo.count > 0 ) {
        status = sendBulkPut( *myConn, bulkOprInp, &bulkOprInfo, rodsArgs );
        if ( status >= 0 ) {
            if ( rodsRestart->fd > 0 ) {
                rodsRestart->curCnt += bulkOprInfo.count;
                /* last entry. */
                writeRestartFile( rodsRestart, bulkOprInfo.cachedTargPath );
            }
        }
        else {
            rodsLogError( LOG_ERROR, status,
                          "bulkPutDirUtil: tarAndBulkPut error for %s",
                          bulkOprInfo.phyBunDir );
        }
        clearBulkOprInfo( &bulkOprInfo );
        if ( bulkOprInfo.bytesBuf.buf != NULL ) {
            free( bulkOprInfo.bytesBuf.buf );
            bulkOprInfo.bytesBuf.buf = NULL;
        }

    }
    return status;
}

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;
}

/* close a iFuse file */
int
ifuseClose (iFuseDesc_t *desc)
{
	int status;

    LOCK_STRUCT(*desc);

	status = _ifuseFlush(desc);
	if(status < 0) {
		rodsLogError(LOG_ERROR, status, "ifuseClose: flush of %s error",
				desc->localPath);

	}
	status = ifuseFileCacheClose(desc->fileCache);
	if(status < 0) {
		rodsLogError(LOG_ERROR, status, "ifuseClose: close of %s error",
				desc->localPath);

	}
	status = _freeIFuseDesc(desc);

	UNLOCK_STRUCT(*desc);
	if(status < 0) {
		rodsLogError(LOG_ERROR, status, "ifuseClose: free desc struct error",
				desc->localPath);

	}

	return status;
}

int
rsAcceptConn( rsComm_t *svrComm ) {
    socklen_t len = sizeof( svrComm->remoteAddr );

    const int saved_socket_flags = fcntl( svrComm->sock, F_GETFL );
    int status = fcntl( svrComm->sock, F_SETFL, saved_socket_flags | O_NONBLOCK );
    if ( status < 0 ) {
        rodsLogError( LOG_NOTICE, status, "failed to set flags with nonblock on fnctl with status %d", status );
    }
    const int newSock = accept( svrComm->sock, ( struct sockaddr * ) &svrComm->remoteAddr, &len );
    status = fcntl( svrComm->sock, F_SETFL, saved_socket_flags );
    if ( status < 0 ) {
        rodsLogError( LOG_NOTICE, status, "failed to revert flags on fnctl with status %d", status );
    }

    if ( newSock < 0 ) {
        const int status = SYS_SOCK_ACCEPT_ERR - errno;
        rodsLogError( LOG_NOTICE, status,
                      "rsAcceptConn: accept error for socket %d, status = %d",
                      svrComm->sock, status );
        return newSock;
    }
    rodsSetSockOpt( newSock, svrComm->windowSize );

    return newSock;
}

int
renamePreloadedCache (const char *fromPath, const char *toPath) {
    int status;
    char fromiRODSPath[MAX_NAME_LEN];
    char toiRODSPath[MAX_NAME_LEN];

    status = _getiRODSPath(fromPath, fromiRODSPath);
    if(status < 0) {
        rodsLogError(LOG_ERROR, status, "renamePreloadedCache: _getiRODSPath error.");
        rodsLog (LOG_ERROR, "renamePreloadedCache: failed to get iRODS path - %s", fromPath);
        return status;
    }

    status = _getiRODSPath(toPath, toiRODSPath);
    if(status < 0) {
        rodsLogError(LOG_ERROR, status, "renamePreloadedCache: _getiRODSPath error.");
        rodsLog (LOG_ERROR, "renamePreloadedCache: failed to get iRODS path - %s", toPath);
        return status;
    }

    LOCK(PreloadLock);

    status = _renameCache(fromiRODSPath, toiRODSPath);

    UNLOCK(PreloadLock);

    return status;
}

int
mvUtil( rcComm_t *conn, rodsArguments_t *myRodsArgs, rodsPathInp_t *rodsPathInp ) {
    if ( rodsPathInp == NULL ) {
        return USER__NULL_INPUT_ERR;
    }

    dataObjCopyInp_t dataObjRenameInp;
    initCondForMv( &dataObjRenameInp );

    int savedStatus = resolveRodsTarget( conn, rodsPathInp, MOVE_OPR );
    if ( savedStatus < 0 ) {
        rodsLogError( LOG_ERROR, savedStatus,
                      "mvUtil: resolveRodsTarget error, status = %d", savedStatus );
        return savedStatus;
    }

    for ( int i = 0; i < rodsPathInp->numSrc; i++ ) {
        rodsPath_t * targPath = &rodsPathInp->targPath[i];

        int status = mvObjUtil( conn, rodsPathInp->srcPath[i].outPath,
                                targPath->outPath, targPath->objType, myRodsArgs,
                                &dataObjRenameInp );

        /* XXXX may need to return a global status */
        if ( status < 0 &&
                status != CAT_NO_ROWS_FOUND ) {
            rodsLogError( LOG_ERROR, status,
                          "mvUtil: mv error for %s, status = %d",
                          targPath->outPath, status );
            savedStatus = status;
        }
    }
    return savedStatus;
}

static int
_completeDownload(const char *workPath, const char *cachePath, struct stat *stbuf) {
    int status;
    struct utimbuf amtime;

    if (workPath == NULL || cachePath == NULL || stbuf == NULL) {
        rodsLog (LOG_ERROR, "_completeDownload: input workPath or cachePath or stbuf is NULL");
        return (SYS_INTERNAL_NULL_INPUT_ERR);
    }

    //amtime.actime = stbuf->st_atime;
    amtime.actime = convTime(getCurrentTime());
    amtime.modtime = stbuf->st_mtime;

    // set last access time and modified time the same as the original file
    status = utime(workPath, &amtime);
    if(status < 0) {
        rodsLogError(LOG_ERROR, status, "_completeDownload: utime error.");
        return status;
    }

    // change the name
    status = rename(workPath, cachePath);
    if(status < 0) {
        rodsLogError(LOG_ERROR, status, "_completeDownload: rename error.");
        return status;
    }

    return (0);
}

int
moveToPreloadedDir (const char *path, const char *iRODSPath) {
    int status;
    char preloadCachePath[MAX_NAME_LEN];

    if (path == NULL || iRODSPath == NULL) {
        rodsLog (LOG_ERROR, "moveToPreloadedDir: input path or iRODSPath is NULL");
        return (SYS_INTERNAL_NULL_INPUT_ERR);
    }

    status = _getCachePath(iRODSPath, preloadCachePath);
    if(status < 0) {
        rodsLogError(LOG_ERROR, status, "moveToPreloadedDir: _getCachePath error.");
        rodsLog (LOG_ERROR, "moveToPreloadedDir: failed to get cache path - %s", path);
        return status;
    }

    // make dir
    prepareDir(preloadCachePath);
    
    // move the file
    status = rename(path, preloadCachePath);
    if(status < 0) {
        rodsLogError(LOG_ERROR, status, "moveToPreloadedDir: rename error.");
        return status;
    }

    return (0);
}

int
regUtil( rcComm_t *conn, rodsEnv *myRodsEnv, rodsArguments_t *myRodsArgs,
         rodsPathInp_t *rodsPathInp ) {
    if ( rodsPathInp == NULL ) {
        return USER__NULL_INPUT_ERR;
    }

    dataObjInp_t dataObjOprInp;
    initCondForReg( myRodsEnv, myRodsArgs, &dataObjOprInp );

    int savedStatus = 0;
    for ( int i = 0; i < rodsPathInp->numSrc; i++ ) {
        rodsPath_t * destPath = &rodsPathInp->destPath[i];	/* iRODS path */
        rodsPath_t * srcPath = &rodsPathInp->srcPath[i];	/* file Path */

        getRodsObjType( conn, destPath );

        if ( destPath->objState == EXIST_ST &&
                myRodsArgs->force == False &&
                myRodsArgs->mountCollection == False &&
                myRodsArgs->regRepl != True ) {
            rodsLog( LOG_ERROR,
                     "regUtil: iRODSPath %s already exist", destPath->outPath );
            return CAT_NAME_EXISTS_AS_DATAOBJ;
        }

        int status = 0;
        if ( myRodsArgs->collection == False && myRodsArgs->checksum == True ) {
            status = rcChksumLocFile( srcPath->outPath,
                                      REG_CHKSUM_KW,
                                      &dataObjOprInp.condInput,
                                      myRodsArgs->hashValue );
            if ( status < 0 ) {
                rodsLogError( LOG_ERROR, status,
                              "regUtil: rcChksumLocFile error for %s, status = %d",
                              srcPath, status );
                return status;
            }
        }
        else if ( myRodsArgs->collection == False && myRodsArgs->verifyChecksum == True ) {
            addKeyVal( &dataObjOprInp.condInput, VERIFY_CHKSUM_KW, "" );
        }

        addKeyVal( &dataObjOprInp.condInput, FILE_PATH_KW, srcPath->outPath );
        rstrcpy( dataObjOprInp.objPath, destPath->outPath, MAX_NAME_LEN );

        status = rcPhyPathReg( conn, &dataObjOprInp );

        /* XXXX may need to return a global status */
        if ( status < 0 &&
                status != CAT_NO_ROWS_FOUND ) {
            rodsLogError( LOG_ERROR, status,
                          "regUtil: reg error for %s, status = %d",
                          destPath->outPath, status );
            savedStatus = status;
        }
    }
    return savedStatus;
}

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);
}

/**
 * \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
phybunUtil (rcComm_t *conn, rodsEnv *myRodsEnv, rodsArguments_t *myRodsArgs,
rodsPathInp_t *rodsPathInp)
{
    int i;
    int status; 
    int savedStatus = 0;
    rodsPath_t *collPath;
    structFileExtAndRegInp_t phyBundleCollInp;

    if (rodsPathInp == NULL) {
	return (USER__NULL_INPUT_ERR);
    }

    status = initCondForPhybunOpr (myRodsEnv, myRodsArgs, &phyBundleCollInp, 
      rodsPathInp);

    if (status < 0) return status;
    
    for (i = 0; i < rodsPathInp->numSrc; i++) {
        collPath = &rodsPathInp->srcPath[i];	/* iRODS Collection */

        getRodsObjType (conn, collPath);

	if (collPath->objType !=  COLL_OBJ_T) {
	    rodsLogError (LOG_ERROR, status,
             "phybunUtil: input path %s is not a collection", 
	      collPath->outPath);
	    return USER_INPUT_PATH_ERR;
	}

	rstrcpy (phyBundleCollInp.collection, collPath->outPath,
	  MAX_NAME_LEN);

	status = rcPhyBundleColl (conn, &phyBundleCollInp);

	if (status < 0) {
	    rodsLogError (LOG_ERROR, status,
             "phybunUtil: opr error for %s, status = %d", 
	      collPath->outPath, status);
            savedStatus = status;
	} 
    }

    if (savedStatus < 0) {
        return (savedStatus);
    } else if (status == CAT_NO_ROWS_FOUND) {
        return (0);
    } else {
        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;
}

// =-=-=-=-=-=-=-
// 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
ifuseConnect( iFuseConn_t *iFuseConn, rodsEnv *myRodsEnv ) {
    int status = 0;
    LOCK_STRUCT( *iFuseConn );
    if ( iFuseConn->conn == NULL ) {
        rErrMsg_t errMsg;
        iFuseConn->conn = rcConnect( myRodsEnv->rodsHost, myRodsEnv->rodsPort,
                                     myRodsEnv->rodsUserName, myRodsEnv->rodsZone, NO_RECONN, &errMsg );

        if ( iFuseConn->conn == NULL ) {
            /* try one more */
            iFuseConn->conn = rcConnect( myRodsEnv->rodsHost, myRodsEnv->rodsPort,
                                         myRodsEnv->rodsUserName, myRodsEnv->rodsZone, NO_RECONN, &errMsg );
            if ( iFuseConn->conn == NULL ) {
                rodsLogError( LOG_ERROR, errMsg.status,
                              "ifuseConnect: rcConnect failure %s", errMsg.msg );
                UNLOCK_STRUCT( *iFuseConn );
                if ( errMsg.status < 0 ) {
                    return errMsg.status;
                }
                else {
                    return -1;
                }
            }
        }

        status = clientLogin( iFuseConn->conn );
        if ( status != 0 ) {
            rcDisconnect( iFuseConn->conn );
            iFuseConn->conn = NULL;
        }
    }
    UNLOCK_STRUCT( *iFuseConn );
    return status;
}