/* TODO: to fetch the uuid from the repository, we need:
1. a path that exists in HEAD
2. a path that's readable
get_uuid handles the case where a path doesn't exist in HEAD and also the
case where the root of the repository is not readable.
However, it does not handle the case where we're fetching path not existing
in HEAD of a repository with unreadable root directory.
Implements svn_ra__vtable_t.get_uuid().
*/
static svn_error_t *
svn_ra_serf__get_uuid(svn_ra_session_t *ra_session,
const char **uuid,
apr_pool_t *pool)
{
svn_ra_serf__session_t *session = ra_session->priv;
if (!session->uuid)
{
const char *vcc_url;
/* We should never get here if we have HTTP v2 support, because
any server with that support should be transmitting the
UUID in the initial OPTIONS response. */
SVN_ERR_ASSERT(! SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session));
/* We're not interested in vcc_url and relative_url, but this call also
stores the repository's uuid in the session. */
SVN_ERR(svn_ra_serf__discover_vcc(&vcc_url, session, pool));
if (!session->uuid)
{
return svn_error_create(SVN_ERR_RA_DAV_RESPONSE_HEADER_BADNESS, NULL,
_("The UUID property was not found on the "
"resource or any of its parents"));
}
}
*uuid = session->uuid;
return SVN_NO_ERROR;
}
/* Implementation of svn_ra_serf__rev_proplist(). */
static svn_error_t *
serf__rev_proplist(svn_ra_session_t *ra_session,
svn_revnum_t rev,
const svn_ra_serf__dav_props_t *fetch_props,
apr_hash_t **ret_props,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_ra_serf__session_t *session = ra_session->priv;
apr_hash_t *props;
const char *propfind_path;
svn_ra_serf__handler_t *handler;
if (SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session))
{
propfind_path = apr_psprintf(scratch_pool, "%s/%ld", session->rev_stub,
rev);
/* svn_ra_serf__retrieve_props() wants to added the revision as
a Label to the PROPFIND, which isn't really necessary when
querying a rev-stub URI. *Shrug* Probably okay to leave the
Label, but whatever. */
rev = SVN_INVALID_REVNUM;
}
else
{
/* Use the VCC as the propfind target path. */
SVN_ERR(svn_ra_serf__discover_vcc(&propfind_path, session,
scratch_pool));
}
props = apr_hash_make(result_pool);
SVN_ERR(svn_ra_serf__create_propfind_handler(&handler, session,
propfind_path, rev, "0",
fetch_props,
svn_ra_serf__deliver_svn_props,
props,
scratch_pool));
SVN_ERR(svn_ra_serf__context_run_one(handler, scratch_pool));
svn_ra_serf__keep_only_regular_props(props, scratch_pool);
*ret_props = props;
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_serf__get_youngest_revnum(svn_revnum_t *youngest,
svn_ra_serf__session_t *session,
apr_pool_t *scratch_pool)
{
const char *vcc_url;
if (SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session))
return svn_error_trace(svn_ra_serf__v2_get_youngest_revnum(
youngest, session, scratch_pool));
SVN_ERR(svn_ra_serf__discover_vcc(&vcc_url, session, scratch_pool));
return svn_error_trace(v1_get_youngest_revnum(youngest, NULL,
session, vcc_url,
scratch_pool, scratch_pool));
}
/* Set *BC_URL to the baseline collection url for REVISION. If REVISION
is SVN_INVALID_REVNUM, then the youngest revnum ("HEAD") is used.
*REVNUM_USED will be set to the revision used.
Uses the specified CONN, which is part of SESSION.
All allocations (results and temporary) are performed in POOL. */
static svn_error_t *
get_baseline_info(const char **bc_url,
svn_revnum_t *revnum_used,
svn_ra_serf__session_t *session,
svn_revnum_t revision,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
/* If we detected HTTP v2 support on the server, we can construct
the baseline collection URL ourselves, and fetch the latest
revision (if needed) with an OPTIONS request. */
if (SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session))
{
if (SVN_IS_VALID_REVNUM(revision))
{
*revnum_used = revision;
}
else
{
SVN_ERR(svn_ra_serf__v2_get_youngest_revnum(
revnum_used, session, scratch_pool));
}
*bc_url = apr_psprintf(result_pool, "%s/%ld",
session->rev_root_stub, *revnum_used);
}
/* Otherwise, we fall back to the old VCC_URL PROPFIND hunt. */
else
{
const char *vcc_url;
SVN_ERR(svn_ra_serf__discover_vcc(&vcc_url, session, scratch_pool));
if (SVN_IS_VALID_REVNUM(revision))
{
/* First check baseline information cache. */
SVN_ERR(svn_ra_serf__blncache_get_bc_url(bc_url,
session->blncache,
revision, result_pool));
if (!*bc_url)
{
SVN_ERR(retrieve_baseline_info(NULL, bc_url, session,
vcc_url, revision,
result_pool, scratch_pool));
SVN_ERR(svn_ra_serf__blncache_set(session->blncache, NULL,
revision, *bc_url,
scratch_pool));
}
*revnum_used = revision;
}
else
{
SVN_ERR(v1_get_youngest_revnum(revnum_used, bc_url,
session, vcc_url,
result_pool, scratch_pool));
}
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_serf__run_merge(const svn_commit_info_t **commit_info,
svn_ra_serf__session_t *session,
const char *merge_resource_url,
apr_hash_t *lock_tokens,
svn_boolean_t keep_locks,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
merge_context_t *merge_ctx;
svn_ra_serf__handler_t *handler;
svn_ra_serf__xml_context_t *xmlctx;
merge_ctx = apr_pcalloc(scratch_pool, sizeof(*merge_ctx));
merge_ctx->pool = result_pool;
merge_ctx->session = session;
merge_ctx->merge_resource_url = merge_resource_url;
merge_ctx->lock_tokens = lock_tokens;
merge_ctx->keep_locks = keep_locks;
/* We don't need the full merge response when working over HTTPv2.
* Over HTTPv1, this response is only required with a non-null
* svn_ra_push_wc_prop_func_t callback. */
merge_ctx->disable_merge_response =
SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session) ||
session->wc_callbacks->push_wc_prop == NULL;
merge_ctx->commit_info = svn_create_commit_info(result_pool);
merge_ctx->merge_url = session->session_url.path;
xmlctx = svn_ra_serf__xml_context_create(merge_ttable,
NULL, merge_closed, NULL,
merge_ctx,
scratch_pool);
handler = svn_ra_serf__create_expat_handler(session, xmlctx, NULL,
scratch_pool);
handler->method = "MERGE";
handler->path = merge_ctx->merge_url;
handler->body_delegate = create_merge_body;
handler->body_delegate_baton = merge_ctx;
handler->body_type = "text/xml";
handler->header_delegate = setup_merge_headers;
handler->header_delegate_baton = merge_ctx;
merge_ctx->handler = handler;
SVN_ERR(svn_ra_serf__context_run_one(handler, scratch_pool));
if (handler->sline.code != 200)
return svn_error_trace(svn_ra_serf__unexpected_status(handler));
*commit_info = merge_ctx->commit_info;
/* Sanity check (Reported to be triggered by CodePlex's svnbridge) */
if (! SVN_IS_VALID_REVNUM(merge_ctx->commit_info->revision))
{
return svn_error_create(SVN_ERR_RA_DAV_PROPS_NOT_FOUND, NULL,
_("The MERGE response did not include "
"a new revision"));
}
merge_ctx->commit_info->repos_root = apr_pstrdup(result_pool,
session->repos_root_str);
return SVN_NO_ERROR;
}
/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
merge_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)
{
merge_context_t *merge_ctx = baton;
if (leaving_state == RESPONSE)
{
const char *rtype;
rtype = svn_hash_gets(attrs, "resourcetype");
/* rtype can only be "baseline" or "collection" (or NULL). We can
keep this check simple. */
if (rtype && *rtype == 'b')
{
const char *rev_str;
rev_str = svn_hash_gets(attrs, "revision");
if (rev_str)
{
apr_int64_t rev;
SVN_ERR(svn_cstring_atoi64(&rev, rev_str));
merge_ctx->commit_info->revision = (svn_revnum_t)rev;
}
else
merge_ctx->commit_info->revision = SVN_INVALID_REVNUM;
merge_ctx->commit_info->date =
apr_pstrdup(merge_ctx->pool,
svn_hash_gets(attrs, "date"));
merge_ctx->commit_info->author =
apr_pstrdup(merge_ctx->pool,
svn_hash_gets(attrs, "author"));
merge_ctx->commit_info->post_commit_err =
apr_pstrdup(merge_ctx->pool,
svn_hash_gets(attrs, "post-commit-err"));
}
else
{
const char *href;
href = svn_urlpath__skip_ancestor(
merge_ctx->merge_url,
svn_hash_gets(attrs, "href"));
if (href == NULL)
return svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
_("A MERGE response for '%s' is not "
"a child of the destination ('%s')"),
href, merge_ctx->merge_url);
/* We now need to dive all the way into the WC to update the
base VCC url. */
if (!SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(merge_ctx->session)
&& merge_ctx->session->wc_callbacks->push_wc_prop)
{
const char *checked_in;
svn_string_t checked_in_str;
checked_in = svn_hash_gets(attrs, "checked-in");
checked_in_str.data = checked_in;
checked_in_str.len = strlen(checked_in);
SVN_ERR(merge_ctx->session->wc_callbacks->push_wc_prop(
merge_ctx->session->wc_callback_baton,
href,
SVN_RA_SERF__WC_CHECKED_IN_URL,
&checked_in_str,
scratch_pool));
}
}
}
else if (leaving_state == BASELINE)
{
svn_ra_serf__xml_note(xes, RESPONSE, "resourcetype", "baseline");
}
else if (leaving_state == COLLECTION)
{
svn_ra_serf__xml_note(xes, RESPONSE, "resourcetype", "collection");
}
else
{
const char *name;
const char *value = cdata->data;
if (leaving_state == HREF)
{
name = "href";
value = svn_urlpath__canonicalize(value, scratch_pool);
}
else if (leaving_state == CHECKED_IN)
{
name = "checked-in";
value = svn_urlpath__canonicalize(value, scratch_pool);
}
else if (leaving_state == VERSION_NAME)
name = "revision";
else if (leaving_state == DATE)
name = "date";
else if (leaving_state == AUTHOR)
name = "author";
else if (leaving_state == POST_COMMIT_ERR)
name = "post-commit-err";
else
SVN_ERR_MALFUNCTION();
svn_ra_serf__xml_note(xes, RESPONSE, name, value);
}
return SVN_NO_ERROR;
}
