svn_error_t *
svn_fs_hotcopy2(const char *src_path, const char *dst_path,
svn_boolean_t clean, svn_boolean_t incremental,
svn_cancel_func_t cancel_func, void *cancel_baton,
apr_pool_t *scratch_pool)
{
fs_library_vtable_t *vtable;
const char *src_fs_type;
svn_fs_t *src_fs;
svn_fs_t *dst_fs;
const char *dst_fs_type;
svn_node_kind_t dst_kind;
if (strcmp(src_path, dst_path) == 0)
return svn_error_create(SVN_ERR_INCORRECT_PARAMS, NULL,
_("Hotcopy source and destination are equal"));
SVN_ERR(svn_fs_type(&src_fs_type, src_path, scratch_pool));
SVN_ERR(get_library_vtable(&vtable, src_fs_type, scratch_pool));
src_fs = fs_new(NULL, scratch_pool);
dst_fs = fs_new(NULL, scratch_pool);
SVN_ERR(svn_io_check_path(dst_path, &dst_kind, scratch_pool));
if (dst_kind == svn_node_file)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("'%s' already exists and is a file"),
svn_dirent_local_style(dst_path,
scratch_pool));
if (dst_kind == svn_node_unknown)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("'%s' already exists and has an unknown "
"node kind"),
svn_dirent_local_style(dst_path,
scratch_pool));
if (dst_kind == svn_node_dir)
{
svn_node_kind_t type_file_kind;
SVN_ERR(svn_io_check_path(svn_dirent_join(dst_path,
FS_TYPE_FILENAME,
scratch_pool),
&type_file_kind, scratch_pool));
if (type_file_kind != svn_node_none)
{
SVN_ERR(svn_fs_type(&dst_fs_type, dst_path, scratch_pool));
if (strcmp(src_fs_type, dst_fs_type) != 0)
return svn_error_createf(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("The filesystem type of the hotcopy source "
"('%s') does not match the filesystem "
"type of the hotcopy destination ('%s')"),
src_fs_type, dst_fs_type);
}
}
SVN_ERR(vtable->hotcopy(src_fs, dst_fs, src_path, dst_path, clean,
incremental, cancel_func, cancel_baton,
scratch_pool));
return svn_error_trace(write_fs_type(dst_path, src_fs_type, scratch_pool));
}
svn_error_t *
svn_fs_create(svn_fs_t **fs_p, const char *path, apr_hash_t *fs_config,
apr_pool_t *pool)
{
svn_error_t *err;
svn_error_t *err2;
fs_library_vtable_t *vtable;
const char *fs_type = svn_hash__get_cstring(fs_config,
SVN_FS_CONFIG_FS_TYPE,
DEFAULT_FS_TYPE);
SVN_ERR(get_library_vtable(&vtable, fs_type, pool));
/* Create the FS directory and write out the fsap-name file. */
SVN_ERR(svn_io_dir_make_sgid(path, APR_OS_DEFAULT, pool));
SVN_ERR(write_fs_type(path, fs_type, pool));
/* Perform the actual creation. */
*fs_p = fs_new(fs_config, pool);
SVN_ERR(acquire_fs_mutex());
err = vtable->create(*fs_p, path, pool, common_pool);
err2 = release_fs_mutex();
if (err)
{
svn_error_clear(err2);
return svn_error_trace(err);
}
return svn_error_trace(err2);
}
/* Fetch the library vtable for an existing FS. */
static svn_error_t *
fs_library_vtable(fs_library_vtable_t **vtable, const char *path,
apr_pool_t *pool)
{
const char *fs_type;
SVN_ERR(svn_fs_type(&fs_type, path, pool));
/* Fetch the library vtable by name, now that we've chosen one. */
return svn_error_trace(get_library_vtable(vtable, fs_type, pool));
}
svn_error_t *
svn_fs_hotcopy(const char *src_path, const char *dest_path,
svn_boolean_t clean, apr_pool_t *pool)
{
fs_library_vtable_t *vtable;
const char *fs_type;
SVN_ERR(svn_fs_type(&fs_type, src_path, pool));
SVN_ERR(get_library_vtable(&vtable, fs_type, pool));
SVN_ERR(vtable->hotcopy(src_path, dest_path, clean, pool));
return svn_error_trace(write_fs_type(dest_path, fs_type, pool));
}
svn_fs_id_t *
svn_fs_parse_id(const char *data, apr_size_t len, apr_pool_t *pool)
{
fs_library_vtable_t *vtable;
svn_error_t *err;
err = get_library_vtable(&vtable, SVN_FS_TYPE_BDB, pool);
if (err)
{
svn_error_clear(err);
return NULL;
}
return vtable->parse_id(data, len, pool);
}
svn_error_t *
svn_fs_create_berkeley(svn_fs_t *fs, const char *path)
{
fs_library_vtable_t *vtable;
SVN_ERR(get_library_vtable(&vtable, SVN_FS_TYPE_BDB, fs->pool));
/* Create the FS directory and write out the fsap-name file. */
SVN_ERR(svn_io_dir_make_sgid(path, APR_OS_DEFAULT, fs->pool));
SVN_ERR(write_fs_type(path, SVN_FS_TYPE_BDB, fs->pool));
/* Perform the actual creation. */
SVN_MUTEX__WITH_LOCK(common_pool_lock,
vtable->create(fs, path, fs->pool, common_pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_create(svn_fs_t **fs_p, const char *path, apr_hash_t *fs_config,
apr_pool_t *pool)
{
fs_library_vtable_t *vtable;
const char *fs_type = svn_hash__get_cstring(fs_config,
SVN_FS_CONFIG_FS_TYPE,
DEFAULT_FS_TYPE);
SVN_ERR(get_library_vtable(&vtable, fs_type, pool));
/* Create the FS directory and write out the fsap-name file. */
SVN_ERR(svn_io_dir_make_sgid(path, APR_OS_DEFAULT, pool));
SVN_ERR(write_fs_type(path, fs_type, pool));
/* Perform the actual creation. */
*fs_p = fs_new(fs_config, pool);
SVN_MUTEX__WITH_LOCK(common_pool_lock,
vtable->create(*fs_p, path, pool, common_pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_create_berkeley(svn_fs_t *fs, const char *path)
{
svn_error_t *err;
svn_error_t *err2;
fs_library_vtable_t *vtable;
SVN_ERR(get_library_vtable(&vtable, SVN_FS_TYPE_BDB, fs->pool));
/* Create the FS directory and write out the fsap-name file. */
SVN_ERR(svn_io_dir_make_sgid(path, APR_OS_DEFAULT, fs->pool));
SVN_ERR(write_fs_type(path, SVN_FS_TYPE_BDB, fs->pool));
/* Perform the actual creation. */
SVN_ERR(acquire_fs_mutex());
err = vtable->create(fs, path, fs->pool, common_pool);
err2 = release_fs_mutex();
if (err)
{
svn_error_clear(err2);
return svn_error_trace(err);
}
return svn_error_trace(err2);
}