自学教程：C++ ASSERT_PASS函数代码示例

    /// =-=-=-=-=-=-=-    /// @brief used to allow the resource to determine which host    ///        should provide the requested operation    irods::error load_balanced_redirect(        irods::resource_plugin_context& _ctx,        const std::string*              _opr,        const std::string*              _curr_host,        irods::hierarchy_parser*        _out_parser,        float*                          _out_vote ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // check incoming parameters        irods::error err = load_balanced_check_params< irods::file_object >( _ctx );        if ( ( result = ASSERT_PASS( err, "Invalid resource context." ) ).ok() ) {            if ( ( result = ASSERT_ERROR( _opr && _curr_host && _out_parser && _out_vote, SYS_INVALID_INPUT_PARAM,                                          "Invalid parameters." ) ).ok() ) {                // =-=-=-=-=-=-=-                // get the object's hier string                irods::file_object_ptr file_obj = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );                std::string hier = file_obj->resc_hier( );                // =-=-=-=-=-=-=-                // get the object's hier string                std::string name;                err = _ctx.prop_map().get< std::string >( irods::RESOURCE_NAME, name );                if ( ( result = ASSERT_PASS( err, "Failed to get property: /"%s/".", irods::RESOURCE_NAME.c_str() ) ).ok() ) {                    // =-=-=-=-=-=-=-                    // add ourselves into the hierarch before calling child resources                    _out_parser->add_child( name );                    // =-=-=-=-=-=-=-                    // test the operation to determine which choices to make                    if ( irods::OPEN_OPERATION   == ( *_opr )  ||                            irods::WRITE_OPERATION  == ( *_opr ) ) {                        std::string err_msg = "failed in resolve hierarchy for [" + ( *_opr ) + "]";                        err = load_balanced_redirect_for_open_operation( _ctx, _opr, _curr_host, _out_parser, _out_vote );                        result = ASSERT_PASS( err, err_msg );                    }                    else if ( irods::CREATE_OPERATION == ( *_opr ) ) {                        // =-=-=-=-=-=-=-                        // get the next_child resource for create                        irods::resource_ptr resc;                        std::string err_msg = "failed in resolve hierarchy for [" + ( *_opr ) + "]";                        err = load_balanced_redirect_for_create_operation( _ctx, _opr, _curr_host, _out_parser, _out_vote );                        result = ASSERT_PASS( err, err_msg );                    }                    else {                        // =-=-=-=-=-=-=-                        // must have been passed a bad operation                        result = ASSERT_ERROR( false, INVALID_OPERATION, "Operation not supported: /"%s/".",                                               _opr->c_str() );                    }                }            }        }        return result;    } // load_balanced_redirect

/// =-=-=-=-=-=-=-/// @brief get the next resource shared pointer given this resources name///        as well as the object's hierarchy stringirods::error get_next_child_in_hier(    const std::string&          _name,    const std::string&          _hier,    irods::resource_child_map& _cmap,    irods::resource_ptr&       _resc ) {    irods::error result = SUCCESS();    // =-=-=-=-=-=-=-    // create a parser and parse the string    irods::hierarchy_parser parse;    irods::error err = parse.set_string( _hier );    if ( ( result = ASSERT_PASS( err, "Failed in set_string" ) ).ok() ) {        // =-=-=-=-=-=-=-        // get the next resource in the series        std::string next;        err = parse.next( _name, next );        if ( ( result = ASSERT_PASS( err, "Failed in next." ) ).ok() ) {            // =-=-=-=-=-=-=-            // get the next resource from the child map            if ( ( result = ASSERT_ERROR( _cmap.has_entry( next ), CHILD_NOT_FOUND, "Child map missing entry: /"%s/"",                                          next.c_str() ) ).ok() ) {                // =-=-=-=-=-=-=-                // assign resource                _resc = _cmap[ next ].second;            }        }    }    return result;} // get_next_child_in_hier

irods::error random_get_resc_for_call(    irods::resource_plugin_context& _ctx,    irods::resource_ptr&            _resc ) {    irods::error result = SUCCESS();    // =-=-=-=-=-=-=-    // check incoming parameters    irods::error err = random_check_params< DEST_TYPE >( _ctx );    if ( ( result = ASSERT_PASS( err, "Bad resource context." ) ).ok() ) {        // =-=-=-=-=-=-=-        // get the object's name        std::string name;        err = _ctx.prop_map().get< std::string >( irods::RESOURCE_NAME, name );        if ( ( result = ASSERT_PASS( err, "Failed to get property." ) ).ok() ) {            // =-=-=-=-=-=-=-            // get the object's hier string            boost::shared_ptr< DEST_TYPE > dst_obj = boost::dynamic_pointer_cast< DEST_TYPE >( _ctx.fco() );            std::string hier = dst_obj->resc_hier( );            // =-=-=-=-=-=-=-            // get the next child pointer given our name and the hier string            err = get_next_child_in_hier( name, hier, _ctx.child_map(), _resc );            result = ASSERT_PASS( err, "Get next child failed." );        }    }    return result;} // random_get_resc_for_call

    // =-=-=-=-=-=-=-    // unixStageToCache - This routine is for testing the TEST_STAGE_FILE_TYPE.    // Just copy the file from filename to cacheFilename. optionalInfo info    // is not used.    irods::error mock_archive_stagetocache_plugin(        irods::resource_plugin_context& _ctx,        const char*                      _cache_file_name ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // Check the operation parameters and update the physical path        irods::error ret = unix_check_params_and_path< irods::file_object >( _ctx );        if ( ( result = ASSERT_PASS( ret, "Invalid plugin context." ) ).ok() ) {            // =-=-=-=-=-=-=-            // get ref to fco            irods::file_object_ptr fco = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );            // =-=-=-=-=-=-=-            // get the vault path for the resource            std::string path;            ret = _ctx.prop_map().get< std::string >( irods::RESOURCE_PATH, path );            if ( ( result = ASSERT_PASS( ret, "Failed to retrieve vault path for resource." ) ).ok() ) {                // =-=-=-=-=-=-=-                // append the hash to the path as the new 'cache file name'                path += "/";                path += fco->physical_path().c_str();                int status = mockArchiveCopyPlugin( fco->mode(), fco->physical_path().c_str(), _cache_file_name );                result = ASSERT_ERROR( status >= 0, status, "Failed copying archive file: /"%s/" to cache file: /"%s/".",                                       fco->physical_path().c_str(), _cache_file_name );            }        }        return result;    } // mock_archive_stagetocache_plugin

    // =-=-=-=-=-=-=-    // used to allow the resource to determine which host    // should provide the requested operation    irods::error impostor_resource_redirect_plugin(        irods::resource_plugin_context& _ctx,        const std::string*                  _opr,        const std::string*                  _curr_host,        irods::hierarchy_parser*           _out_parser,        float*                              _out_vote ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // check the context validity        irods::error ret = _ctx.valid< irods::file_object >();        if ( ( result = ASSERT_PASS( ret, "Invalid resource context." ) ).ok() ) {            // =-=-=-=-=-=-=-            // check incoming parameters            if ( ( result = ASSERT_ERROR( _opr && _curr_host && _out_parser && _out_vote, SYS_INVALID_INPUT_PARAM, "Invalid input parameter." ) ).ok() ) {                // =-=-=-=-=-=-=-                // cast down the chain to our understood object type                irods::file_object_ptr file_obj = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );                // =-=-=-=-=-=-=-                // get the name of this resource                std::string resc_name;                ret = _ctx.prop_map().get< std::string >( irods::RESOURCE_NAME, resc_name );                if ( ( result = ASSERT_PASS( ret, "Failed in get property for name." ) ).ok() ) {                    // =-=-=-=-=-=-=-                    // add ourselves to the hierarchy parser by default                    _out_parser->add_child( resc_name );                    // =-=-=-=-=-=-=-                    // test the operation to determine which choices to make                    if ( irods::OPEN_OPERATION  == ( *_opr ) ||                            irods::WRITE_OPERATION == ( *_opr ) ) {                        // =-=-=-=-=-=-=-                        // call redirect determination for 'get' operation                        ret = impostor_resource_redirect_open( _ctx.prop_map(), file_obj, resc_name, ( *_curr_host ), ( *_out_vote ) );                        result = ASSERT_PASS_MSG( ret, "Failed redirecting for open." );                    }                    else if ( irods::CREATE_OPERATION == ( *_opr ) ) {                        // =-=-=-=-=-=-=-                        // call redirect determination for 'create' operation                        ret = impostor_resource_redirect_create( _ctx.prop_map(), file_obj, resc_name, ( *_curr_host ), ( *_out_vote ) );                        result = ASSERT_PASS_MSG( ret, "Failed redirecting for create." );                    }                    else {                        // =-=-=-=-=-=-=-                        // must have been passed a bad operation                        result = ASSERT_ERROR( false, INVALID_OPERATION, "Operation not supported." );                    }                }            }        }        return result;    } // impostor_resource_redirect_plugin

    // =-=-=-=-=-=-=-    // redirect_create - code to determine redirection for create operation    irods::error impostor_resource_redirect_create(        irods::plugin_property_map&   _prop_map,        irods::file_object_ptr        _file_obj,        const std::string&             _resc_name,        const std::string&             _curr_host,        float&                         _out_vote ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // determine if the resource is down        int resc_status = 0;        irods::error get_ret = _prop_map.get< int >( irods::RESOURCE_STATUS, resc_status );        if ( ( result = ASSERT_PASS( get_ret, "Failed to get /"status/" property." ) ).ok() ) {            // =-=-=-=-=-=-=-            // if the status is down, vote no.            if ( INT_RESC_STATUS_DOWN == resc_status ) {                _out_vote = 0.0;                result.code( SYS_RESC_IS_DOWN );                // result = PASS( result );            }            else {                // =-=-=-=-=-=-=-                // get the resource host for comparison to curr host                std::string host_name;                get_ret = _prop_map.get< std::string >( irods::RESOURCE_LOCATION, host_name );                if ( ( result = ASSERT_PASS( get_ret, "Failed to get /"location/" property." ) ).ok() ) {                    // =-=-=-=-=-=-=-                    // vote higher if we are on the same host                    if ( _curr_host == host_name ) {                        _out_vote = 1.0;                    }                    else {                        _out_vote = 0.5;                    }                }                rodsLog(                     LOG_DEBUG,                    "create :: resc name [%s] curr host [%s] resc host [%s] vote [%f]",                    _resc_name.c_str(),                    _curr_host.c_str(),                    host_name.c_str(),                    _out_vote );            }        }        return result;    } // impostor_resource_redirect_create

    // =-=-=-=-=-=-=-    // unixSyncToArch - This routine is for testing the TEST_STAGE_FILE_TYPE.    // Just copy the file from cacheFilename to filename. optionalInfo info    // is not used.    irods::error mock_archive_synctoarch_plugin(        irods::resource_plugin_context& _ctx,        char*                           _cache_file_name ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // Check the operation parameters and update the physical path        irods::error ret = unix_check_params_and_path< irods::file_object >( _ctx );        if ( ( result = ASSERT_PASS( ret, "Invalid plugin context." ) ).ok() ) {            // =-=-=-=-=-=-=-            // get ref to fco            irods::file_object_ptr fco = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );            // =-=-=-=-=-=-=-            // get the vault path for the resource            std::string path;            ret = make_hashed_path(                      _ctx.prop_map(),                      fco->physical_path(),                      path );            if ( ( result = ASSERT_PASS( ret, "Failed to gen hashed path" ) ).ok() ) {                // =-=-=-=-=-=-=-                // append the hash to the path as the new 'cache file name'                rodsLog( LOG_NOTICE, "mock archive :: cache file name [%s]", _cache_file_name );                rodsLog( LOG_NOTICE, "mock archive :: new hashed file name for [%s] is [%s]",                         fco->physical_path().c_str(), path.c_str() );                // =-=-=-=-=-=-=-                // make the directories in the path to the new file                std::string new_path = path;                std::size_t last_slash = new_path.find_last_of( '/' );                new_path.erase( last_slash );                ret = mock_archive_mkdir_r( new_path.c_str(), 0750 );                if ( ( result = ASSERT_PASS( ret, "Mkdir error for /"%s/".", new_path.c_str() ) ).ok() ) {                }                // =-=-=-=-=-=-=-                // make the copy to the 'archive'                int status = mockArchiveCopyPlugin( fco->mode(), _cache_file_name, path.c_str() );                if ( ( result = ASSERT_ERROR( status >= 0, status, "Sync to arch failed." ) ).ok() ) {                    fco->physical_path( path );                }            }        }        return result;    } // mock_archive_synctoarch_plugin

// =-=-=-=-=-=-=-/// @brief update the physical path in the file objectirods::error unix_check_path(    irods::resource_plugin_context& _ctx ) {    irods::error result = SUCCESS();    try {        irods::data_object_ptr data_obj = boost::dynamic_pointer_cast< irods::data_object >( _ctx.fco() );        // =-=-=-=-=-=-=-        // NOTE: Must do this for all storage resources        std::string full_path;        irods::error ret = mock_archive_generate_full_path( _ctx.prop_map(),                           data_obj->physical_path(),                           full_path );        if ( ( result = ASSERT_PASS( ret, "Failed generating full path for object." ) ).ok() ) {            data_obj->physical_path( full_path );        }        return result;    }    catch ( const std::bad_cast& ) {        return ERROR( SYS_INVALID_INPUT_PARAM, "failed to cast fco to data_object" );    }} // unix_check_path

// =-=-=-=-=-=-=-/// @brief Generates a full path name from the partial physical path and the specified resource's vault pathirods::error mock_archive_generate_full_path(    irods::plugin_property_map& _prop_map,    const std::string&           _phy_path,    std::string&                 _ret_string ) {    irods::error result = SUCCESS();    irods::error ret;    std::string vault_path;    // TODO - getting vault path by property will not likely work for coordinating nodes    ret = _prop_map.get<std::string>( irods::RESOURCE_PATH, vault_path );    if ( ( result = ASSERT_PASS( ret, "Resource has no vault path." ) ).ok() ) {        if ( _phy_path.compare( 0, 1, "/" ) != 0 &&                _phy_path.compare( 0, vault_path.size(), vault_path ) != 0 ) {            _ret_string  = vault_path;            _ret_string += "/";            _ret_string += _phy_path;        }        else {            // The physical path already contains the vault path            _ret_string = _phy_path;        }    }    return result;} // mock_archive_generate_full_path

    // =-=-=-=-=-=-=-    // interface for POSIX Unlink    irods::error mock_archive_unlink_plugin(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // Check the operation parameters and update the physical path        irods::error ret = unix_check_params_and_path< irods::file_object >( _ctx );        if ( ( result = ASSERT_PASS( ret, "Invalid plugin context." ) ).ok() ) {            // =-=-=-=-=-=-=-            // get ref to fco            irods::file_object_ptr fco = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );            // =-=-=-=-=-=-=-            // make the call to unlink            int status = unlink( fco->physical_path().c_str() );            // =-=-=-=-=-=-=-            // error handling            int err_status = UNIX_FILE_UNLINK_ERR - errno;            result = ASSERT_ERROR( status >= 0, err_status, "Unlink error for: /"%s/", errno = /"%s/", status = %d.",                                   fco->physical_path().c_str(), strerror( errno ), err_status );        }        return result;    } // mock_archive_unlink_plugin

    // =-=-=-=-=-=-=-    // interface for POSIX readdir    irods::error mock_archive_rename_plugin(        irods::resource_plugin_context& _ctx,        const char*                     _new_file_name ) {        // =-=-=-=-=-=-=-        // Check the operation parameters and update the physical path        irods::error result = SUCCESS();        irods::error ret = unix_check_params_and_path< irods::data_object >( _ctx );        if ( ( result = ASSERT_PASS( ret, "Invalid parameters or physical path." ) ).ok() ) {            // =-=-=-=-=-=-=-            // manufacture a new path from the new file name            std::string new_full_path;            ret = mock_archive_generate_full_path( _ctx.prop_map(), _new_file_name, new_full_path );            if ( ( result = ASSERT_PASS( ret, "Unable to generate full path for destination file: /"%s/".",                                         _new_file_name ) ).ok() ) {                // =-=-=-=-=-=-=-                // cast down the hierarchy to the desired object                irods::file_object_ptr fco = boost::dynamic_pointer_cast< irods::file_object >( _ctx.fco() );                // =-=-=-=-=-=-=-                // get hashed names for the old path                std::string new_hash;                ret = make_hashed_path(                          _ctx.prop_map(),                          _new_file_name,                          new_hash );                if ( ( result = ASSERT_PASS( ret, "Failed to gen hashed path" ) ).ok() ) {                    // =-=-=-=-=-=-=-                    // make the call to rename                    int status = rename( fco->physical_path().c_str(), new_hash.c_str() );                    // =-=-=-=-=-=-=-                    // handle error cases                    int err_status = UNIX_FILE_RENAME_ERR - errno;                    if ( ( result = ASSERT_ERROR( status >= 0, err_status, "Rename error for /"%s/" to /"%s/", errno = /"%s/", status = %d.",                                                  fco->physical_path().c_str(), new_hash.c_str(), strerror( errno ), err_status ) ).ok() ) {                        fco->physical_path( new_hash );                        result.code( status );                    }                }            }        }        return result;    } // mock_archive_rename_plugin

    // =-=-=-=-=-=-=-    // interface for POSIX Open    irods::error random_file_open(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed in file open." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call open operation on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_OPEN, _ctx.fco() );            result = ASSERT_PASS( err, "Failed calling open on the child." );        }        return result;    } // random_file_open

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX create    irods::error random_file_create(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Invalid resource context." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call create on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_CREATE, _ctx.fco() );            result = ASSERT_PASS( err, "Failed calling create on child resource." );        }        return result;    } // random_file_create

    // =-=-=-=-=-=-=-    /// @brief interface for POSIX closedir    irods::error random_file_closedir(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::collection_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select random resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call closedir on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_CLOSEDIR, _ctx.fco() );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // random_file_closedir

    /// =-=-=-=-=-=-=-    /// @brief interface to notify of a file unregistration    irods::error load_balanced_file_unregistered(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = load_balanced_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed selecting load_balanced resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call rename on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_UNREGISTERED, _ctx.fco() );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // load_balanced_file_unregistered

    /// =-=-=-=-=-=-=-    /// @brief This routine copys data from the archive resource to the cache resource    ///        in a compound resource composition    irods::error load_balanced_file_stage_to_cache(        irods::resource_plugin_context& _ctx,        const char*                         _cache_file_name ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = load_balanced_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select load_balanced resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call stage on the child            err = resc->call< const char* >( _ctx.comm(), irods::RESOURCE_OP_STAGETOCACHE, _ctx.fco(), _cache_file_name );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // load_balanced_file_stage_to_cache

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX Close    irods::error load_balanced_file_close(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = load_balanced_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select load_balanced resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call close on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_CLOSE, _ctx.fco() );            result = ASSERT_PASS( err, "Failed calling operation in child." );        }        return result;    } // load_balanced_file_close

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX Unlink    irods::error random_file_unlink(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::data_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select random resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call unlink on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_UNLINK, _ctx.fco() );            result = ASSERT_PASS( err, "Failed during call to child operation." );        }        return result;    } // random_file_unlink

    /// =-=-=-=-=-=-=-    /// @brief interface to notify of a file modification    irods::error random_file_modified(        irods::resource_plugin_context& _ctx ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed selecting random resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call rename on the child            err = resc->call( _ctx.comm(), irods::RESOURCE_OP_MODIFIED, _ctx.fco() );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // random_file_modified

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX Stat    irods::error random_file_stat(        irods::resource_plugin_context& _ctx,        struct stat*                     _statbuf ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::data_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed selecting random child resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call stat on the child            err = resc->call< struct stat* >( _ctx.comm(), irods::RESOURCE_OP_STAT, _ctx.fco(), _statbuf );            result = ASSERT_PASS( err, "Failed in call to child operation." );        }        return result;    } // random_file_stat

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX readdir    irods::error load_balanced_file_readdir(        irods::resource_plugin_context& _ctx,        struct rodsDirent**              _dirent_ptr ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = load_balanced_get_resc_for_call< irods::collection_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select load_balanced resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call readdir on the child            err = resc->call< struct rodsDirent** >( _ctx.comm(), irods::RESOURCE_OP_READDIR, _ctx.fco(), _dirent_ptr );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // load_balanced_file_readdir

    /// =-=-=-=-=-=-=-    /// @brief This routine is for testing the TEST_STAGE_FILE_TYPE.    ///        Just copy the file from cacheFilename to filename. optionalInfo info    ///        is not used.    irods::error random_file_sync_to_arch(        irods::resource_plugin_context& _ctx,        const char*                         _cache_file_name ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed selecting random resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call synctoarch on the child            err = resc->call< const char* >( _ctx.comm(), irods::RESOURCE_OP_SYNCTOARCH, _ctx.fco(), _cache_file_name );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // random_file_sync_to_arch

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX rename    irods::error random_file_rename(        irods::resource_plugin_context& _ctx,        const char*                         _new_file_name ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select random resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call rename on the child            err = resc->call< const char* >( _ctx.comm(), irods::RESOURCE_OP_RENAME, _ctx.fco(), _new_file_name );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // random_file_rename

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX Write    irods::error random_file_write(        irods::resource_plugin_context& _ctx,        void*                               _buf,        int                                 _len ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed choosing child resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call write on the child            err = resc->call< void*, int >( _ctx.comm(), irods::RESOURCE_OP_WRITE, _ctx.fco(), _buf, _len );            result = ASSERT_PASS( err, "Failed calling operation on child resource." );        }        return result;    } // random_file_write

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX lseek    irods::error random_file_lseek(        irods::resource_plugin_context& _ctx,        long long                        _offset,        int                              _whence ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = random_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed to select random child." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call lseek on the child            err = resc->call< long long, int >( _ctx.comm(), irods::RESOURCE_OP_LSEEK, _ctx.fco(), _offset, _whence );            result = ASSERT_PASS( err, "Failed calling child operation." );        }        return result;    } // random_file_lseek

    /// =-=-=-=-=-=-=-    /// @brief interface for POSIX Read    irods::error load_balanced_file_read(        irods::resource_plugin_context& _ctx,        void*                               _buf,        int                                 _len ) {        irods::error result = SUCCESS();        // =-=-=-=-=-=-=-        // get the child resc to call        irods::resource_ptr resc;        irods::error err = load_balanced_get_resc_for_call< irods::file_object >( _ctx, resc );        if ( ( result = ASSERT_PASS( err, "Failed finding resource." ) ).ok() ) {            // =-=-=-=-=-=-=-            // call read on the child            err = resc->call< void*, int >( _ctx.comm(), irods::RESOURCE_OP_READ, _ctx.fco(), _buf, _len );            result = ASSERT_PASS( err, "Failed calling operation on child resource." );        }        return result;    } // load_balanced_file_read

inline irods::error random_check_params(    irods::resource_plugin_context& _ctx ) {    irods::error result = SUCCESS();    // =-=-=-=-=-=-=-    // ask the context if it is valid    irods::error ret = _ctx.valid< DEST_TYPE >();    result = ASSERT_PASS( ret, "Resource context invalid." );    return result;} // random_check_params

    error gsi_auth_object::resolve(        const std::string& _interface,        plugin_ptr& _ptr ) {        error result = SUCCESS();        if ( ( result = ASSERT_ERROR( _interface == AUTH_INTERFACE, SYS_INVALID_INPUT_PARAM,                                      "gsi_auth_object does not support a /"%s/" plugin interface.",                                      _interface.c_str() ) ).ok() ) {            auth_ptr ath;            error ret = auth_mgr.resolve( AUTH_GSI_SCHEME, ath );            if ( !( result = ASSERT_PASS( ret, "Failed to resolve the GSI auth plugin." ) ).ok() ) {                // Attempt to load the plugin.                std::string empty_context( "" );                ret = auth_mgr.init_from_type( AUTH_GSI_SCHEME, AUTH_GSI_SCHEME, AUTH_GSI_SCHEME, empty_context, ath );                result = ASSERT_PASS( ret, "Failed to load the GSI auth plugin." );            }            if ( result.ok() ) {                _ptr = boost::dynamic_pointer_cast<plugin_base>( ath );            }        }        return result;    }

irods::error unix_check_params_and_path(    irods::resource_plugin_context& _ctx ) {    irods::error result = SUCCESS();    irods::error ret;    // =-=-=-=-=-=-=-    // verify that the resc context is valid    ret = _ctx.valid< DEST_TYPE >();    if ( ( result = ASSERT_PASS( ret, "Resource context is invalid." ) ).ok() ) {        result = unix_check_path( _ctx );    }    return result;} // unix_check_params_and_path

    error auth_manager::init_from_type(        const std::string& _type,        const std::string& _key,        const std::string& _inst,        const std::string& _ctx,        auth_ptr& _rtn_auth ) {        error result = SUCCESS();        error ret;        auth_ptr auth;        ret = load_auth_plugin( auth, _type, _inst, _ctx );        if ( ( result = ASSERT_PASS( ret, "Failed to load auth plugin." ) ).ok() ) {            plugins_[_key] = auth;            _rtn_auth = plugins_[_key];        }        return result;    }