示例#1
0
int
l3Create( rsComm_t *rsComm, int l1descInx ) {
    dataObjInfo_t *dataObjInfo;
    int l3descInx;

    dataObjInfo = L1desc[l1descInx].dataObjInfo;

    // =-=-=-=-=-=-=-
    // extract the host location from the resource hierarchy
    std::string location;
    irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
    if ( !ret.ok() ) {
        irods::log( PASSMSG( "l3Create - failed in get_loc_for_hier_String", ret ) );
        return -1;
    }


    if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
        subFile_t subFile;
        memset( &subFile, 0, sizeof( subFile ) );
        rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
        rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );

        subFile.specColl = dataObjInfo->specColl;
        subFile.mode = getFileMode( L1desc[l1descInx].dataObjInp );
        l3descInx = rsSubStructFileCreate( rsComm, &subFile );
    }
    else {
        /* normal or mounted file */
        l3descInx = l3CreateByObjInfo( rsComm, L1desc[l1descInx].dataObjInp,
                                       L1desc[l1descInx].dataObjInfo );
    }

    return ( l3descInx );
}
示例#2
0
/* createEmptyRepl - Physically create a zero length file and register
 * as a replica and queue the dataObjInfo on the top of dataObjInfoHead.
 */
int
createEmptyRepl( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
                 dataObjInfo_t **dataObjInfoHead ) {
    int status;
    regReplica_t regReplicaInp;
    keyValPair_t *condInput = &dataObjInp->condInput;
    dataObjInfo_t *myDataObjInfo;

    std::string resc_name;

    if ( getValByKey( condInput, DEST_RESC_NAME_KW ) == NULL &&
            getValByKey( condInput, BACKUP_RESC_NAME_KW ) == NULL &&
            getValByKey( condInput, DEF_RESC_NAME_KW ) == NULL ) {
        return USER_NO_RESC_INPUT_ERR;
    }

    status = getRescForCreate( rsComm, dataObjInp, resc_name );
    if ( status < 0 || resc_name.empty() ) {
        return status;    // JMC cppcheck
    }

    myDataObjInfo = ( dataObjInfo_t* )malloc( sizeof( dataObjInfo_t ) );
    *myDataObjInfo = *( *dataObjInfoHead );

    rstrcpy( myDataObjInfo->rescName, ( *dataObjInfoHead )->rescName, NAME_LEN );

    char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
    if ( resc_hier ) {
        rstrcpy( myDataObjInfo->rescHier, resc_hier, MAX_NAME_LEN ); // hier sent from upper level code
    }
    else {
        rodsLog( LOG_NOTICE, "createEmptyRepl :: using rescName for hier" );
        rstrcpy( myDataObjInfo->rescHier, ( *dataObjInfoHead )->rescName, MAX_NAME_LEN ); // in kw else
    }

    rodsLong_t resc_id;
    irods::error ret = resc_mgr.hier_to_leaf_id( myDataObjInfo->rescHier, resc_id );
    myDataObjInfo->rescId = resc_id;

    status = getFilePathName( rsComm, myDataObjInfo, dataObjInp );
    if ( status < 0 ) {
        rodsLog( LOG_ERROR, "getFilePathName failed in %s with status %d", __FUNCTION__, status );
        return status;
    }

    status = l3CreateByObjInfo( rsComm, dataObjInp, myDataObjInfo );
    if ( status < 0 ) {
        rodsLog( LOG_ERROR, "l3CreateByObjInfo failed in %s with status %d", __FUNCTION__, status );
        return status;
    }

    /* close it */
    _l3Close( rsComm, status );

    /* register the replica */
    memset( &regReplicaInp, 0, sizeof( regReplicaInp ) );
    regReplicaInp.srcDataObjInfo = *dataObjInfoHead;
    regReplicaInp.destDataObjInfo = myDataObjInfo;
    if ( getValByKey( &dataObjInp->condInput, ADMIN_KW ) != NULL ) {
        addKeyVal( &regReplicaInp.condInput, ADMIN_KW, "" );
    }
    status = rsRegReplica( rsComm, &regReplicaInp );
    clearKeyVal( &regReplicaInp.condInput );


    if ( status < 0 ) {
        free( myDataObjInfo );
    }
    else {
        /* queue it on top */
        myDataObjInfo->next = *dataObjInfoHead;
        *dataObjInfoHead = myDataObjInfo;
    }
    return status;
}