/* This implements the fs_library_vtable_t.hotcopy() API. Copy a
possibly live Subversion filesystem SRC_FS from SRC_PATH to a
DST_FS at DEST_PATH. If INCREMENTAL is TRUE, make an effort not to
re-copy data which already exists in DST_FS.
The CLEAN_LOGS argument is ignored and included for Subversion
1.0.x compatibility. Perform all temporary allocations in POOL. */
static svn_error_t *
fs_hotcopy(svn_fs_t *src_fs,
svn_fs_t *dst_fs,
const char *src_path,
const char *dst_path,
svn_boolean_t clean_logs,
svn_boolean_t incremental,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
SVN_ERR(svn_fs__check_fs(src_fs, FALSE));
SVN_ERR(initialize_fs_struct(src_fs));
SVN_ERR(svn_fs_fs__open(src_fs, src_path, pool));
SVN_ERR(svn_fs_fs__initialize_caches(src_fs, pool));
SVN_ERR(fs_serialized_init(src_fs, pool, pool));
SVN_ERR(svn_fs__check_fs(dst_fs, FALSE));
SVN_ERR(initialize_fs_struct(dst_fs));
/* In INCREMENTAL mode, svn_fs_fs__hotcopy() will open DST_FS.
Otherwise, it's not an FS yet --- possibly just an empty dir --- so
can't be opened.
*/
return svn_fs_fs__hotcopy(src_fs, dst_fs, src_path, dst_path,
incremental, cancel_func, cancel_baton, pool);
}
/* This implements the fs_library_vtable_t.open() API. Open an FSFS
Subversion filesystem located at PATH, set *FS to point to the
correct vtable for the filesystem. Use POOL for any temporary
allocations, and COMMON_POOL for fs-global allocations. */
static svn_error_t *
fs_open(svn_fs_t *fs, const char *path, apr_pool_t *pool,
apr_pool_t *common_pool)
{
initialize_fs_struct(fs);
SVN_ERR(svn_fs_fs__open(fs, path, pool));
return fs_serialized_init(fs, common_pool, pool);
}
/* This implements the fs_library_vtable_t.uprade_fs() API. */
static svn_error_t *
fs_upgrade(svn_fs_t *fs, const char *path, apr_pool_t *pool,
apr_pool_t *common_pool)
{
SVN_ERR(svn_fs__check_fs(fs, FALSE));
initialize_fs_struct(fs);
SVN_ERR(svn_fs_fs__open(fs, path, pool));
SVN_ERR(fs_serialized_init(fs, common_pool, pool));
return svn_fs_fs__upgrade(fs, pool);
}
static svn_error_t *
fs_pack(svn_fs_t *fs,
const char *path,
svn_fs_pack_notify_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
SVN_ERR(svn_fs__check_fs(fs, FALSE));
SVN_ERR(initialize_fs_struct(fs));
SVN_ERR(svn_fs_fs__open(fs, path, pool));
SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
SVN_ERR(fs_serialized_init(fs, pool, pool));
return svn_fs_fs__pack(fs, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
static svn_error_t *
fs_verify(svn_fs_t *fs, const char *path,
svn_revnum_t start,
svn_revnum_t end,
svn_fs_progress_notify_func_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
SVN_ERR(svn_fs__check_fs(fs, FALSE));
SVN_ERR(initialize_fs_struct(fs));
SVN_ERR(svn_fs_fs__open(fs, path, pool));
SVN_ERR(svn_fs_fs__initialize_caches(fs, pool));
SVN_ERR(fs_serialized_init(fs, common_pool, pool));
return svn_fs_fs__verify(fs, start, end, notify_func, notify_baton,
cancel_func, cancel_baton, pool);
}
svn_error_t *
svn_fs_fs__hotcopy_prepare_target(svn_fs_t *src_fs,
svn_fs_t *dst_fs,
const char *dst_path,
svn_boolean_t incremental,
apr_pool_t *pool)
{
if (incremental)
{
const char *dst_format_abspath;
svn_node_kind_t dst_format_kind;
/* Check destination format to be sure we know how to incrementally
* hotcopy to the destination FS. */
dst_format_abspath = svn_dirent_join(dst_path, PATH_FORMAT, pool);
SVN_ERR(svn_io_check_path(dst_format_abspath, &dst_format_kind, pool));
if (dst_format_kind == svn_node_none)
{
/* Destination doesn't exist yet. Perform a normal hotcopy to a
* empty destination using the same configuration as the source. */
SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path, pool));
}
else
{
/* Check the existing repository. */
SVN_ERR(svn_fs_fs__open(dst_fs, dst_path, pool));
SVN_ERR(hotcopy_incremental_check_preconditions(src_fs, dst_fs,
pool));
}
}
else
{
/* Start out with an empty destination using the same configuration
* as the source. */
SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path, pool));
}
return SVN_NO_ERROR;
}
/* This implements the fs_library_vtable_t.open() API. Open an FSFS
Subversion filesystem located at PATH, set *FS to point to the
correct vtable for the filesystem. Use POOL for any temporary
allocations, and COMMON_POOL for fs-global allocations.
The latter must be serialized using COMMON_POOL_LOCK. */
static svn_error_t *
fs_open(svn_fs_t *fs,
const char *path,
svn_mutex__t *common_pool_lock,
apr_pool_t *pool,
apr_pool_t *common_pool)
{
apr_pool_t *subpool = svn_pool_create(pool);
SVN_ERR(svn_fs__check_fs(fs, FALSE));
SVN_ERR(initialize_fs_struct(fs));
SVN_ERR(svn_fs_fs__open(fs, path, subpool));
SVN_ERR(svn_fs_fs__initialize_caches(fs, subpool));
SVN_MUTEX__WITH_LOCK(common_pool_lock,
fs_serialized_init(fs, common_pool, subpool));
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
