You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by vm...@apache.org on 2012/05/29 03:39:49 UTC
svn commit: r1343447 [9/27] - in /subversion/branches/javahl-ra: ./ build/
build/ac-macros/ build/generator/ build/generator/templates/ build/win32/
contrib/client-side/emacs/ contrib/server-side/ notes/
notes/api-errata/1.8/ notes/merge-tracking/ subv...
Modified: subversion/branches/javahl-ra/subversion/libsvn_fs_fs/temp_serializer.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_fs_fs/temp_serializer.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_fs_fs/temp_serializer.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_fs_fs/temp_serializer.c Tue May 29 01:39:41 2012
@@ -30,6 +30,7 @@
#include "private/svn_fs_util.h"
#include "private/svn_temp_serializer.h"
+#include "private/svn_subr_private.h"
#include "temp_serializer.h"
@@ -359,7 +360,7 @@ serialize_dir(apr_hash_t *entries, apr_p
static apr_hash_t *
deserialize_dir(void *buffer, hash_data_t *hash_data, apr_pool_t *pool)
{
- apr_hash_t *result = apr_hash_make(pool);
+ apr_hash_t *result = svn_hash__make(pool);
apr_size_t i;
apr_size_t count;
svn_fs_dirent_t *entry;
@@ -678,7 +679,7 @@ svn_fs_fs__deserialize_properties(void *
apr_size_t data_len,
apr_pool_t *pool)
{
- apr_hash_t *hash = apr_hash_make(pool);
+ apr_hash_t *hash = svn_hash__make(pool);
properties_data_t *properties = (properties_data_t *)data;
size_t i;
@@ -931,7 +932,7 @@ svn_fs_fs__extract_dir_entry(void **out,
svn_temp_deserializer__ptr(entries, (const void *const *)&entries[pos]);
/* Entries have been serialized one-by-one, each time including all
- * nestes structures and strings. Therefore, they occupy a single
+ * nested structures and strings. Therefore, they occupy a single
* block of memory whose end-offset is either the beginning of the
* next entry or the end of the buffer
*/
Modified: subversion/branches/javahl-ra/subversion/libsvn_fs_fs/tree.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_fs_fs/tree.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_fs_fs/tree.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_fs_fs/tree.c Tue May 29 01:39:41 2012
@@ -359,7 +359,7 @@ mutable_root_node(dag_node_t **node_p,
return svn_fs_fs__dag_clone_root(node_p, root->fs, root->txn, pool);
else
/* If it's not a transaction root, we can't change its contents. */
- return SVN_FS__ERR_NOT_MUTABLE(root->fs, root->rev, error_path, pool);
+ return SVN_FS__ERR_NOT_MUTABLE(root->fs, root->rev, error_path);
}
@@ -696,7 +696,7 @@ open_path(parent_path_t **parent_path_p,
/* The path isn't finished yet; we'd better be in a directory. */
if (svn_fs_fs__dag_node_kind(child) != svn_node_dir)
- SVN_ERR_W(SVN_FS__ERR_NOT_DIRECTORY(fs, path_so_far, iterpool),
+ SVN_ERR_W(SVN_FS__ERR_NOT_DIRECTORY(fs, path_so_far),
apr_psprintf(iterpool, _("Failure opening '%s'"), path));
rest = next;
@@ -1837,7 +1837,7 @@ fs_make_dir(svn_fs_root_t *root,
/* If there's already a sub-directory by that name, complain. This
also catches the case of trying to make a subdirectory named `/'. */
if (parent_path->node)
- return SVN_FS__ALREADY_EXISTS(root, path, pool);
+ return SVN_FS__ALREADY_EXISTS(root, path);
/* Create the subdirectory. */
SVN_ERR(make_path_mutable(root, parent_path->parent, path, pool));
@@ -1925,17 +1925,7 @@ fs_same_p(svn_boolean_t *same_p,
svn_fs_t *fs2,
apr_pool_t *pool)
{
- const char *uuid1;
- const char *uuid2;
-
- /* Random thought: if fetching UUIDs to compare filesystems is too
- expensive, one solution would be to cache the UUID in each fs
- object (copying the UUID into fs->pool, of course). */
-
- SVN_ERR(fs1->vtable->get_uuid(fs1, &uuid1, pool));
- SVN_ERR(fs2->vtable->get_uuid(fs2, &uuid2, pool));
-
- *same_p = ! strcmp(uuid1, uuid2);
+ *same_p = ! strcmp(fs1->uuid, fs2->uuid);
return SVN_NO_ERROR;
}
@@ -2182,7 +2172,7 @@ fs_make_file(svn_fs_root_t *root,
/* If there's already a file by that name, complain.
This also catches the case of trying to make a file named `/'. */
if (parent_path->node)
- return SVN_FS__ALREADY_EXISTS(root, path, pool);
+ return SVN_FS__ALREADY_EXISTS(root, path);
/* Check (non-recursively) to see if path is locked; if so, check
that we can use it. */
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra/debug_reporter.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra/debug_reporter.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra/debug_reporter.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra/debug_reporter.c Tue May 29 01:39:41 2012
@@ -95,7 +95,7 @@ finish_report(void *report_baton,
apr_pool_t *pool)
{
struct report_baton *rb = report_baton;
- SVN_ERR(svn_stream_printf(rb->out, pool, "finish_report()\n"));
+ SVN_ERR(svn_stream_puts(rb->out, "finish_report()\n"));
SVN_ERR(rb->wrapped_reporter->finish_report(rb->wrapped_report_baton, pool));
return SVN_NO_ERROR;
}
@@ -105,7 +105,7 @@ abort_report(void *report_baton,
apr_pool_t *pool)
{
struct report_baton *rb = report_baton;
- SVN_ERR(svn_stream_printf(rb->out, pool, "abort_report()\n"));
+ SVN_ERR(svn_stream_puts(rb->out, "abort_report()\n"));
SVN_ERR(rb->wrapped_reporter->abort_report(rb->wrapped_report_baton, pool));
return SVN_NO_ERROR;
}
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra/ra_loader.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra/ra_loader.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra/ra_loader.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra/ra_loader.c Tue May 29 01:39:41 2012
@@ -902,6 +902,8 @@ svn_error_t *svn_ra_do_diff3(svn_ra_sess
void *diff_baton,
apr_pool_t *pool)
{
+ SVN_ERR_ASSERT(svn_path_is_empty(diff_target)
+ || svn_path_is_single_path_component(diff_target));
return session->vtable->do_diff(session,
reporter, report_baton,
revision, diff_target,
@@ -1167,6 +1169,17 @@ svn_error_t *svn_ra_replay(svn_ra_sessio
}
svn_error_t *
+svn_ra__replay_ev2(svn_ra_session_t *session,
+ svn_revnum_t revision,
+ svn_revnum_t low_water_mark,
+ svn_boolean_t send_deltas,
+ svn_editor_t *editor,
+ apr_pool_t *scratch_pool)
+{
+ SVN__NOT_IMPLEMENTED();
+}
+
+svn_error_t *
svn_ra_replay_range(svn_ra_session_t *session,
svn_revnum_t start_revision,
svn_revnum_t end_revision,
@@ -1219,6 +1232,20 @@ svn_ra_replay_range(svn_ra_session_t *se
return err;
}
+svn_error_t *
+svn_ra__replay_range_ev2(svn_ra_session_t *session,
+ svn_revnum_t start_revision,
+ svn_revnum_t end_revision,
+ svn_revnum_t low_water_mark,
+ svn_boolean_t send_deltas,
+ svn_ra__replay_revstart_ev2_callback_t revstart_func,
+ svn_ra__replay_revfinish_ev2_callback_t revfinish_func,
+ void *replay_baton,
+ apr_pool_t *scratch_pool)
+{
+ SVN__NOT_IMPLEMENTED();
+}
+
svn_error_t *svn_ra_has_capability(svn_ra_session_t *session,
svn_boolean_t *has,
const char *capability,
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra_local/ra_plugin.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra_local/ra_plugin.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra_local/ra_plugin.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra_local/ra_plugin.c Tue May 29 01:39:41 2012
@@ -76,8 +76,6 @@ get_username(svn_ra_session_t *session,
apr_pool_t *pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
- svn_auth_iterstate_t *iterstate;
- svn_fs_access_t *access_ctx;
/* If we've already found the username don't ask for it again. */
if (! sess->username)
@@ -88,6 +86,8 @@ get_username(svn_ra_session_t *session,
{
void *creds;
svn_auth_cred_username_t *username_creds;
+ svn_auth_iterstate_t *iterstate;
+
SVN_ERR(svn_auth_first_credentials(&creds, &iterstate,
SVN_AUTH_CRED_USERNAME,
sess->uuid, /* realmstring */
@@ -118,6 +118,8 @@ get_username(svn_ra_session_t *session,
*/
if (*sess->username)
{
+ svn_fs_access_t *access_ctx;
+
SVN_ERR(svn_fs_create_access(&access_ctx, sess->username,
session->pool));
SVN_ERR(svn_fs_set_access(sess->fs, access_ctx));
@@ -367,11 +369,12 @@ struct deltify_etc_baton
{
svn_fs_t *fs; /* the fs to deltify in */
svn_repos_t *repos; /* repos for unlocking */
- const char *fs_path; /* fs-path part of split session URL */
+ const char *fspath_base; /* fs-path part of split session URL */
+
apr_hash_t *lock_tokens; /* tokens to unlock, if any */
- apr_pool_t *pool; /* pool for scratch work */
- svn_commit_callback2_t callback; /* the original callback */
- void *callback_baton; /* the original callback's baton */
+
+ svn_commit_callback2_t commit_cb; /* the original callback */
+ void *commit_baton; /* the original callback's baton */
};
/* This implements 'svn_commit_callback_t'. Its invokes the original
@@ -380,60 +383,107 @@ struct deltify_etc_baton
BATON is 'struct deltify_etc_baton *'. */
static svn_error_t *
deltify_etc(const svn_commit_info_t *commit_info,
- void *baton, apr_pool_t *pool)
+ void *baton,
+ apr_pool_t *scratch_pool)
{
- struct deltify_etc_baton *db = baton;
+ struct deltify_etc_baton *deb = baton;
svn_error_t *err1 = SVN_NO_ERROR;
svn_error_t *err2;
- apr_hash_index_t *hi;
- apr_pool_t *iterpool;
/* Invoke the original callback first, in case someone's waiting to
know the revision number so they can go off and annotate an
issue or something. */
- if (db->callback)
- err1 = db->callback(commit_info, db->callback_baton, pool);
+ if (deb->commit_cb)
+ err1 = deb->commit_cb(commit_info, deb->commit_baton, scratch_pool);
/* Maybe unlock the paths. */
- if (db->lock_tokens)
+ if (deb->lock_tokens)
{
- iterpool = svn_pool_create(db->pool);
- for (hi = apr_hash_first(db->pool, db->lock_tokens); hi;
+ apr_pool_t *iterpool = svn_pool_create(scratch_pool);
+ apr_hash_index_t *hi;
+
+ for (hi = apr_hash_first(scratch_pool, deb->lock_tokens); hi;
hi = apr_hash_next(hi))
{
- const void *rel_path;
- void *val;
- const char *abs_path, *token;
+ const void *relpath = svn__apr_hash_index_key(hi);
+ const char *token = svn__apr_hash_index_val(hi);
+ const char *fspath;
svn_pool_clear(iterpool);
- apr_hash_this(hi, &rel_path, NULL, &val);
- token = val;
- abs_path = svn_fspath__join(db->fs_path, rel_path, iterpool);
+
+ fspath = svn_fspath__join(deb->fspath_base, relpath, iterpool);
+
/* We may get errors here if the lock was broken or stolen
after the commit succeeded. This is fine and should be
ignored. */
- svn_error_clear(svn_repos_fs_unlock(db->repos, abs_path, token,
+ svn_error_clear(svn_repos_fs_unlock(deb->repos, fspath, token,
FALSE, iterpool));
}
+
svn_pool_destroy(iterpool);
}
/* But, deltification shouldn't be stopped just because someone's
random callback failed, so proceed unconditionally on to
deltification. */
- err2 = svn_fs_deltify_revision(db->fs, commit_info->revision, db->pool);
+ err2 = svn_fs_deltify_revision(deb->fs, commit_info->revision, scratch_pool);
+
+ return svn_error_compose_create(err1, err2);
+}
+
- /* It's more interesting if the original callback failed, so let
- that one dominate. */
- if (err1)
+/* If LOCK_TOKENS is not NULL, then copy all tokens into the access context
+ of FS. The tokens' paths will be prepended with FSPATH_BASE.
+
+ ACCESS_POOL must match (or exceed) the lifetime of the access context
+ that was associated with FS. Typically, this is the session pool.
+
+ Temporary allocations are made in SCRATCH_POOL. */
+static svn_error_t *
+apply_lock_tokens(svn_fs_t *fs,
+ const char *fspath_base,
+ apr_hash_t *lock_tokens,
+ apr_pool_t *access_pool,
+ apr_pool_t *scratch_pool)
+{
+ if (lock_tokens)
{
- svn_error_clear(err2);
- return err1;
+ svn_fs_access_t *access_ctx;
+
+ SVN_ERR(svn_fs_get_access(&access_ctx, fs));
+
+ /* If there is no access context, the filesystem will scream if a
+ lock is needed. */
+ if (access_ctx)
+ {
+ apr_hash_index_t *hi;
+
+ /* Note: we have no use for an iterpool here since the data
+ within the loop is copied into ACCESS_POOL. */
+
+ for (hi = apr_hash_first(scratch_pool, lock_tokens); hi;
+ hi = apr_hash_next(hi))
+ {
+ const void *relpath = svn__apr_hash_index_key(hi);
+ const char *token = svn__apr_hash_index_val(hi);
+ const char *fspath;
+
+ /* The path needs to live as long as ACCESS_CTX. */
+ fspath = svn_fspath__join(fspath_base, relpath, access_pool);
+
+ /* The token must live as long as ACCESS_CTX. */
+ token = apr_pstrdup(access_pool, token);
+
+ SVN_ERR(svn_fs_access_add_lock_token2(access_ctx, fspath,
+ token));
+ }
+ }
}
- return err2;
+ return SVN_NO_ERROR;
}
+
/*----------------------------------------------------------------*/
/*** The RA vtable routines ***/
@@ -679,47 +729,24 @@ svn_ra_local__get_commit_editor(svn_ra_s
apr_pool_t *pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
- struct deltify_etc_baton *db = apr_palloc(pool, sizeof(*db));
- apr_hash_index_t *hi;
- svn_fs_access_t *fs_access;
+ struct deltify_etc_baton *deb = apr_palloc(pool, sizeof(*deb));
- db->fs = sess->fs;
- db->repos = sess->repos;
- db->fs_path = sess->fs_path->data;
+ /* Prepare the baton for deltify_etc() */
+ deb->fs = sess->fs;
+ deb->repos = sess->repos;
+ deb->fspath_base = sess->fs_path->data;
if (! keep_locks)
- db->lock_tokens = lock_tokens;
+ deb->lock_tokens = lock_tokens;
else
- db->lock_tokens = NULL;
- db->pool = pool;
- db->callback = callback;
- db->callback_baton = callback_baton;
+ deb->lock_tokens = NULL;
+ deb->commit_cb = callback;
+ deb->commit_baton = callback_baton;
SVN_ERR(get_username(session, pool));
/* If there are lock tokens to add, do so. */
- if (lock_tokens)
- {
- SVN_ERR(svn_fs_get_access(&fs_access, sess->fs));
-
- /* If there is no access context, the filesystem will scream if a
- lock is needed. */
- if (fs_access)
- {
- for (hi = apr_hash_first(pool, lock_tokens); hi;
- hi = apr_hash_next(hi))
- {
- void *val;
- const char *abs_path, *token;
- const void *key;
-
- apr_hash_this(hi, &key, NULL, &val);
- abs_path = svn_fspath__join(sess->fs_path->data, key, pool);
- token = val;
- SVN_ERR(svn_fs_access_add_lock_token2(fs_access,
- abs_path, token));
- }
- }
- }
+ SVN_ERR(apply_lock_tokens(sess->fs, sess->fs_path->data, lock_tokens,
+ session->pool, pool));
/* Copy the revprops table so we can add the username. */
revprop_table = apr_hash_copy(pool, revprop_table);
@@ -730,7 +757,7 @@ svn_ra_local__get_commit_editor(svn_ra_s
return svn_repos_get_commit_editor5
(editor, edit_baton, sess->repos, NULL,
svn_path_uri_decode(sess->repos_url, pool), sess->fs_path->data,
- revprop_table, deltify_etc, db, NULL, NULL, pool);
+ revprop_table, deltify_etc, deb, NULL, NULL, pool);
}
@@ -1514,6 +1541,62 @@ svn_ra_local__register_editor_shim_callb
return SVN_NO_ERROR;
}
+
+static svn_error_t *
+svn_ra_local__get_commit_ev2(svn_editor_t **editor,
+ svn_ra_session_t *session,
+ apr_hash_t *revprops,
+ svn_commit_callback2_t commit_cb,
+ void *commit_baton,
+ apr_hash_t *lock_tokens,
+ svn_boolean_t keep_locks,
+ svn_ra__provide_base_cb_t provide_base_cb,
+ svn_ra__provide_props_cb_t provide_props_cb,
+ svn_ra__get_copysrc_kind_cb_t get_copysrc_kind_cb,
+ void *cb_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_ra_local__session_baton_t *sess = session->priv;
+ struct deltify_etc_baton *deb = apr_palloc(result_pool, sizeof(*deb));
+
+ /* NOTE: the RA callbacks are ignored. We pass everything directly to
+ the REPOS editor. */
+
+ /* Prepare the baton for deltify_etc() */
+ deb->fs = sess->fs;
+ deb->repos = sess->repos;
+ deb->fspath_base = sess->fs_path->data;
+ if (! keep_locks)
+ deb->lock_tokens = lock_tokens;
+ else
+ deb->lock_tokens = NULL;
+ deb->commit_cb = commit_cb;
+ deb->commit_baton = commit_baton;
+
+ /* Ensure there is a username (and an FS access context) associated with
+ the session and its FS handle. */
+ SVN_ERR(get_username(session, scratch_pool));
+
+ /* If there are lock tokens to add, do so. */
+ SVN_ERR(apply_lock_tokens(sess->fs, sess->fs_path->data, lock_tokens,
+ session->pool, scratch_pool));
+
+ /* Copy the REVPROPS and insert the author/username. */
+ revprops = apr_hash_copy(scratch_pool, revprops);
+ apr_hash_set(revprops, SVN_PROP_REVISION_AUTHOR, APR_HASH_KEY_STRING,
+ svn_string_create(sess->username, scratch_pool));
+
+ return svn_error_trace(svn_repos__get_commit_ev2(
+ editor, sess->repos, NULL /* authz */,
+ NULL /* authz_repos_name */, NULL /* authz_user */,
+ revprops,
+ deltify_etc, deb, cancel_func, cancel_baton,
+ result_pool, scratch_pool));
+}
+
/*----------------------------------------------------------------*/
static const svn_version_t *
@@ -1561,7 +1644,8 @@ static const svn_ra__vtable_t ra_local_v
svn_ra_local__has_capability,
svn_ra_local__replay_range,
svn_ra_local__get_deleted_rev,
- svn_ra_local__register_editor_shim_callbacks
+ svn_ra_local__register_editor_shim_callbacks,
+ svn_ra_local__get_commit_ev2
};
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra_neon/commit.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra_neon/commit.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra_neon/commit.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra_neon/commit.c Tue May 29 01:39:41 2012
@@ -737,6 +737,7 @@ static svn_error_t * commit_open_root(vo
transaction (and, optionally, a corresponding activity). */
svn_ra_neon__request_t *req;
const char *header_val;
+ svn_error_t *err;
SVN_ERR(svn_ra_neon__request_create(&req, cc->ras, "POST",
cc->ras->me_resource, dir_pool));
@@ -749,33 +750,39 @@ static svn_error_t * commit_open_root(vo
svn_uuid_generate(dir_pool));
#endif
- SVN_ERR(svn_ra_neon__request_dispatch(NULL, req, NULL, "( create-txn )",
- 201, 0, dir_pool));
-
- /* Check the response headers for either the virtual transaction
- details, or the real transaction details. We need to have
- one or the other of those! */
- if ((header_val = ne_get_response_header(req->ne_req,
- SVN_DAV_VTXN_NAME_HEADER)))
- {
- cc->txn_url = svn_path_url_add_component2(cc->ras->vtxn_stub,
- header_val, cc->pool);
- cc->txn_root_url
- = svn_path_url_add_component2(cc->ras->vtxn_root_stub,
- header_val, cc->pool);
- }
- else if ((header_val = ne_get_response_header(req->ne_req,
- SVN_DAV_TXN_NAME_HEADER)))
- {
- cc->txn_url = svn_path_url_add_component2(cc->ras->txn_stub,
- header_val, cc->pool);
- cc->txn_root_url = svn_path_url_add_component2(cc->ras->txn_root_stub,
- header_val, cc->pool);
+ err = svn_ra_neon__request_dispatch(NULL, req, NULL, "( create-txn )",
+ 201, 0, dir_pool);
+ if (!err)
+ {
+ /* Check the response headers for either the virtual transaction
+ details, or the real transaction details. We need to have
+ one or the other of those! */
+ if ((header_val = ne_get_response_header(req->ne_req,
+ SVN_DAV_VTXN_NAME_HEADER)))
+ {
+ cc->txn_url = svn_path_url_add_component2(cc->ras->vtxn_stub,
+ header_val, cc->pool);
+ cc->txn_root_url
+ = svn_path_url_add_component2(cc->ras->vtxn_root_stub,
+ header_val, cc->pool);
+ }
+ else if ((header_val
+ = ne_get_response_header(req->ne_req,
+ SVN_DAV_TXN_NAME_HEADER)))
+ {
+ cc->txn_url = svn_path_url_add_component2(cc->ras->txn_stub,
+ header_val, cc->pool);
+ cc->txn_root_url
+ = svn_path_url_add_component2(cc->ras->txn_root_stub,
+ header_val, cc->pool);
+ }
+ else
+ err = svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
+ _("POST request did not return transaction "
+ "information"));
}
- else
- return svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
- _("POST request did not return transaction "
- "information"));
+ svn_ra_neon__request_destroy(req);
+ SVN_ERR(err);
root->rsrc = NULL;
root->txn_root_url = svn_path_url_add_component2(cc->txn_root_url,
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra_neon/util.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra_neon/util.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra_neon/util.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra_neon/util.c Tue May 29 01:39:41 2012
@@ -245,7 +245,12 @@ end_207_element(void *baton, int state,
case ELEM_responsedescription:
if (b->in_propstat)
- svn_stringbuf_set(b->propstat_description, b->cdata->data);
+ {
+ /* Remove leading newline added by DEBUG_CR on server */
+ svn_stringbuf_strip_whitespace(b->cdata);
+
+ svn_stringbuf_set(b->propstat_description, b->cdata->data);
+ }
else
{
if (! svn_stringbuf_isempty(b->description))
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra_serf/blame.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra_serf/blame.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra_serf/blame.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra_serf/blame.c Tue May 29 01:39:41 2012
@@ -22,9 +22,6 @@
*/
#include <apr_uri.h>
-
-#include <expat.h>
-
#include <serf.h>
#include "svn_pools.h"
@@ -50,6 +47,7 @@
*/
typedef enum blame_state_e {
NONE = 0,
+ INITIAL = 0,
FILE_REVS_REPORT,
FILE_REV,
REV_PROP,
@@ -112,6 +110,42 @@ typedef struct blame_context_t {
void *file_rev_baton;
} blame_context_t;
+
+#if 0
+/* ### we cannot use this yet since the CDATA is unbounded and cannot be
+ ### collected by the parsing context. we need a streamy mechanism for
+ ### this report. */
+
+#define D_ "DAV:"
+#define S_ SVN_XML_NAMESPACE
+static const svn_ra_serf__xml_transition_t blame_ttable[] = {
+ { INITIAL, S_, "file-revs-report", FILE_REVS_REPORT,
+ FALSE, { NULL }, FALSE, FALSE },
+
+ { FILE_REVS_REPORT, S_, "file-rev", FILE_REV,
+ FALSE, { "path", "rev", NULL }, FALSE, TRUE },
+
+ { FILE_REV, D_, "rev-prop", REV_PROP,
+ TRUE, { "name", "?encoding", NULL }, FALSE, TRUE },
+
+ { FILE_REV, D_, "set-prop", SET_PROP,
+ TRUE, { "name", "?encoding", NULL }, FALSE, TRUE },
+
+ { FILE_REV, D_, "remove-prop", REMOVE_PROP,
+ FALSE, { "name", "?encoding", NULL }, FALSE, TRUE },
+
+ { FILE_REV, D_, "merged-revision", MERGED_REVISION,
+ FALSE, { NULL }, FALSE, FALSE },
+
+ { FILE_REV, D_, "txdelta", TXDELTA,
+ TRUE, { NULL }, FALSE, TRUE },
+
+ { 0 }
+};
+
+#endif
+
+
static blame_info_t *
push_state(svn_ra_serf__xml_parser_t *parser,
@@ -427,8 +461,7 @@ svn_ra_serf__get_file_revs(svn_ra_sessio
svn_ra_serf__session_t *session = ra_session->priv;
svn_ra_serf__handler_t *handler;
svn_ra_serf__xml_parser_t *parser_ctx;
- const char *relative_url, *basecoll_url, *req_url;
- int status_code;
+ const char *req_url;
svn_error_t *err;
blame_ctx = apr_pcalloc(pool, sizeof(*blame_ctx));
@@ -441,13 +474,14 @@ svn_ra_serf__get_file_revs(svn_ra_sessio
blame_ctx->include_merged_revisions = include_merged_revisions;
blame_ctx->done = FALSE;
- SVN_ERR(svn_ra_serf__get_baseline_info(&basecoll_url, &relative_url, session,
- NULL, session->session_url.path,
- end, NULL, pool));
- req_url = svn_path_url_add_component2(basecoll_url, relative_url, pool);
+ SVN_ERR(svn_ra_serf__get_stable_url(&req_url, NULL /* latest_revnum */,
+ session, NULL /* conn */,
+ NULL /* url */, end,
+ pool, pool));
handler = apr_pcalloc(pool, sizeof(*handler));
+ handler->handler_pool = pool;
handler->method = "REPORT";
handler->path = req_url;
handler->body_type = "text/xml";
@@ -464,7 +498,6 @@ svn_ra_serf__get_file_revs(svn_ra_sessio
parser_ctx->end = end_blame;
parser_ctx->cdata = cdata_blame;
parser_ctx->done = &blame_ctx->done;
- parser_ctx->status_code = &status_code;
handler->response_handler = svn_ra_serf__handle_xml_parser;
handler->response_baton = parser_ctx;
@@ -474,9 +507,9 @@ svn_ra_serf__get_file_revs(svn_ra_sessio
err = svn_ra_serf__context_run_wait(&blame_ctx->done, session, pool);
err = svn_error_compose_create(
- svn_ra_serf__error_on_status(status_code,
+ svn_ra_serf__error_on_status(handler->sline.code,
handler->path,
- parser_ctx->location),
+ handler->location),
err);
return svn_error_trace(err);
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra_serf/commit.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra_serf/commit.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra_serf/commit.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra_serf/commit.c Tue May 29 01:39:41 2012
@@ -22,9 +22,6 @@
*/
#include <apr_uri.h>
-
-#include <expat.h>
-
#include <serf.h>
#include "svn_pools.h"
@@ -48,14 +45,17 @@
/* Structure associated with a CHECKOUT request. */
typedef struct checkout_context_t {
+ /* The handler running the CHECKOUT. */
+ svn_ra_serf__handler_t *handler;
- apr_pool_t *pool;
+ /* The pool for allocating RESOURCE_URL. */
+ apr_pool_t *result_pool;
+ /* The activity that will hold the checked-out resource. */
const char *activity_url;
- const char *checkout_url;
- const char *resource_url;
- svn_ra_serf__simple_request_context_t progress;
+ /* The output: */
+ const char *resource_url;
} checkout_context_t;
@@ -82,7 +82,7 @@ typedef struct commit_context_t {
/* HTTP v1 stuff (only valid when 'txn_url' is NULL) */
const char *activity_url; /* activity base URL... */
- checkout_context_t *baseline; /* checkout for the baseline */
+ const char *baseline_url; /* the working-baseline resource */
const char *checked_in_url; /* checked-in root to base CHECKOUTs from */
const char *vcc_url; /* vcc url */
@@ -110,7 +110,6 @@ typedef struct proppatch_context_t {
/* In HTTP v2, this is the file/directory version we think we're changing. */
svn_revnum_t base_revision;
- svn_ra_serf__simple_request_context_t progress;
} proppatch_context_t;
typedef struct delete_context_t {
@@ -122,7 +121,6 @@ typedef struct delete_context_t {
apr_hash_t *lock_token_hash;
svn_boolean_t keep_locks;
- svn_ra_serf__simple_request_context_t progress;
} delete_context_t;
/* Represents a directory. */
@@ -162,9 +160,9 @@ typedef struct dir_context_t {
apr_hash_t *changed_props;
apr_hash_t *removed_props;
- /* The checked out context for this directory. May be NULL; if so
+ /* The checked-out working resource for this directory. May be NULL; if so
call checkout_dir() first. */
- checkout_context_t *checkout;
+ const char *working_url;
} dir_context_t;
@@ -184,8 +182,8 @@ typedef struct file_context_t {
const char *relpath;
const char *name;
- /* The checked out context for this file. */
- checkout_context_t *checkout;
+ /* The checked-out working resource for this file. */
+ const char *working_url;
/* The base revision of the file. */
svn_revnum_t base_revision;
@@ -219,24 +217,29 @@ typedef struct file_context_t {
/* Setup routines and handlers for various requests we'll invoke. */
static svn_error_t *
-return_response_err(svn_ra_serf__handler_t *handler,
- svn_ra_serf__simple_request_context_t *ctx)
+return_response_err(svn_ra_serf__handler_t *handler)
{
svn_error_t *err;
+ /* We should have captured SLINE and LOCATION in the HANDLER. */
+ SVN_ERR_ASSERT(handler->handler_pool != NULL);
+
/* Ye Olde Fallback Error */
err = svn_error_compose_create(
- ctx->server_error.error,
+ handler->server_error != NULL
+ ? handler->server_error->error
+ : SVN_NO_ERROR,
svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
_("%s of '%s': %d %s"),
handler->method, handler->path,
- ctx->status, ctx->reason));
+ handler->sline.code, handler->sline.reason));
/* Try to return one of the standard errors for 301, 404, etc.,
then look for an error embedded in the response. */
- return svn_error_compose_create(svn_ra_serf__error_on_status(ctx->status,
- handler->path,
- ctx->location),
+ return svn_error_compose_create(svn_ra_serf__error_on_status(
+ handler->sline.code,
+ handler->path,
+ handler->location),
err);
}
@@ -259,8 +262,10 @@ create_checkout_body(serf_bucket_t **bkt
svn_ra_serf__add_open_tag_buckets(body_bkt, alloc, "D:activity-set", NULL);
svn_ra_serf__add_open_tag_buckets(body_bkt, alloc, "D:href", NULL);
+ SVN_ERR_ASSERT(ctx->activity_url != NULL);
svn_ra_serf__add_cdata_len_buckets(body_bkt, alloc,
- ctx->activity_url, strlen(ctx->activity_url));
+ ctx->activity_url,
+ strlen(ctx->activity_url));
svn_ra_serf__add_close_tag_buckets(body_bkt, alloc, "D:href");
svn_ra_serf__add_close_tag_buckets(body_bkt, alloc, "D:activity-set");
@@ -275,13 +280,14 @@ create_checkout_body(serf_bucket_t **bkt
static svn_error_t *
handle_checkout(serf_request_t *request,
serf_bucket_t *response,
- void *handler_baton,
+ void *baton,
apr_pool_t *pool)
{
- checkout_context_t *ctx = handler_baton;
+ checkout_context_t *ctx = baton;
+ svn_ra_serf__handler_t *handler = ctx->handler;
- svn_error_t *err = svn_ra_serf__handle_status_only(request, response,
- &ctx->progress, pool);
+ svn_error_t *err = svn_ra_serf__expect_empty_body(request, response,
+ handler, pool);
/* These handler functions are supposed to return an APR_EOF status
wrapped in a svn_error_t to indicate to serf that the response was
@@ -291,7 +297,7 @@ handle_checkout(serf_request_t *request,
return err;
/* Get the resulting location. */
- if (ctx->progress.done && ctx->progress.status == 201)
+ if (handler->done && handler->sline.code == 201)
{
serf_bucket_t *hdrs;
apr_uri_t uri;
@@ -309,21 +315,86 @@ handle_checkout(serf_request_t *request,
if (status)
err = svn_error_compose_create(svn_error_wrap_apr(status, NULL), err);
- ctx->resource_url = svn_urlpath__canonicalize(uri.path, ctx->pool);
+ SVN_ERR_ASSERT(ctx->result_pool != NULL);
+ ctx->resource_url = svn_urlpath__canonicalize(uri.path,
+ ctx->result_pool);
}
return err;
}
+
+/* Using the HTTPv1 protocol, perform a CHECKOUT of NODE_URL within the
+ given COMMIT_CTX. The resulting working resource will be returned in
+ *WORKING_URL, allocated from RESULT_POOL. All temporary allocations
+ are performed in SCRATCH_POOL.
+
+ ### are these URLs actually repos relpath values? or fspath? or maybe
+ ### the abspath portion of the full URL.
+
+ This function operates synchronously.
+
+ Strictly speaking, we could perform "all" of the CHECKOUT requests
+ when the commit starts, and only block when we need a specific
+ answer. Or, at a minimum, send off these individual requests async
+ and block when we need the answer (eg PUT or PROPPATCH).
+
+ However: the investment to speed this up is not worthwhile, given
+ that CHECKOUT (and the related round trip) is completely obviated
+ in HTTPv2.
+*/
static svn_error_t *
-checkout_dir(dir_context_t *dir)
+checkout_node(const char **working_url,
+ const commit_context_t *commit_ctx,
+ const char *node_url,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_ra_serf__handler_t handler = { 0 };
+ checkout_context_t checkout_ctx = { 0 };
+
+ /* HANDLER_POOL is the scratch pool since we don't need to remember
+ anything from the handler. We just want the working resource. */
+ handler.handler_pool = scratch_pool;
+ handler.session = commit_ctx->session;
+ handler.conn = commit_ctx->conn;
+
+ checkout_ctx.handler = &handler;
+ checkout_ctx.result_pool = result_pool;
+ checkout_ctx.activity_url = commit_ctx->activity_url;
+
+ handler.body_delegate = create_checkout_body;
+ handler.body_delegate_baton = &checkout_ctx;
+ handler.body_type = "text/xml";
+
+ handler.response_handler = handle_checkout;
+ handler.response_baton = &checkout_ctx;
+
+ handler.method = "CHECKOUT";
+ handler.path = node_url;
+
+ SVN_ERR(svn_ra_serf__context_run_one(&handler, scratch_pool));
+
+ if (handler.sline.code != 201)
+ return svn_error_trace(return_response_err(&handler));
+
+ /* Already in the correct pool. */
+ *working_url = checkout_ctx.resource_url;
+
+ return SVN_NO_ERROR;
+}
+
+
+static svn_error_t *
+checkout_dir(dir_context_t *dir,
+ apr_pool_t *scratch_pool)
{
- checkout_context_t *checkout_ctx;
- svn_ra_serf__handler_t *handler;
svn_error_t *err;
dir_context_t *p_dir = dir;
+ const char *checkout_url;
+ const char **working;
- if (dir->checkout)
+ if (dir->working_url)
{
return SVN_NO_ERROR;
}
@@ -335,73 +406,41 @@ checkout_dir(dir_context_t *dir)
if (p_dir->added)
{
/* Implicitly checkout this dir now. */
- dir->checkout = apr_pcalloc(dir->pool, sizeof(*dir->checkout));
- dir->checkout->pool = dir->pool;
- dir->checkout->progress.pool = dir->pool;
- dir->checkout->activity_url = dir->commit->activity_url;
- dir->checkout->resource_url =
- svn_path_url_add_component2(dir->parent_dir->checkout->resource_url,
- dir->name, dir->pool);
-
+ dir->working_url = svn_path_url_add_component2(
+ dir->parent_dir->working_url,
+ dir->name, dir->pool);
return SVN_NO_ERROR;
}
p_dir = p_dir->parent_dir;
}
- /* Checkout our directory into the activity URL now. */
- handler = apr_pcalloc(dir->pool, sizeof(*handler));
- handler->session = dir->commit->session;
- handler->conn = dir->commit->conn;
-
- checkout_ctx = apr_pcalloc(dir->pool, sizeof(*checkout_ctx));
- checkout_ctx->pool = dir->pool;
- checkout_ctx->progress.pool = dir->pool;
-
- checkout_ctx->activity_url = dir->commit->activity_url;
-
/* We could be called twice for the root: once to checkout the baseline;
* once to checkout the directory itself if we need to do so.
+ * Note: CHECKOUT_URL should live longer than HANDLER.
*/
- if (!dir->parent_dir && !dir->commit->baseline)
+ if (!dir->parent_dir && !dir->commit->baseline_url)
{
- checkout_ctx->checkout_url = dir->commit->vcc_url;
- dir->commit->baseline = checkout_ctx;
+ checkout_url = dir->commit->vcc_url;
+ working = &dir->commit->baseline_url;
}
else
{
- checkout_ctx->checkout_url = dir->url;
- dir->checkout = checkout_ctx;
+ checkout_url = dir->url;
+ working = &dir->working_url;
}
- handler->body_delegate = create_checkout_body;
- handler->body_delegate_baton = checkout_ctx;
- handler->body_type = "text/xml";
-
- handler->response_handler = handle_checkout;
- handler->response_baton = checkout_ctx;
-
- handler->method = "CHECKOUT";
- handler->path = checkout_ctx->checkout_url;
-
- svn_ra_serf__request_create(handler);
-
- err = svn_ra_serf__context_run_wait(&checkout_ctx->progress.done,
- dir->commit->session,
- dir->pool);
+ /* Checkout our directory into the activity URL now. */
+ err = checkout_node(working, dir->commit, checkout_url,
+ dir->pool, scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_FS_CONFLICT)
- SVN_ERR_W(err, apr_psprintf(dir->pool,
+ SVN_ERR_W(err, apr_psprintf(scratch_pool,
_("Directory '%s' is out of date; try updating"),
- svn_dirent_local_style(dir->relpath, dir->pool)));
+ svn_dirent_local_style(dir->relpath, scratch_pool)));
return err;
}
- if (checkout_ctx->progress.status != 201)
- {
- return return_response_err(handler, &checkout_ctx->progress);
- }
-
return SVN_NO_ERROR;
}
@@ -419,16 +458,17 @@ checkout_dir(dir_context_t *dir)
* BASE_REVISION, and set *CHECKED_IN_URL to the concatenation of that
* with RELPATH.
*
- * Allocate the result in POOL, and use POOL for temporary allocation.
+ * Allocate the result in RESULT_POOL, and use SCRATCH_POOL for
+ * temporary allocation.
*/
static svn_error_t *
get_version_url(const char **checked_in_url,
svn_ra_serf__session_t *session,
- svn_ra_serf__connection_t *conn,
const char *relpath,
svn_revnum_t base_revision,
const char *parent_vsn_url,
- apr_pool_t *pool)
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
{
const char *root_checkout;
@@ -436,15 +476,16 @@ get_version_url(const char **checked_in_
{
const svn_string_t *current_version;
- SVN_ERR(session->wc_callbacks->get_wc_prop(session->wc_callback_baton,
- relpath,
- SVN_RA_SERF__WC_CHECKED_IN_URL,
- ¤t_version, pool));
+ SVN_ERR(session->wc_callbacks->get_wc_prop(
+ session->wc_callback_baton,
+ relpath,
+ SVN_RA_SERF__WC_CHECKED_IN_URL,
+ ¤t_version, scratch_pool));
if (current_version)
{
*checked_in_url =
- svn_urlpath__canonicalize(current_version->data, pool);
+ svn_urlpath__canonicalize(current_version->data, result_pool);
return SVN_NO_ERROR;
}
}
@@ -455,63 +496,53 @@ get_version_url(const char **checked_in_
}
else
{
- svn_ra_serf__propfind_context_t *propfind_ctx;
- apr_hash_t *props;
const char *propfind_url;
-
- props = apr_hash_make(pool);
+ svn_ra_serf__connection_t *conn = session->conns[0];
if (SVN_IS_VALID_REVNUM(base_revision))
{
- const char *bc_url, *bc_relpath;
-
/* mod_dav_svn can't handle the "Label:" header that
svn_ra_serf__deliver_props() is going to try to use for
this lookup, so we'll do things the hard(er) way, by
looking up the version URL from a resource in the
baseline collection. */
- SVN_ERR(svn_ra_serf__get_baseline_info(&bc_url, &bc_relpath,
- session, conn,
- session->session_url.path,
- base_revision, NULL, pool));
- propfind_url = svn_path_url_add_component2(bc_url, bc_relpath, pool);
+ /* ### conn==NULL for session->conns[0]. same as CONN. */
+ SVN_ERR(svn_ra_serf__get_stable_url(&propfind_url,
+ NULL /* latest_revnum */,
+ session, NULL /* conn */,
+ NULL /* url */, base_revision,
+ scratch_pool, scratch_pool));
}
else
{
propfind_url = session->session_url.path;
}
- /* ### switch to svn_ra_serf__retrieve_props */
- SVN_ERR(svn_ra_serf__deliver_props(&propfind_ctx, props, session, conn,
- propfind_url, base_revision, "0",
- checked_in_props, NULL, pool));
- SVN_ERR(svn_ra_serf__wait_for_props(propfind_ctx, session, pool));
-
- /* We wouldn't get here if the url wasn't found (404), so the checked-in
- property should have been set. */
- root_checkout =
- svn_ra_serf__get_ver_prop(props, propfind_url,
- base_revision, "DAV:", "checked-in");
-
+ SVN_ERR(svn_ra_serf__fetch_dav_prop(&root_checkout,
+ conn, propfind_url, base_revision,
+ "checked-in",
+ scratch_pool, scratch_pool));
if (!root_checkout)
return svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
_("Path '%s' not present"),
session->session_url.path);
- root_checkout = svn_urlpath__canonicalize(root_checkout, pool);
+ root_checkout = svn_urlpath__canonicalize(root_checkout, scratch_pool);
}
- *checked_in_url = svn_path_url_add_component2(root_checkout, relpath, pool);
+ *checked_in_url = svn_path_url_add_component2(root_checkout, relpath,
+ result_pool);
return SVN_NO_ERROR;
}
static svn_error_t *
-checkout_file(file_context_t *file)
+checkout_file(file_context_t *file,
+ apr_pool_t *scratch_pool)
{
- svn_ra_serf__handler_t *handler;
svn_error_t *err;
dir_context_t *parent_dir = file->parent_dir;
+ const char *checkout_url;
/* Is one of our parent dirs newly added? If so, we're already
* implicitly checked out.
@@ -521,68 +552,33 @@ checkout_file(file_context_t *file)
if (parent_dir->added)
{
/* Implicitly checkout this file now. */
- file->checkout = apr_pcalloc(file->pool, sizeof(*file->checkout));
- file->checkout->pool = file->pool;
- file->checkout->progress.pool = file->pool;
- file->checkout->activity_url = file->commit->activity_url;
- file->checkout->resource_url =
- svn_path_url_add_component2(parent_dir->checkout->resource_url,
- svn_relpath_skip_ancestor(
- parent_dir->relpath, file->relpath),
- file->pool);
+ file->working_url = svn_path_url_add_component2(
+ parent_dir->working_url,
+ svn_relpath_skip_ancestor(
+ parent_dir->relpath, file->relpath),
+ file->pool);
return SVN_NO_ERROR;
}
parent_dir = parent_dir->parent_dir;
}
- /* Checkout our file into the activity URL now. */
- handler = apr_pcalloc(file->pool, sizeof(*handler));
- handler->session = file->commit->session;
- handler->conn = file->commit->conn;
-
- file->checkout = apr_pcalloc(file->pool, sizeof(*file->checkout));
- file->checkout->pool = file->pool;
- file->checkout->progress.pool = file->pool;
-
- file->checkout->activity_url = file->commit->activity_url;
-
- SVN_ERR(get_version_url(&(file->checkout->checkout_url),
- file->commit->session, file->commit->conn,
+ SVN_ERR(get_version_url(&checkout_url,
+ file->commit->session,
file->relpath, file->base_revision,
- NULL, file->pool));
-
- handler->body_delegate = create_checkout_body;
- handler->body_delegate_baton = file->checkout;
- handler->body_type = "text/xml";
-
- handler->response_handler = handle_checkout;
- handler->response_baton = file->checkout;
+ NULL, scratch_pool, scratch_pool));
- handler->method = "CHECKOUT";
- handler->path = file->checkout->checkout_url;
-
- svn_ra_serf__request_create(handler);
-
- /* There's no need to wait here as we only need this when we start the
- * PROPPATCH or PUT of the file.
- */
- err = svn_ra_serf__context_run_wait(&file->checkout->progress.done,
- file->commit->session,
- file->pool);
+ /* Checkout our file into the activity URL now. */
+ err = checkout_node(&file->working_url, file->commit, checkout_url,
+ file->pool, scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_FS_CONFLICT)
- SVN_ERR_W(err, apr_psprintf(file->pool,
+ SVN_ERR_W(err, apr_psprintf(scratch_pool,
_("File '%s' is out of date; try updating"),
- svn_dirent_local_style(file->relpath, file->pool)));
+ svn_dirent_local_style(file->relpath, scratch_pool)));
return err;
}
- if (file->checkout->progress.status != 201)
- {
- return return_response_err(handler, &file->checkout->progress);
- }
-
return SVN_NO_ERROR;
}
@@ -920,6 +916,7 @@ proppatch_resource(proppatch_context_t *
struct proppatch_body_baton_t pbb;
handler = apr_pcalloc(pool, sizeof(*handler));
+ handler->handler_pool = pool;
handler->method = "PROPPATCH";
handler->path = proppatch->path;
handler->conn = commit->conn;
@@ -934,20 +931,19 @@ proppatch_resource(proppatch_context_t *
handler->body_delegate_baton = &pbb;
handler->response_handler = svn_ra_serf__handle_multistatus_only;
- handler->response_baton = &proppatch->progress;
-
- svn_ra_serf__request_create(handler);
+ handler->response_baton = handler;
- /* If we don't wait for the response, our pool will be gone! */
- SVN_ERR(svn_ra_serf__context_run_wait(&proppatch->progress.done,
- commit->session, pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, pool));
- if (proppatch->progress.status != 207 ||
- proppatch->progress.server_error.error)
- {
- return svn_error_create(SVN_ERR_RA_DAV_PROPPATCH_FAILED,
- return_response_err(handler, &proppatch->progress),
- _("At least one property change failed; repository is unchanged"));
+ if (handler->sline.code != 207
+ || (handler->server_error != NULL
+ && handler->server_error->error != NULL))
+ {
+ return svn_error_create(
+ SVN_ERR_RA_DAV_PROPPATCH_FAILED,
+ return_response_err(handler),
+ _("At least one property change failed; repository"
+ " is unchanged"));
}
return SVN_NO_ERROR;
@@ -1055,8 +1051,8 @@ setup_copy_file_headers(serf_bucket_t *h
serf_bucket_headers_set(headers, "Destination", absolute_uri);
- serf_bucket_headers_set(headers, "Depth", "0");
- serf_bucket_headers_set(headers, "Overwrite", "T");
+ serf_bucket_headers_setn(headers, "Depth", "0");
+ serf_bucket_headers_setn(headers, "Overwrite", "T");
return SVN_NO_ERROR;
}
@@ -1080,22 +1076,18 @@ setup_copy_dir_headers(serf_bucket_t *he
else
{
uri.path = (char *)svn_path_url_add_component2(
- dir->parent_dir->checkout->resource_url,
+ dir->parent_dir->working_url,
dir->name, pool);
}
absolute_uri = apr_uri_unparse(pool, &uri, 0);
serf_bucket_headers_set(headers, "Destination", absolute_uri);
- serf_bucket_headers_set(headers, "Depth", "infinity");
- serf_bucket_headers_set(headers, "Overwrite", "T");
+ serf_bucket_headers_setn(headers, "Depth", "infinity");
+ serf_bucket_headers_setn(headers, "Overwrite", "T");
/* Implicitly checkout this dir now. */
- dir->checkout = apr_pcalloc(dir->pool, sizeof(*dir->checkout));
- dir->checkout->pool = dir->pool;
- dir->checkout->progress.pool = dir->pool;
- dir->checkout->activity_url = dir->commit->activity_url;
- dir->checkout->resource_url = apr_pstrdup(dir->checkout->pool, uri.path);
+ dir->working_url = apr_pstrdup(dir->pool, uri.path);
return SVN_NO_ERROR;
}
@@ -1125,8 +1117,8 @@ setup_delete_headers(serf_bucket_t *head
serf_bucket_headers_set(headers, "If", token_header);
if (ctx->keep_locks)
- serf_bucket_headers_set(headers, SVN_DAV_OPTIONS_HEADER,
- SVN_DAV_OPTION_KEEP_LOCKS);
+ serf_bucket_headers_setn(headers, SVN_DAV_OPTIONS_HEADER,
+ SVN_DAV_OPTION_KEEP_LOCKS);
}
}
@@ -1205,7 +1197,7 @@ setup_post_headers(serf_bucket_t *header
/* Handler baton for POST request. */
typedef struct post_response_ctx_t
{
- svn_ra_serf__simple_request_context_t *request_ctx;
+ svn_ra_serf__handler_t *handler;
commit_context_t *commit_ctx;
} post_response_ctx_t;
@@ -1250,14 +1242,15 @@ post_headers_iterator_callback(void *bat
/* A custom serf_response_handler_t which is mostly a wrapper around
- svn_ra_serf__handle_status_only -- it just notices POST response
+ svn_ra_serf__expect_empty_body -- it just notices POST response
headers, too.
+
Implements svn_ra_serf__response_handler_t */
static svn_error_t *
post_response_handler(serf_request_t *request,
serf_bucket_t *response,
void *baton,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
post_response_ctx_t *prc = baton;
serf_bucket_t *hdrs = serf_bucket_response_get_headers(response);
@@ -1266,8 +1259,8 @@ post_response_handler(serf_request_t *re
serf_bucket_headers_do(hdrs, post_headers_iterator_callback, prc);
/* Execute the 'real' response handler to XML-parse the repsonse body. */
- return svn_ra_serf__handle_status_only(request, response,
- prc->request_ctx, pool);
+ return svn_ra_serf__expect_empty_body(request, response,
+ prc->handler, scratch_pool);
}
@@ -1289,12 +1282,12 @@ open_root(void *edit_baton,
if (SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(ctx->session))
{
- svn_ra_serf__simple_request_context_t *post_ctx;
post_response_ctx_t *prc;
const char *rel_path;
/* Create our activity URL now on the server. */
handler = apr_pcalloc(ctx->pool, sizeof(*handler));
+ handler->handler_pool = ctx->pool;
handler->method = "POST";
handler->body_type = SVN_SKEL_MIME_TYPE;
handler->body_delegate = create_txn_post_body;
@@ -1305,25 +1298,20 @@ open_root(void *edit_baton,
handler->conn = ctx->session->conns[0];
handler->session = ctx->session;
- post_ctx = apr_pcalloc(ctx->pool, sizeof(*post_ctx));
- post_ctx->pool = ctx->pool;
-
prc = apr_pcalloc(ctx->pool, sizeof(*prc));
- prc->request_ctx = post_ctx;
+ prc->handler = handler;
prc->commit_ctx = ctx;
handler->response_handler = post_response_handler;
handler->response_baton = prc;
- svn_ra_serf__request_create(handler);
-
- SVN_ERR(svn_ra_serf__context_run_wait(&post_ctx->done, ctx->session,
- ctx->pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, ctx->pool));
- if (post_ctx->status != 201)
+ if (handler->sline.code != 201)
{
apr_status_t status = SVN_ERR_RA_DAV_REQUEST_FAILED;
- switch(post_ctx->status)
+
+ switch (handler->sline.code)
{
case 403:
status = SVN_ERR_RA_DAV_FORBIDDEN;
@@ -1336,7 +1324,7 @@ open_root(void *edit_baton,
return svn_error_createf(status, NULL,
_("%s of '%s': %d %s (%s://%s)"),
handler->method, handler->path,
- post_ctx->status, post_ctx->reason,
+ handler->sline.code, handler->sline.reason,
ctx->session->session_url.scheme,
ctx->session->session_url.hostinfo);
}
@@ -1369,20 +1357,12 @@ open_root(void *edit_baton,
}
else
{
- svn_ra_serf__options_context_t *opt_ctx;
- svn_ra_serf__simple_request_context_t *mkact_ctx;
const char *activity_str;
- SVN_ERR(svn_ra_serf__create_options_req(&opt_ctx, ctx->session,
- ctx->session->conns[0],
- ctx->session->session_url.path,
- ctx->pool));
-
- SVN_ERR(svn_ra_serf__context_run_wait(
- svn_ra_serf__get_options_done_ptr(opt_ctx),
- ctx->session, ctx->pool));
-
- activity_str = svn_ra_serf__options_get_activity_collection(opt_ctx);
+ SVN_ERR(svn_ra_serf__v1_get_activity_collection(&activity_str,
+ ctx->session->conns[0],
+ ctx->pool,
+ ctx->pool));
if (!activity_str)
return svn_error_create(SVN_ERR_RA_DAV_OPTIONS_REQ_FAILED, NULL,
_("The OPTIONS response did not include the "
@@ -1394,26 +1374,22 @@ open_root(void *edit_baton,
/* Create our activity URL now on the server. */
handler = apr_pcalloc(ctx->pool, sizeof(*handler));
+ handler->handler_pool = ctx->pool;
handler->method = "MKACTIVITY";
handler->path = ctx->activity_url;
handler->conn = ctx->session->conns[0];
handler->session = ctx->session;
- mkact_ctx = apr_pcalloc(ctx->pool, sizeof(*mkact_ctx));
- mkact_ctx->pool = ctx->pool;
-
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = mkact_ctx;
-
- svn_ra_serf__request_create(handler);
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
- SVN_ERR(svn_ra_serf__context_run_wait(&mkact_ctx->done, ctx->session,
- ctx->pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, ctx->pool));
- if (mkact_ctx->status != 201)
+ if (handler->sline.code != 201)
{
apr_status_t status = SVN_ERR_RA_DAV_REQUEST_FAILED;
- switch(mkact_ctx->status)
+
+ switch (handler->sline.code)
{
case 403:
status = SVN_ERR_RA_DAV_FORBIDDEN;
@@ -1426,7 +1402,7 @@ open_root(void *edit_baton,
return svn_error_createf(status, NULL,
_("%s of '%s': %d %s (%s://%s)"),
handler->method, handler->path,
- mkact_ctx->status, mkact_ctx->reason,
+ handler->sline.code, handler->sline.reason,
ctx->session->session_url.scheme,
ctx->session->session_url.hostinfo);
}
@@ -1447,22 +1423,21 @@ open_root(void *edit_baton,
dir->removed_props = apr_hash_make(dir->pool);
SVN_ERR(get_version_url(&dir->url, dir->commit->session,
- dir->commit->conn, dir->relpath,
+ dir->relpath,
dir->base_revision, ctx->checked_in_url,
- dir->pool));
+ dir->pool, dir->pool /* scratch_pool */));
ctx->checked_in_url = dir->url;
/* Checkout our root dir */
- SVN_ERR(checkout_dir(dir));
+ SVN_ERR(checkout_dir(dir, dir->pool /* scratch_pool */));
- proppatch_target = ctx->baseline->resource_url;
+ proppatch_target = ctx->baseline_url;
}
/* PROPPATCH our revprops and pass them along. */
proppatch_ctx = apr_pcalloc(ctx->pool, sizeof(*proppatch_ctx));
proppatch_ctx->pool = dir_pool;
- proppatch_ctx->progress.pool = dir_pool;
proppatch_ctx->commit = ctx;
proppatch_ctx->path = proppatch_target;
proppatch_ctx->changed_props = apr_hash_make(proppatch_ctx->pool);
@@ -1523,8 +1498,8 @@ delete_entry(const char *path,
else
{
/* Ensure our directory has been checked out */
- SVN_ERR(checkout_dir(dir));
- delete_target = svn_path_url_add_component2(dir->checkout->resource_url,
+ SVN_ERR(checkout_dir(dir, pool /* scratch_pool */));
+ delete_target = svn_path_url_add_component2(dir->working_url,
svn_relpath_basename(path,
NULL),
pool);
@@ -1532,18 +1507,18 @@ delete_entry(const char *path,
/* DELETE our entry */
delete_ctx = apr_pcalloc(pool, sizeof(*delete_ctx));
- delete_ctx->progress.pool = pool;
delete_ctx->path = apr_pstrdup(pool, path);
delete_ctx->revision = revision;
delete_ctx->lock_token_hash = dir->commit->lock_tokens;
delete_ctx->keep_locks = dir->commit->keep_locks;
handler = apr_pcalloc(pool, sizeof(*handler));
+ handler->handler_pool = pool;
handler->session = dir->commit->session;
handler->conn = dir->commit->conn;
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = &delete_ctx->progress;
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
handler->header_delegate = setup_delete_headers;
handler->header_delegate_baton = delete_ctx;
@@ -1551,10 +1526,7 @@ delete_entry(const char *path,
handler->method = "DELETE";
handler->path = delete_target;
- svn_ra_serf__request_create(handler);
-
- err = svn_ra_serf__context_run_wait(&delete_ctx->progress.done,
- dir->commit->session, pool);
+ err = svn_ra_serf__context_run_one(handler, pool);
if (err &&
(err->apr_err == SVN_ERR_FS_BAD_LOCK_TOKEN ||
@@ -1572,12 +1544,7 @@ delete_entry(const char *path,
handler->body_delegate_baton = delete_ctx;
handler->body_type = "text/xml";
- svn_ra_serf__request_create(handler);
-
- delete_ctx->progress.done = 0;
-
- SVN_ERR(svn_ra_serf__context_run_wait(&delete_ctx->progress.done,
- dir->commit->session, pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, pool));
}
else if (err)
{
@@ -1585,9 +1552,9 @@ delete_entry(const char *path,
}
/* 204 No Content: item successfully deleted */
- if (delete_ctx->progress.status != 204)
+ if (handler->sline.code != 204)
{
- return return_response_err(handler, &delete_ctx->progress);
+ return svn_error_trace(return_response_err(handler));
}
apr_hash_set(dir->commit->deleted_entries,
@@ -1608,7 +1575,6 @@ add_directory(const char *path,
dir_context_t *parent = parent_baton;
dir_context_t *dir;
svn_ra_serf__handler_t *handler;
- svn_ra_serf__simple_request_context_t *add_dir_ctx;
apr_status_t status;
const char *mkcol_target;
@@ -1635,24 +1601,22 @@ add_directory(const char *path,
else
{
/* Ensure our parent is checked out. */
- SVN_ERR(checkout_dir(parent));
+ SVN_ERR(checkout_dir(parent, dir->pool /* scratch_pool */));
dir->url = svn_path_url_add_component2(parent->commit->checked_in_url,
dir->name, dir->pool);
mkcol_target = svn_path_url_add_component2(
- parent->checkout->resource_url,
+ parent->working_url,
dir->name, dir->pool);
}
handler = apr_pcalloc(dir->pool, sizeof(*handler));
+ handler->handler_pool = dir->pool;
handler->conn = dir->commit->conn;
handler->session = dir->commit->session;
- add_dir_ctx = apr_pcalloc(dir->pool, sizeof(*add_dir_ctx));
- add_dir_ctx->pool = dir->pool;
-
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = add_dir_ctx;
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
if (!dir->copy_path)
{
handler->method = "MKCOL";
@@ -1661,7 +1625,7 @@ add_directory(const char *path,
else
{
apr_uri_t uri;
- const char *rel_copy_path, *basecoll_url, *req_url;
+ const char *req_url;
status = apr_uri_parse(dir->pool, dir->copy_path, &uri);
if (status)
@@ -1671,13 +1635,12 @@ add_directory(const char *path,
dir->copy_path);
}
- SVN_ERR(svn_ra_serf__get_baseline_info(&basecoll_url, &rel_copy_path,
- dir->commit->session,
- dir->commit->conn,
- uri.path, dir->copy_revision,
- NULL, dir_pool));
- req_url = svn_path_url_add_component2(basecoll_url, rel_copy_path,
- dir->pool);
+ /* ### conn==NULL for session->conns[0]. same as commit->conn. */
+ SVN_ERR(svn_ra_serf__get_stable_url(&req_url, NULL /* latest_revnum */,
+ dir->commit->session,
+ NULL /* conn */,
+ uri.path, dir->copy_revision,
+ dir_pool, dir_pool));
handler->method = "COPY";
handler->path = req_url;
@@ -1686,29 +1649,24 @@ add_directory(const char *path,
handler->header_delegate_baton = dir;
}
- svn_ra_serf__request_create(handler);
-
- SVN_ERR(svn_ra_serf__context_run_wait(&add_dir_ctx->done,
- dir->commit->session, dir->pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, dir->pool));
- switch (add_dir_ctx->status)
+ switch (handler->sline.code)
{
case 201: /* Created: item was successfully copied */
case 204: /* No Content: item successfully replaced an existing target */
break;
case 403:
- SVN_ERR(add_dir_ctx->server_error.error);
return svn_error_createf(SVN_ERR_RA_DAV_FORBIDDEN, NULL,
_("Access to '%s' forbidden"),
handler->path);
default:
- SVN_ERR(add_dir_ctx->server_error.error);
return svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
_("Adding directory failed: %s on %s "
"(%d %s)"),
handler->method, handler->path,
- add_dir_ctx->status, add_dir_ctx->reason);
+ handler->sline.code, handler->sline.reason);
}
*child_baton = dir;
@@ -1748,9 +1706,10 @@ open_directory(const char *path,
else
{
SVN_ERR(get_version_url(&dir->url,
- dir->commit->session, dir->commit->conn,
+ dir->commit->session,
dir->relpath, dir->base_revision,
- dir->commit->checked_in_url, dir->pool));
+ dir->commit->checked_in_url,
+ dir->pool, dir->pool /* scratch_pool */));
}
*child_baton = dir;
@@ -1775,9 +1734,9 @@ change_dir_prop(void *dir_baton,
else
{
/* Ensure we have a checked out dir. */
- SVN_ERR(checkout_dir(dir));
+ SVN_ERR(checkout_dir(dir, pool /* scratch_pool */));
- proppatch_target = dir->checkout->resource_url;
+ proppatch_target = dir->working_url;
}
name = apr_pstrdup(dir->pool, name);
@@ -1825,7 +1784,6 @@ close_directory(void *dir_baton,
proppatch_ctx = apr_pcalloc(pool, sizeof(*proppatch_ctx));
proppatch_ctx->pool = pool;
- proppatch_ctx->progress.pool = pool;
proppatch_ctx->commit = dir->commit;
proppatch_ctx->relpath = dir->relpath;
proppatch_ctx->changed_props = dir->changed_props;
@@ -1838,7 +1796,7 @@ close_directory(void *dir_baton,
}
else
{
- proppatch_ctx->path = dir->checkout->resource_url;
+ proppatch_ctx->path = dir->working_url;
}
SVN_ERR(proppatch_resource(proppatch_ctx, dir->commit, dir->pool));
@@ -1886,10 +1844,10 @@ add_file(const char *path,
else
{
/* Ensure our parent directory has been checked out */
- SVN_ERR(checkout_dir(dir));
+ SVN_ERR(checkout_dir(dir, new_file->pool /* scratch_pool */));
new_file->url =
- svn_path_url_add_component2(dir->checkout->resource_url,
+ svn_path_url_add_component2(dir->working_url,
new_file->name, new_file->pool);
}
@@ -1906,28 +1864,22 @@ add_file(const char *path,
if (! ((dir->added && !dir->copy_path) ||
(deleted_parent && deleted_parent[0] != '\0')))
{
- svn_ra_serf__simple_request_context_t *head_ctx;
svn_ra_serf__handler_t *handler;
- head_ctx = apr_pcalloc(new_file->pool, sizeof(*head_ctx));
- head_ctx->pool = new_file->pool;
-
handler = apr_pcalloc(new_file->pool, sizeof(*handler));
+ handler->handler_pool = new_file->pool;
handler->session = new_file->commit->session;
handler->conn = new_file->commit->conn;
handler->method = "HEAD";
handler->path = svn_path_url_add_component2(
dir->commit->session->session_url.path,
path, new_file->pool);
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = head_ctx;
- svn_ra_serf__request_create(handler);
-
- SVN_ERR(svn_ra_serf__context_run_wait(&head_ctx->done,
- new_file->commit->session,
- new_file->pool));
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
- if (head_ctx->status != 404)
+ SVN_ERR(svn_ra_serf__context_run_one(handler, new_file->pool));
+
+ if (handler->sline.code != 404)
{
return svn_error_createf(SVN_ERR_RA_DAV_ALREADY_EXISTS, NULL,
_("File '%s' already exists"), path);
@@ -1971,9 +1923,9 @@ open_file(const char *path,
else
{
/* CHECKOUT the file into our activity. */
- SVN_ERR(checkout_file(new_file));
+ SVN_ERR(checkout_file(new_file, new_file->pool /* scratch_pool */));
- new_file->url = new_file->checkout->resource_url;
+ new_file->url = new_file->working_url;
}
*file_baton = new_file;
@@ -2059,7 +2011,7 @@ change_file_prop(void *file_baton,
static svn_error_t *
close_file(void *file_baton,
const char *text_checksum,
- apr_pool_t *pool)
+ apr_pool_t *scratch_pool)
{
file_context_t *ctx = file_baton;
svn_boolean_t put_empty_file = FALSE;
@@ -2070,11 +2022,10 @@ close_file(void *file_baton,
if (ctx->copy_path)
{
svn_ra_serf__handler_t *handler;
- svn_ra_serf__simple_request_context_t *copy_ctx;
apr_uri_t uri;
- const char *rel_copy_path, *basecoll_url, *req_url;
+ const char *req_url;
- status = apr_uri_parse(pool, ctx->copy_path, &uri);
+ status = apr_uri_parse(scratch_pool, ctx->copy_path, &uri);
if (status)
{
return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
@@ -2082,36 +2033,31 @@ close_file(void *file_baton,
ctx->copy_path);
}
- SVN_ERR(svn_ra_serf__get_baseline_info(&basecoll_url, &rel_copy_path,
- ctx->commit->session,
- ctx->commit->conn,
- uri.path, ctx->copy_revision,
- NULL, pool));
- req_url = svn_path_url_add_component2(basecoll_url, rel_copy_path, pool);
+ /* ### conn==NULL for session->conns[0]. same as commit->conn. */
+ SVN_ERR(svn_ra_serf__get_stable_url(&req_url, NULL /* latest_revnum */,
+ ctx->commit->session,
+ NULL /* conn */,
+ uri.path, ctx->copy_revision,
+ scratch_pool, scratch_pool));
- handler = apr_pcalloc(pool, sizeof(*handler));
+ handler = apr_pcalloc(scratch_pool, sizeof(*handler));
+ handler->handler_pool = scratch_pool;
handler->method = "COPY";
handler->path = req_url;
handler->conn = ctx->commit->conn;
handler->session = ctx->commit->session;
- copy_ctx = apr_pcalloc(pool, sizeof(*copy_ctx));
- copy_ctx->pool = pool;
-
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = copy_ctx;
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
handler->header_delegate = setup_copy_file_headers;
handler->header_delegate_baton = ctx;
- svn_ra_serf__request_create(handler);
-
- SVN_ERR(svn_ra_serf__context_run_wait(©_ctx->done,
- ctx->commit->session, pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, scratch_pool));
- if (copy_ctx->status != 201 && copy_ctx->status != 204)
+ if (handler->sline.code != 201 && handler->sline.code != 204)
{
- return return_response_err(handler, copy_ctx);
+ return svn_error_trace(return_response_err(handler));
}
}
@@ -2125,19 +2071,16 @@ close_file(void *file_baton,
if (ctx->stream || put_empty_file)
{
svn_ra_serf__handler_t *handler;
- svn_ra_serf__simple_request_context_t *put_ctx;
- handler = apr_pcalloc(pool, sizeof(*handler));
+ handler = apr_pcalloc(scratch_pool, sizeof(*handler));
+ handler->handler_pool = scratch_pool;
handler->method = "PUT";
handler->path = ctx->url;
handler->conn = ctx->commit->conn;
handler->session = ctx->commit->session;
- put_ctx = apr_pcalloc(pool, sizeof(*put_ctx));
- put_ctx->pool = pool;
-
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = put_ctx;
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
if (put_empty_file)
{
@@ -2155,19 +2098,16 @@ close_file(void *file_baton,
handler->header_delegate = setup_put_headers;
handler->header_delegate_baton = ctx;
- svn_ra_serf__request_create(handler);
-
- SVN_ERR(svn_ra_serf__context_run_wait(&put_ctx->done,
- ctx->commit->session, pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, scratch_pool));
- if (put_ctx->status != 204 && put_ctx->status != 201)
+ if (handler->sline.code != 204 && handler->sline.code != 201)
{
- return return_response_err(handler, put_ctx);
+ return svn_error_trace(return_response_err(handler));
}
}
if (ctx->svndiff)
- SVN_ERR(svn_io_file_close(ctx->svndiff, pool));
+ SVN_ERR(svn_io_file_close(ctx->svndiff, scratch_pool));
/* If we had any prop changes, push them via PROPPATCH. */
if (apr_hash_count(ctx->changed_props) ||
@@ -2177,7 +2117,6 @@ close_file(void *file_baton,
proppatch = apr_pcalloc(ctx->pool, sizeof(*proppatch));
proppatch->pool = ctx->pool;
- proppatch->progress.pool = pool;
proppatch->relpath = ctx->relpath;
proppatch->path = ctx->url;
proppatch->commit = ctx->commit;
@@ -2197,7 +2136,6 @@ close_edit(void *edit_baton,
{
commit_context_t *ctx = edit_baton;
svn_ra_serf__merge_context_t *merge_ctx;
- svn_ra_serf__simple_request_context_t *delete_ctx;
svn_ra_serf__handler_t *handler;
svn_boolean_t *merge_done;
const char *merge_target =
@@ -2232,23 +2170,18 @@ close_edit(void *edit_baton,
if (ctx->activity_url)
{
handler = apr_pcalloc(pool, sizeof(*handler));
+ handler->handler_pool = pool;
handler->method = "DELETE";
handler->path = ctx->activity_url;
handler->conn = ctx->conn;
handler->session = ctx->session;
- delete_ctx = apr_pcalloc(pool, sizeof(*delete_ctx));
- delete_ctx->pool = pool;
-
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = delete_ctx;
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
- svn_ra_serf__request_create(handler);
+ SVN_ERR(svn_ra_serf__context_run_one(handler, pool));
- SVN_ERR(svn_ra_serf__context_run_wait(&delete_ctx->done, ctx->session,
- pool));
-
- SVN_ERR_ASSERT(delete_ctx->status == 204);
+ SVN_ERR_ASSERT(handler->sline.code == 204);
}
return SVN_NO_ERROR;
@@ -2260,7 +2193,6 @@ abort_edit(void *edit_baton,
{
commit_context_t *ctx = edit_baton;
svn_ra_serf__handler_t *handler;
- svn_ra_serf__simple_request_context_t *delete_ctx;
/* If an activity or transaction wasn't even created, don't bother
trying to delete it. */
@@ -2273,32 +2205,27 @@ abort_edit(void *edit_baton,
/* DELETE our aborted activity */
handler = apr_pcalloc(pool, sizeof(*handler));
+ handler->handler_pool = pool;
handler->method = "DELETE";
handler->conn = ctx->session->conns[0];
handler->session = ctx->session;
- delete_ctx = apr_pcalloc(pool, sizeof(*delete_ctx));
- delete_ctx->pool = pool;
-
- handler->response_handler = svn_ra_serf__handle_status_only;
- handler->response_baton = delete_ctx;
+ handler->response_handler = svn_ra_serf__expect_empty_body;
+ handler->response_baton = handler;
if (USING_HTTPV2_COMMIT_SUPPORT(ctx)) /* HTTP v2 */
handler->path = ctx->txn_url;
else
handler->path = ctx->activity_url;
- svn_ra_serf__request_create(handler);
-
- SVN_ERR(svn_ra_serf__context_run_wait(&delete_ctx->done, ctx->session,
- pool));
+ SVN_ERR(svn_ra_serf__context_run_one(handler, pool));
/* 204 if deleted,
403 if DELETE was forbidden (indicates MKACTIVITY was forbidden too),
404 if the activity wasn't found. */
- if (delete_ctx->status != 204 &&
- delete_ctx->status != 403 &&
- delete_ctx->status != 404
+ if (handler->sline.code != 204
+ && handler->sline.code != 403
+ && handler->sline.code != 404
)
{
SVN_ERR_MALFUNCTION();
@@ -2392,8 +2319,8 @@ svn_ra_serf__change_rev_prop(svn_ra_sess
svn_ra_serf__session_t *session = ra_session->priv;
proppatch_context_t *proppatch_ctx;
commit_context_t *commit;
- const char *vcc_url, *proppatch_target, *ns;
- apr_hash_t *props;
+ const char *proppatch_target;
+ const char *ns;
svn_error_t *err;
if (old_value_p)
@@ -2420,21 +2347,15 @@ svn_ra_serf__change_rev_prop(svn_ra_sess
}
else
{
- svn_ra_serf__propfind_context_t *propfind_ctx;
+ const char *vcc_url;
SVN_ERR(svn_ra_serf__discover_vcc(&vcc_url, commit->session,
commit->conn, pool));
- props = apr_hash_make(pool);
-
- /* ### switch to svn_ra_serf__retrieve_props */
- SVN_ERR(svn_ra_serf__deliver_props(&propfind_ctx, props, commit->session,
- commit->conn, vcc_url, rev, "0",
- checked_in_props, NULL, pool));
- SVN_ERR(svn_ra_serf__wait_for_props(propfind_ctx, commit->session, pool));
-
- proppatch_target = svn_ra_serf__get_ver_prop(props, vcc_url, rev,
- "DAV:", "href");
+ SVN_ERR(svn_ra_serf__fetch_dav_prop(&proppatch_target,
+ commit->conn, vcc_url, rev,
+ "href",
+ pool, pool));
}
if (strncmp(name, SVN_PROP_PREFIX, sizeof(SVN_PROP_PREFIX) - 1) == 0)
@@ -2450,7 +2371,6 @@ svn_ra_serf__change_rev_prop(svn_ra_sess
/* PROPPATCH our log message and pass it along. */
proppatch_ctx = apr_pcalloc(pool, sizeof(*proppatch_ctx));
proppatch_ctx->pool = pool;
- proppatch_ctx->progress.pool = pool;
proppatch_ctx->commit = commit;
proppatch_ctx->path = proppatch_target;
proppatch_ctx->changed_props = apr_hash_make(proppatch_ctx->pool);
Modified: subversion/branches/javahl-ra/subversion/libsvn_ra_serf/get_deleted_rev.c
URL: http://svn.apache.org/viewvc/subversion/branches/javahl-ra/subversion/libsvn_ra_serf/get_deleted_rev.c?rev=1343447&r1=1343446&r2=1343447&view=diff
==============================================================================
--- subversion/branches/javahl-ra/subversion/libsvn_ra_serf/get_deleted_rev.c (original)
+++ subversion/branches/javahl-ra/subversion/libsvn_ra_serf/get_deleted_rev.c Tue May 29 01:39:41 2012
@@ -35,14 +35,13 @@
/*
* This enum represents the current state of our XML parsing for a REPORT.
*/
-typedef enum drev_state_e {
- NONE = 0,
+enum drev_state_e {
+ INITIAL = 0,
+ REPORT,
VERSION_NAME
-} drev_state_e;
+};
typedef struct drev_context_t {
- apr_pool_t *pool;
-
const char *path;
svn_revnum_t peg_revision;
svn_revnum_t end_revision;
@@ -51,91 +50,41 @@ typedef struct drev_context_t {
the range PEG_REVISION-END-END_REVISION? */
svn_revnum_t *revision_deleted;
- /* are we done? */
- svn_boolean_t done;
-
} drev_context_t;
-
-static void
-push_state(svn_ra_serf__xml_parser_t *parser,
- drev_context_t *drev_ctx,
- drev_state_e state)
-{
- svn_ra_serf__xml_push_state(parser, state);
-
- if (state == VERSION_NAME)
- parser->state->private = NULL;
-}
-
-static svn_error_t *
-start_getdrev(svn_ra_serf__xml_parser_t *parser,
- svn_ra_serf__dav_props_t name,
- const char **attrs,
- apr_pool_t *scratch_pool)
-{
- drev_context_t *drev_ctx = parser->user_data;
- drev_state_e state;
-
- state = parser->state->current_state;
+#define D_ "DAV:"
+#define S_ SVN_XML_NAMESPACE
+static const svn_ra_serf__xml_transition_t getdrev_ttable[] = {
+ { INITIAL, S_, "get-deleted-rev-report", REPORT,
+ FALSE, { NULL }, FALSE, FALSE },
- if (state == NONE &&
- strcmp(name.name, SVN_DAV__VERSION_NAME) == 0)
- {
- push_state(parser, drev_ctx, VERSION_NAME);
- }
+ { REPORT, D_, SVN_DAV__VERSION_NAME, VERSION_NAME,
+ TRUE, { NULL }, FALSE, TRUE },
- return SVN_NO_ERROR;
-}
-
-static svn_error_t *
-end_getdrev(svn_ra_serf__xml_parser_t *parser,
- svn_ra_serf__dav_props_t name,
- apr_pool_t *scratch_pool)
-{
- drev_context_t *drev_ctx = parser->user_data;
- drev_state_e state;
- svn_string_t *info;
-
- state = parser->state->current_state;
- info = parser->state->private;
-
- if (state == VERSION_NAME &&
- strcmp(name.name, SVN_DAV__VERSION_NAME) == 0 &&
- info)
- {
- *drev_ctx->revision_deleted = SVN_STR_TO_REV(info->data);
- svn_ra_serf__xml_pop_state(parser);
- }
-
- return SVN_NO_ERROR;
-}
+ { 0 }
+};
+
+/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
-cdata_getdrev(svn_ra_serf__xml_parser_t *parser,
- const char *data,
- apr_size_t len,
- apr_pool_t *scratch_pool)
+getdrev_closed(svn_ra_serf__xml_estate_t *xes,
+ void *baton,
+ int leaving_state,
+ const svn_string_t *cdata,
+ apr_hash_t *attrs,
+ apr_pool_t *scratch_pool)
{
- drev_context_t *drev_ctx = parser->user_data;
- drev_state_e state;
+ drev_context_t *drev_ctx = baton;
- UNUSED_CTX(drev_ctx);
+ SVN_ERR_ASSERT(leaving_state == VERSION_NAME);
+ SVN_ERR_ASSERT(cdata != NULL);
- state = parser->state->current_state;
- switch (state)
- {
- case VERSION_NAME:
- parser->state->private = svn_string_ncreate(data, len,
- parser->state->pool);
- break;
- default:
- break;
- }
+ *drev_ctx->revision_deleted = SVN_STR_TO_REV(cdata->data);
return SVN_NO_ERROR;
}
+
/* Implements svn_ra_serf__request_body_delegate_t */
static svn_error_t *
create_getdrev_body(serf_bucket_t **body_bkt,
@@ -186,54 +135,43 @@ svn_ra_serf__get_deleted_rev(svn_ra_sess
drev_context_t *drev_ctx;
svn_ra_serf__session_t *ras = session->priv;
svn_ra_serf__handler_t *handler;
- svn_ra_serf__xml_parser_t *parser_ctx;
- const char *relative_url, *basecoll_url, *req_url;
- int status_code = 0;
+ svn_ra_serf__xml_context_t *xmlctx;
+ const char *req_url;
svn_error_t *err;
drev_ctx = apr_pcalloc(pool, sizeof(*drev_ctx));
drev_ctx->path = path;
drev_ctx->peg_revision = peg_revision;
drev_ctx->end_revision = end_revision;
- drev_ctx->pool = pool;
drev_ctx->revision_deleted = revision_deleted;
- drev_ctx->done = FALSE;
- SVN_ERR(svn_ra_serf__get_baseline_info(&basecoll_url, &relative_url,
- ras, NULL, NULL, peg_revision, NULL,
- pool));
-
- req_url = svn_path_url_add_component2(basecoll_url, relative_url, pool);
-
- parser_ctx = apr_pcalloc(pool, sizeof(*parser_ctx));
- parser_ctx->pool = pool;
- parser_ctx->user_data = drev_ctx;
- parser_ctx->start = start_getdrev;
- parser_ctx->end = end_getdrev;
- parser_ctx->cdata = cdata_getdrev;
- parser_ctx->done = &drev_ctx->done;
- parser_ctx->status_code = &status_code;
+ SVN_ERR(svn_ra_serf__get_stable_url(&req_url, NULL /* latest_revnum */,
+ ras, NULL /* conn */,
+ NULL /* url */, peg_revision,
+ pool, pool));
+
+ xmlctx = svn_ra_serf__xml_context_create(getdrev_ttable,
+ NULL, getdrev_closed, drev_ctx,
+ pool);
+ handler = svn_ra_serf__create_expat_handler(xmlctx, pool);
- handler = apr_pcalloc(pool, sizeof(*handler));
handler->method = "REPORT";
handler->path = req_url;
handler->body_type = "text/xml";
- handler->response_handler = svn_ra_serf__handle_xml_parser;
handler->body_delegate = create_getdrev_body;
handler->body_delegate_baton = drev_ctx;
handler->conn = ras->conns[0];
handler->session = ras;
- handler->response_baton = parser_ctx;
- svn_ra_serf__request_create(handler);
-
- err = svn_ra_serf__context_run_wait(&drev_ctx->done, ras, pool);
+ err = svn_ra_serf__context_run_one(handler, pool);
/* Map status 501: Method Not Implemented to our not implemented error.
1.5.x servers and older don't support this report. */
- if (status_code == 501)
+ if (handler->sline.code == 501)
return svn_error_createf(SVN_ERR_RA_NOT_IMPLEMENTED, err,
- _("'%s' REPORT not implemented"), "get-deleted-rev");
+ _("'%s' REPORT not implemented"),
+ "get-deleted-rev");
SVN_ERR(err);
+
return SVN_NO_ERROR;
}