/// =-=-=-=-=-=-=-
    /// @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 string
irods::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 object
irods::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 path
irods::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