You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by br...@apache.org on 2012/08/16 12:18:03 UTC
svn commit: r1373783 [20/50] - in /subversion/branches/compressed-pristines:
./ build/ build/ac-macros/ build/generator/ build/generator/templates/
build/win32/ contrib/client-side/emacs/ contrib/client-side/svn-push/
contrib/client-side/svnmerge/ cont...
Modified: subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/ra_serf.h
URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/ra_serf.h?rev=1373783&r1=1373782&r2=1373783&view=diff
==============================================================================
--- subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/ra_serf.h (original)
+++ subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/ra_serf.h Thu Aug 16 10:17:48 2012
@@ -26,7 +26,7 @@
#include <serf.h>
-#include <expat.h>
+#include <expat.h> /* for XML_Parser */
#include <apr_uri.h>
#include "svn_types.h"
@@ -71,22 +71,11 @@ typedef struct svn_ra_serf__connection_t
/* Our connection to a server. */
serf_connection_t *conn;
- /* The server is not Apache/mod_dav_svn (directly) and only supports
- HTTP/1.0. Thus, we cannot send chunked requests. */
- svn_boolean_t http10;
-
/* Bucket allocator for this connection. */
serf_bucket_alloc_t *bkt_alloc;
- /* Host name */
- const char *hostname;
-
- /* Are we using ssl */
- svn_boolean_t using_ssl;
- int server_cert_failures; /* Collected cert failures in chain */
-
- /* Should we ask for compressed responses? */
- svn_boolean_t using_compression;
+ /* Collected cert failures in chain. */
+ int server_cert_failures;
/* What was the last HTTP status code we got on this connection? */
int last_status_code;
@@ -98,11 +87,11 @@ typedef struct svn_ra_serf__connection_t
svn_ra_serf__session_t *session;
- /* user agent string */
- const char *useragent;
-
} svn_ra_serf__connection_t;
+/** Max. number of connctions we'll open to the server. */
+#define MAX_NR_OF_CONNS 4
+
/*
* The master serf RA session.
*
@@ -121,8 +110,11 @@ struct svn_ra_serf__session_t {
/* Should we ask for compressed responses? */
svn_boolean_t using_compression;
+ /* The user agent string */
+ const char *useragent;
+
/* The current connection */
- svn_ra_serf__connection_t **conns;
+ svn_ra_serf__connection_t *conns[MAX_NR_OF_CONNS];
int num_conns;
int cur_conn;
@@ -134,6 +126,10 @@ struct svn_ra_serf__session_t {
apr_uri_t repos_root;
const char *repos_root_str;
+ /* The server is not Apache/mod_dav_svn (directly) and only supports
+ HTTP/1.0. Thus, we cannot send chunked requests. */
+ svn_boolean_t http10;
+
/* Our Version-Controlled-Configuration; may be NULL until we know it. */
const char *vcc_url;
@@ -186,7 +182,7 @@ struct svn_ra_serf__session_t {
const char *uuid;
/* Connection timeout value */
- long timeout;
+ apr_short_interval_time_t timeout;
/* HTTPv1 flags */
svn_tristate_t supports_deadprop_count;
@@ -280,40 +276,21 @@ static const svn_ra_serf__dav_props_t al
{ NULL }
};
-static const svn_ra_serf__dav_props_t vcc_props[] =
-{
- { "DAV:", "version-controlled-configuration" },
- { NULL }
-};
-
static const svn_ra_serf__dav_props_t check_path_props[] =
{
{ "DAV:", "resourcetype" },
{ NULL }
};
-static const svn_ra_serf__dav_props_t uuid_props[] =
-{
- { SVN_DAV_PROP_NS_DAV, "repository-uuid" },
- { NULL }
-};
-
-static const svn_ra_serf__dav_props_t repos_root_props[] =
-{
- { SVN_DAV_PROP_NS_DAV, "baseline-relative-path" },
- { NULL }
-};
-
-static const svn_ra_serf__dav_props_t href_props[] =
+static const svn_ra_serf__dav_props_t type_and_checksum_props[] =
{
- { "DAV:", "href" },
+ { "DAV:", "resourcetype" },
+ { SVN_DAV_PROP_NS_DAV, "sha1-checksum" },
{ NULL }
};
/* WC props compatibility with ra_neon. */
-#define SVN_RA_SERF__WC_NAMESPACE SVN_PROP_WC_PREFIX "ra_dav:"
-#define SVN_RA_SERF__WC_ACTIVITY_URL SVN_RA_SERF__WC_NAMESPACE "activity-url"
-#define SVN_RA_SERF__WC_CHECKED_IN_URL SVN_RA_SERF__WC_NAMESPACE "version-url"
+#define SVN_RA_SERF__WC_CHECKED_IN_URL SVN_PROP_WC_PREFIX "ra_dav:version-url"
/** Serf utility functions **/
@@ -364,7 +341,7 @@ typedef svn_error_t *
(*svn_ra_serf__response_handler_t)(serf_request_t *request,
serf_bucket_t *response,
void *handler_baton,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
/* Callback for when a request body is needed. */
/* ### should pass a scratch_pool */
@@ -388,6 +365,9 @@ typedef svn_error_t *
int status_code,
void *baton);
+/* ### we should reorder the types in this file. */
+typedef struct svn_ra_serf__server_error_t svn_ra_serf__server_error_t;
+
/*
* Structure that can be passed to our default handler to guide the
* execution of the request through its lifecycle.
@@ -402,10 +382,24 @@ typedef struct svn_ra_serf__handler_t {
/* The content-type of the request body. */
const char *body_type;
+ /* Has the request/response been completed? */
+ svn_boolean_t done;
+
+ /* If we captured an error from the server, then this will be non-NULL.
+ It will be allocated from HANDLER_POOL. */
+ svn_ra_serf__server_error_t *server_error;
+
/* The handler and baton pair for our handler. */
svn_ra_serf__response_handler_t response_handler;
void *response_baton;
+ /* When REPONSE_HANDLER is invoked, the following fields will be set
+ based on the response header. HANDLER_POOL must be non-NULL for these
+ values to be filled in. SLINE.REASON and LOCATION will be allocated
+ within HANDLER_POOL. */
+ serf_status_line sline; /* The parsed Status-Line */
+ const char *location; /* The Location: header, if any */
+
/* The handler and baton pair to be executed when a non-recoverable error
* is detected. If it is NULL in the presence of an error, an abort() may
* be triggered.
@@ -437,8 +431,34 @@ typedef struct svn_ra_serf__handler_t {
/* The connection and session to be used for this request. */
svn_ra_serf__connection_t *conn;
svn_ra_serf__session_t *session;
+
+ /* Internal flag to indicate we've parsed the headers. */
+ svn_boolean_t reading_body;
+
+ /* When this flag will be set, the core handler will discard any unread
+ portion of the response body. The registered response handler will
+ no longer be called. */
+ svn_boolean_t discard_body;
+
+ /* Pool for allocating SLINE.REASON and LOCATION. If this pool is NULL,
+ then the requestor does not care about SLINE and LOCATION. */
+ apr_pool_t *handler_pool;
+
} svn_ra_serf__handler_t;
+
+/* Run one request and process the response.
+
+ Similar to context_run_wait(), but this creates the request for HANDLER
+ and then waits for it to complete.
+
+ WARNING: context_run_wait() does NOT create a request, whereas this
+ function DOES. Avoid a double-create. */
+svn_error_t *
+svn_ra_serf__context_run_one(svn_ra_serf__handler_t *handler,
+ apr_pool_t *scratch_pool);
+
+
/*
* Helper function to queue a request in the @a handler's connection.
*/
@@ -532,16 +552,6 @@ struct svn_ra_serf__xml_parser_t {
/* Our previously used states (will be reused). */
svn_ra_serf__xml_state_t *free_state;
- /* If non-NULL, the status code of the response will be stored here.
- *
- * If this is NULL and an error is received, an abort will be triggered.
- */
- int *status_code;
-
- /* If non-NULL, this is the value of the response's Location header.
- */
- const char *location;
-
/* If non-NULL, this value will be set to TRUE when the response is
* completed.
*/
@@ -601,19 +611,217 @@ struct svn_ra_serf__xml_parser_t {
apr_off_t read_size; /* Number of bytes read from response */
};
+
+/* v2 of the XML parsing functions */
+
+/* The XML parsing context. */
+typedef struct svn_ra_serf__xml_context_t svn_ra_serf__xml_context_t;
+
+
+/* An opaque structure for the XML parse element/state. */
+typedef struct svn_ra_serf__xml_estate_t svn_ra_serf__xml_estate_t;
+
+/* Called just after the parser moves into ENTERED_STATE. The tag causing
+ the transition is passed in TAG.
+
+ This callback is applied to a parsing context by using the
+ svn_ra_serf__xml_context_customize() function.
+
+ NOTE: this callback, when set, will be invoked on *every* transition.
+ The callback must examine ENTERED_STATE to determine if any action
+ must be taken. The original state is not provided, but must be derived
+ from ENTERED_STATE and/or the TAG causing the transition (if needed). */
+typedef svn_error_t *
+(*svn_ra_serf__xml_opened_t)(svn_ra_serf__xml_estate_t *xes,
+ void *baton,
+ int entered_state,
+ const svn_ra_serf__dav_props_t *tag,
+ apr_pool_t *scratch_pool);
+
+
+/* Called just before the parser leaves LEAVING_STATE.
+
+ If cdata collection was enabled for this state, then CDATA will be
+ non-NULL and contain the collected cdata.
+
+ If attribute collection was enabled for this state, then ATTRS will
+ contain the attributes collected for this element only, along with
+ any values stored via svn_ra_serf__xml_note().
+
+ Use svn_ra_serf__xml_gather_since() to gather up data from outer states.
+
+ ATTRS is char* -> char*.
+
+ Temporary allocations may be made in SCRATCH_POOL. */
+typedef svn_error_t *
+(*svn_ra_serf__xml_closed_t)(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);
+
+
+/* Called for all states that are not using the builtin cdata collection.
+ This callback is (only) appropriate for unbounded-size cdata content.
+
+ CURRENT_STATE may be used to decide what to do with the data.
+
+ Temporary allocations may be made in SCRATCH_POOL. */
+typedef svn_error_t *
+(*svn_ra_serf__xml_cdata_t)(svn_ra_serf__xml_estate_t *xes,
+ void *baton,
+ int current_state,
+ const char *data,
+ apr_size_t len,
+ apr_pool_t *scratch_pool);
+
+
+/* State transition table.
+
+ When the XML Context is constructed, it is in state 0. User states are
+ positive integers.
+
+ In a list of transitions, use { 0 } to indicate the end. Specifically,
+ the code looks for NS == NULL.
+
+ ### more docco
+*/
+typedef struct svn_ra_serf__xml_transition_t {
+ /* This transition applies when in this state */
+ int from_state;
+
+ /* And when this tag is observed */
+ const char *ns;
+ const char *name;
+
+ /* Moving to this state */
+ int to_state;
+
+ /* Should the cdata of NAME be collected? Note that CUSTOM_CLOSE should
+ be TRUE in order to capture this cdata. */
+ svn_boolean_t collect_cdata;
+
+ /* Which attributes of NAME should be collected? Terminate with NULL.
+ Maximum of 10 attributes may be collected. Note that attribute
+ namespaces are ignored at this time.
+
+ Attribute names beginning with "?" are optional. Other names must
+ exist on the element, or SVN_ERR_XML_ATTRIB_NOT_FOUND will be raised. */
+ const char *collect_attrs[11];
+
+ /* When NAME is closed, should the callback be invoked? */
+ svn_boolean_t custom_close;
+
+} svn_ra_serf__xml_transition_t;
+
+
+/* Construct an XML parsing context, based on the TTABLE transition table.
+ As content is parsed, the CLOSED_CB callback will be invoked according
+ to the definition in the table.
+
+ If OPENED_CB is not NULL, then it will be invoked for *every* tag-open
+ event. The callback will need to use the ENTERED_STATE and TAG parameters
+ to decide what it would like to do.
+
+ If CDATA_CB is not NULL, then it will be called for all cdata that is
+ not be automatically collected (based on the transition table record's
+ COLLECT_CDATA flag). It will be called in every state, so the callback
+ must examine the CURRENT_STATE parameter to decide what to do.
+
+ The same BATON value will be passed to all three callbacks.
+
+ The context will be created within RESULT_POOL. */
+svn_ra_serf__xml_context_t *
+svn_ra_serf__xml_context_create(
+ const svn_ra_serf__xml_transition_t *ttable,
+ svn_ra_serf__xml_opened_t opened_cb,
+ svn_ra_serf__xml_closed_t closed_cb,
+ svn_ra_serf__xml_cdata_t cdata_cb,
+ void *baton,
+ apr_pool_t *result_pool);
+
+/* Destroy all subpools for this structure. */
+void
+svn_ra_serf__xml_context_destroy(
+ svn_ra_serf__xml_context_t *xmlctx);
+
+/* Construct a handler with the response function/baton set up to parse
+ a response body using the given XML context. The handler and its
+ internal structures are allocated in RESULT_POOL.
+
+ This also initializes HANDLER_POOL to the given RESULT_POOL. */
+svn_ra_serf__handler_t *
+svn_ra_serf__create_expat_handler(svn_ra_serf__xml_context_t *xmlctx,
+ apr_pool_t *result_pool);
+
+
+/* Allocated within XES->STATE_POOL. Changes are not allowd (callers
+ should make a deep copy if they need to make changes).
+
+ The resulting hash maps char* names to char* values. */
+apr_hash_t *
+svn_ra_serf__xml_gather_since(svn_ra_serf__xml_estate_t *xes,
+ int stop_state);
+
+
+/* Attach the NAME/VALUE pair onto this/parent state identified by STATE.
+ The name and value will be copied into the target state's pool.
+
+ These values will be available to the CLOSED_CB for the target state,
+ or part of the gathered state via xml_gather_since().
+
+ Typically, this function is used by a child state's close callback,
+ or within an opening callback to store additional data.
+
+ Note: if the state is not found, then a programmer error has occurred,
+ so the function will invoke SVN_ERR_MALFUNCTION(). */
+void
+svn_ra_serf__xml_note(svn_ra_serf__xml_estate_t *xes,
+ int state,
+ const char *name,
+ const char *value);
+
+
+/* Returns XES->STATE_POOL for allocating structures that should live
+ as long as the state identified by XES.
+
+ Note: a state pool is created upon demand, so only use this function
+ when memory is required for a given state. */
+apr_pool_t *
+svn_ra_serf__xml_state_pool(svn_ra_serf__xml_estate_t *xes);
+
+
+/* Any XML parser may be used. When an opening tag is seen, call this
+ function to feed the information into XMLCTX. */
+svn_error_t *
+svn_ra_serf__xml_cb_start(svn_ra_serf__xml_context_t *xmlctx,
+ const char *raw_name,
+ const char *const *attrs);
+
+
+/* When a close tag is seen, call this function to feed the information
+ into XMLCTX. */
+svn_error_t *
+svn_ra_serf__xml_cb_end(svn_ra_serf__xml_context_t *xmlctx,
+ const char *raw_name);
+
+
+/* When cdata is parsed by the wrapping XML parser, call this function to
+ feed the cdata into the XMLCTX. */
+svn_error_t *
+svn_ra_serf__xml_cb_cdata(svn_ra_serf__xml_context_t *xmlctx,
+ const char *data,
+ apr_size_t len);
+
+
/*
* Parses a server-side error message into a local Subversion error.
*/
-typedef struct svn_ra_serf__server_error_t {
+struct svn_ra_serf__server_error_t {
/* Our local representation of the error. */
svn_error_t *error;
- /* Have we checked to see if there's an XML error in this response? */
- svn_boolean_t init;
-
- /* Was there an XML error response? */
- svn_boolean_t has_xml_response;
-
/* Are we done with the response? */
svn_boolean_t done;
@@ -631,41 +839,8 @@ typedef struct svn_ra_serf__server_error
/* XML parser and namespace used to parse the remote response */
svn_ra_serf__xml_parser_t parser;
-} svn_ra_serf__server_error_t;
-
-/* A simple request context that can be passed to handle_status_only. */
-typedef struct svn_ra_serf__simple_request_context_t {
- apr_pool_t *pool;
-
- /* The HTTP status code of the response */
- int status;
-
- /* The HTTP status line of the response */
- const char *reason;
-
- /* The Location header value of the response, or NULL if there
- wasn't one. */
- const char *location;
-
- /* This value is set to TRUE when the response is completed. */
- svn_boolean_t done;
+};
- /* If an error occurred, this value will be initialized. */
- svn_ra_serf__server_error_t server_error;
-} svn_ra_serf__simple_request_context_t;
-
-/*
- * Serf handler for @a request / @a response pair that takes in a
- * @a baton (@see svn_ra_serf__simple_request_context_t).
- * Implements svn_ra_serf__response_handler_t.
- *
- * Temporary allocations are made in @a pool.
- */
-svn_error_t *
-svn_ra_serf__handle_status_only(serf_request_t *request,
- serf_bucket_t *response,
- void *baton,
- apr_pool_t *pool);
/*
* Handler that discards the entire @a response body associated with a
@@ -682,32 +857,45 @@ svn_ra_serf__handle_discard_body(serf_re
void *baton,
apr_pool_t *pool);
-/*
- * Handler that retrieves the embedded XML error response from the
- * the @a response body associated with a @a request.
- * Implements svn_ra_serf__response_handler_t.
- *
- * All temporary allocations will be made in a @a pool.
- */
-svn_error_t *
-svn_ra_serf__handle_server_error(serf_request_t *request,
- serf_bucket_t *response,
- apr_pool_t *pool);
/*
* Handler that retrieves the embedded XML multistatus response from the
- * the @a RESPONSE body associated with a @a REQUEST. *DONE is set to TRUE.
+ * the @a RESPONSE body associated with a @a REQUEST.
+ *
* Implements svn_ra_serf__response_handler_t.
*
- * The @a BATON should be of type svn_ra_serf__simple_request_context_t.
+ * The @a BATON should be of type svn_ra_serf__handler_t. When the request
+ * is complete, the handler's DONE flag will be set to TRUE.
*
- * All temporary allocations will be made in a @a pool.
+ * All temporary allocations will be made in a @a scratch_pool.
*/
svn_error_t *
svn_ra_serf__handle_multistatus_only(serf_request_t *request,
serf_bucket_t *response,
void *baton,
- apr_pool_t *pool);
+ apr_pool_t *scratch_pool);
+
+
+/* Handler that expects an empty body.
+
+ If a body IS present, and it is text/xml, then it will be parsed for
+ a server-side error.
+
+ BATON should be the svn_ra_serf__handler_t running REQUEST.
+
+ Status line information will be in HANDLER->SLINE.
+
+ Any parsed errors will be left in HANDLER->SERVER_ERROR. That member
+ may be NULL if no body was present, or a problem occurred trying to
+ parse the body.
+
+ All temporary allocations will be made in SCRATCH_POOL. */
+svn_error_t *
+svn_ra_serf__expect_empty_body(serf_request_t *request,
+ serf_bucket_t *response,
+ void *baton,
+ apr_pool_t *scratch_pool);
+
/*
* This function will feed the RESPONSE body into XMLP. When parsing is
@@ -736,12 +924,6 @@ svn_ra_serf__response_discard_handler(se
void *baton,
apr_pool_t *pool);
-/* Return the value of the RESPONSE's Location header if any, or NULL
- * otherwise. All allocations will be made in POOL.
- */
-const char *
-svn_ra_serf__response_get_location(serf_bucket_t *response,
- apr_pool_t *pool);
/** XML helper functions. **/
@@ -827,12 +1009,12 @@ svn_ra_serf__add_cdata_len_buckets(serf_
* Look up the @a attrs array for namespace definitions and add each one
* to the @a ns_list of namespaces.
*
- * New namespaces will be allocated in @a pool.
+ * New namespaces will be allocated in RESULT_POOL.
*/
void
svn_ra_serf__define_ns(svn_ra_serf__ns_t **ns_list,
- const char **attrs,
- apr_pool_t *pool);
+ const char *const *attrs,
+ apr_pool_t *result_pool);
/*
* Look up @a name in the @a ns_list list for previously declared namespace
@@ -843,27 +1025,12 @@ svn_ra_serf__define_ns(svn_ra_serf__ns_t
*/
void
svn_ra_serf__expand_ns(svn_ra_serf__dav_props_t *returned_prop_name,
- svn_ra_serf__ns_t *ns_list,
+ const svn_ra_serf__ns_t *ns_list,
const char *name);
/** PROPFIND-related functions **/
-/* Opaque structure representing PROPFINDs. */
-typedef struct svn_ra_serf__propfind_context_t svn_ra_serf__propfind_context_t;
-
-/*
- * Returns a flag representing whether the PROPFIND @a ctx is completed.
- */
-svn_boolean_t
-svn_ra_serf__propfind_is_done(svn_ra_serf__propfind_context_t *ctx);
-
-/*
- * Returns the response status code of the PROPFIND @a ctx.
- */
-int
-svn_ra_serf__propfind_status_code(svn_ra_serf__propfind_context_t *ctx);
-
/*
* This function will deliver a PROP_CTX PROPFIND request in the SESS
* serf context for the properties listed in LOOKUP_PROPS at URL for
@@ -873,7 +1040,7 @@ svn_ra_serf__propfind_status_code(svn_ra
* expected to call svn_ra_serf__wait_for_props().
*/
svn_error_t *
-svn_ra_serf__deliver_props(svn_ra_serf__propfind_context_t **prop_ctx,
+svn_ra_serf__deliver_props(svn_ra_serf__handler_t **propfind_handler,
apr_hash_t *prop_vals,
svn_ra_serf__session_t *sess,
svn_ra_serf__connection_t *conn,
@@ -885,13 +1052,12 @@ svn_ra_serf__deliver_props(svn_ra_serf__
apr_pool_t *pool);
/*
- * This helper function will block until the PROP_CTX indicates that is done
- * or another error is returned.
+ * This helper function will block until PROPFIND_HANDLER indicates that is
+ * done or another error is returned.
*/
svn_error_t *
-svn_ra_serf__wait_for_props(svn_ra_serf__propfind_context_t *prop_ctx,
- svn_ra_serf__session_t *sess,
- apr_pool_t *pool);
+svn_ra_serf__wait_for_props(svn_ra_serf__handler_t *handler,
+ apr_pool_t *scratch_pool);
/* This is a blocking version of deliver_props.
@@ -913,6 +1079,50 @@ svn_ra_serf__retrieve_props(apr_hash_t *
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
+
+/* Using CONN, fetch the properties specified by WHICH_PROPS using CONN
+ for URL at REVISION. The resulting properties are placed into a 2-level
+ hash in RESULTS, mapping NAMESPACE -> hash<PROPNAME, PROPVALUE>, which
+ is allocated in RESULT_POOL.
+
+ If REVISION is SVN_INVALID_REVNUM, then the properties are fetched
+ from HEAD for URL.
+
+ This function performs the request synchronously.
+
+ Temporary allocations are made in SCRATCH_POOL. */
+svn_error_t *
+svn_ra_serf__fetch_node_props(apr_hash_t **results,
+ svn_ra_serf__connection_t *conn,
+ const char *url,
+ svn_revnum_t revision,
+ const svn_ra_serf__dav_props_t *which_props,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
+
+
+/* Using CONN, fetch a DAV: property from the resource identified by URL
+ within REVISION. The PROPNAME may be one of:
+
+ "checked-in"
+ "href"
+
+ The resulting value will be allocated in RESULT_POOL, and may be NULL
+ if the property does not exist (note: "href" always exists).
+
+ This function performs the request synchronously.
+
+ Temporary allocations are made in SCRATCH_POOL. */
+svn_error_t *
+svn_ra_serf__fetch_dav_prop(const char **value,
+ svn_ra_serf__connection_t *conn,
+ const char *url,
+ svn_revnum_t revision,
+ const char *propname,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
+
+
/* Set PROPS for PATH at REV revision with a NS:NAME VAL.
*
* The POOL governs allocation.
@@ -941,6 +1151,15 @@ svn_ra_serf__walk_all_props(apr_hash_t *
void *baton,
apr_pool_t *pool);
+
+/* Like walk_all_props(), but a 2-level hash. */
+svn_error_t *
+svn_ra_serf__walk_node_props(apr_hash_t *props,
+ svn_ra_serf__walker_visitor_t walker,
+ void *baton,
+ apr_pool_t *scratch_pool);
+
+
typedef svn_error_t *
(*svn_ra_serf__path_rev_walker_t)(void *baton,
const char *path, apr_ssize_t path_len,
@@ -979,9 +1198,8 @@ svn_ra_serf__select_revprops(apr_hash_t
apr_pool_t *scratch_pool);
-/* PROPS is nested hash tables mapping REV -> PATH -> NS -> NAME -> VALUE.
- This function takes the tree of tables identified by PATH and REVISION
- (resulting in NS:NAME:VALUE hashes) and flattens them into a set of
+/* PROPS is nested hash tables mapping NS -> NAME -> VALUE.
+ This function takes the NS:NAME:VALUE hashes and flattens them into a set of
names to VALUE. The names are composed of NS:NAME, with specific
rewrite from wire names (DAV) to SVN names. This mapping is managed
by the svn_ra_serf__set_baton_props() function.
@@ -994,8 +1212,6 @@ svn_ra_serf__select_revprops(apr_hash_t
svn_error_t *
svn_ra_serf__flatten_props(apr_hash_t **flat_props,
apr_hash_t *props,
- const char *path,
- svn_revnum_t revision,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
@@ -1035,25 +1251,12 @@ svn_ra_serf__set_prop(apr_hash_t *props,
const svn_string_t *val, apr_pool_t *pool);
svn_error_t *
-svn_ra_serf__get_resource_type(svn_node_kind_t *kind,
- apr_hash_t *props,
- const char *url,
- svn_revnum_t revision);
+svn_ra_serf__get_resource_type(svn_kind_t *kind,
+ apr_hash_t *props);
/** MERGE-related functions **/
-typedef struct svn_ra_serf__merge_context_t svn_ra_serf__merge_context_t;
-
-svn_boolean_t*
-svn_ra_serf__merge_get_done_ptr(svn_ra_serf__merge_context_t *ctx);
-
-svn_commit_info_t*
-svn_ra_serf__merge_get_commit_info(svn_ra_serf__merge_context_t *ctx);
-
-int
-svn_ra_serf__merge_get_status(svn_ra_serf__merge_context_t *ctx);
-
void
svn_ra_serf__merge_lock_token_list(apr_hash_t *lock_tokens,
const char *parent,
@@ -1067,38 +1270,48 @@ svn_ra_serf__merge_lock_token_list(apr_h
client. If KEEP_LOCKS is set, instruct the server to not release
locks set on the paths included in this commit. */
svn_error_t *
-svn_ra_serf__merge_create_req(svn_ra_serf__merge_context_t **merge_ctx,
- svn_ra_serf__session_t *session,
- svn_ra_serf__connection_t *conn,
- const char *merge_resource_url,
- apr_hash_t *lock_tokens,
- svn_boolean_t keep_locks,
- apr_pool_t *pool);
+svn_ra_serf__run_merge(const svn_commit_info_t **commit_info,
+ int *response_code,
+ svn_ra_serf__session_t *session,
+ svn_ra_serf__connection_t *conn,
+ 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);
+
/** OPTIONS-related functions **/
-typedef struct svn_ra_serf__options_context_t svn_ra_serf__options_context_t;
+/* On HTTPv2 connections, run an OPTIONS request over CONN to fetch the
+ current youngest revnum, returning it in *YOUNGEST.
-/* Is this OPTIONS-request done yet? */
-svn_boolean_t*
-svn_ra_serf__get_options_done_ptr(svn_ra_serf__options_context_t *ctx);
+ (the revnum is headers of the OPTIONS response)
-const char *
-svn_ra_serf__options_get_activity_collection(svn_ra_serf__options_context_t *ctx);
+ This function performs the request synchronously.
-svn_revnum_t
-svn_ra_serf__options_get_youngest_rev(svn_ra_serf__options_context_t *ctx);
+ All temporary allocations will be made in SCRATCH_POOL. */
+svn_error_t *
+svn_ra_serf__v2_get_youngest_revnum(svn_revnum_t *youngest,
+ svn_ra_serf__connection_t *conn,
+ apr_pool_t *scratch_pool);
+
+
+/* On HTTPv1 connections, run an OPTIONS request over CONN to fetch the
+ activity collection set and return it in *ACTIVITY_URL, allocated
+ from RESULT_POOL.
+
+ (the activity-collection-set is in the body of the OPTIONS response)
+
+ This function performs the request synchronously.
+
+ All temporary allocations will be made in SCRATCH_POOL. */
+svn_error_t *
+svn_ra_serf__v1_get_activity_collection(const char **activity_url,
+ svn_ra_serf__connection_t *conn,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
-/* Create an OPTIONS request. When run, ask for an
- activity-collection-set in the request body (retrievable via
- accessor above) and also parse the server's capability headers into
- the SESSION->capabilites hash. */
-svn_error_t *
-svn_ra_serf__create_options_req(svn_ra_serf__options_context_t **opt_ctx,
- svn_ra_serf__session_t *session,
- svn_ra_serf__connection_t *conn,
- const char *path,
- apr_pool_t *pool);
/* Set @a VCC_URL to the default VCC for our repository based on @a
* ORIG_PATH for the session @a SESSION, ensuring that the VCC URL and
@@ -1138,34 +1351,63 @@ svn_ra_serf__get_relative_path(const cha
svn_ra_serf__connection_t *conn,
apr_pool_t *pool);
-/* Set *BC_URL to the baseline collection url, and set *BC_RELATIVE to
- * the path relative to that url for URL in REVISION using SESSION.
- * BC_RELATIVE will be URI decoded.
- *
- * REVISION may be SVN_INVALID_REVNUM (to mean "the current HEAD
- * revision"). If URL is NULL, use SESSION's session url.
- *
- * If LATEST_REVNUM is not NULL, set it to the baseline revision. If
- * REVISION was set to SVN_INVALID_REVNUM, this will return the current
- * HEAD revision.
- *
- * If non-NULL, use CONN for communications with the server;
- * otherwise, use the default connection.
- *
- * Use POOL for all allocations.
- */
+
+/* Using the default connection in SESSION (conns[0]), get the youngest
+ revnum from the server, returning it in *YOUNGEST.
+
+ This function operates synchronously.
+
+ All temporary allocations are performed in SCRATCH_POOL. */
svn_error_t *
-svn_ra_serf__get_baseline_info(const char **bc_url,
- const char **bc_relative,
- svn_ra_serf__session_t *session,
- svn_ra_serf__connection_t *conn,
- const char *url,
- svn_revnum_t revision,
- svn_revnum_t *latest_revnum,
- apr_pool_t *pool);
+svn_ra_serf__get_youngest_revnum(svn_revnum_t *youngest,
+ svn_ra_serf__session_t *session,
+ apr_pool_t *scratch_pool);
+
+
+/* Generate a revision-stable URL.
+
+ The RA APIs all refer to user/public URLs that float along with the
+ youngest revision. In many cases, we do NOT want to work with that URL
+ since it can change from one moment to the next. Especially if we
+ attempt to operation against multiple floating URLs -- we could end up
+ referring to two separate revisions.
+
+ The DAV RA provider(s) solve this by generating a URL that is specific
+ to a revision by using a URL into a "baseline collection".
+
+ For a specified SESSION, with an optional CONN (if NULL, then the
+ session's default connection will be used; specifically SESSION->conns[0]),
+ generate a revision-stable URL for URL at REVISION. If REVISION is
+ SVN_INVALID_REVNUM, then the stable URL will refer to the youngest
+ revision at the time this function was called.
+
+ If URL is NULL, then the session root will be used.
+
+ The stable URL will be placed into *STABLE_URL, allocated from RESULT_POOL.
+
+ If LATEST_REVNUM is not NULL, then the revision used will be placed into
+ *LATEST_REVNUM. That will be equal to youngest, or the given REVISION.
+
+ This function operates synchronously, if any communication to the server
+ is required. Communication is needed if REVISION is SVN_INVALID_REVNUM
+ (to get the current youngest revnum), or if the specified REVISION is not
+ (yet) in our cache of baseline collections.
+
+ All temporary allocations are performed in SCRATCH_POOL. */
+svn_error_t *
+svn_ra_serf__get_stable_url(const char **stable_url,
+ svn_revnum_t *latest_revnum,
+ svn_ra_serf__session_t *session,
+ svn_ra_serf__connection_t *conn,
+ const char *url,
+ svn_revnum_t revision,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool);
+
/** RA functions **/
+/* Implements svn_ra__vtable_t.get_log(). */
svn_error_t *
svn_ra_serf__get_log(svn_ra_session_t *session,
const apr_array_header_t *paths,
@@ -1180,6 +1422,7 @@ svn_ra_serf__get_log(svn_ra_session_t *s
void *receiver_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_locations(). */
svn_error_t *
svn_ra_serf__get_locations(svn_ra_session_t *session,
apr_hash_t **locations,
@@ -1188,6 +1431,7 @@ svn_ra_serf__get_locations(svn_ra_sessio
const apr_array_header_t *location_revisions,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_location_segments(). */
svn_error_t *
svn_ra_serf__get_location_segments(svn_ra_session_t *session,
const char *path,
@@ -1198,6 +1442,7 @@ svn_ra_serf__get_location_segments(svn_r
void *receiver_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.do_diff(). */
svn_error_t *
svn_ra_serf__do_diff(svn_ra_session_t *session,
const svn_ra_reporter3_t **reporter,
@@ -1212,6 +1457,7 @@ svn_ra_serf__do_diff(svn_ra_session_t *s
void *diff_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.do_status(). */
svn_error_t *
svn_ra_serf__do_status(svn_ra_session_t *ra_session,
const svn_ra_reporter3_t **reporter,
@@ -1223,6 +1469,7 @@ svn_ra_serf__do_status(svn_ra_session_t
void *status_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.do_update(). */
svn_error_t *
svn_ra_serf__do_update(svn_ra_session_t *ra_session,
const svn_ra_reporter3_t **reporter,
@@ -1235,6 +1482,7 @@ svn_ra_serf__do_update(svn_ra_session_t
void *update_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.do_switch(). */
svn_error_t *
svn_ra_serf__do_switch(svn_ra_session_t *ra_session,
const svn_ra_reporter3_t **reporter,
@@ -1247,6 +1495,7 @@ svn_ra_serf__do_switch(svn_ra_session_t
void *switch_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_file_revs(). */
svn_error_t *
svn_ra_serf__get_file_revs(svn_ra_session_t *session,
const char *path,
@@ -1257,12 +1506,14 @@ svn_ra_serf__get_file_revs(svn_ra_sessio
void *handler_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_dated_revision(). */
svn_error_t *
svn_ra_serf__get_dated_revision(svn_ra_session_t *session,
svn_revnum_t *revision,
apr_time_t tm,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_commit_editor(). */
svn_error_t *
svn_ra_serf__get_commit_editor(svn_ra_session_t *session,
const svn_delta_editor_t **editor,
@@ -1274,6 +1525,7 @@ svn_ra_serf__get_commit_editor(svn_ra_se
svn_boolean_t keep_locks,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_file(). */
svn_error_t *
svn_ra_serf__get_file(svn_ra_session_t *session,
const char *path,
@@ -1283,6 +1535,7 @@ svn_ra_serf__get_file(svn_ra_session_t *
apr_hash_t **props,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.change_rev_prop(). */
svn_error_t *
svn_ra_serf__change_rev_prop(svn_ra_session_t *session,
svn_revnum_t rev,
@@ -1291,6 +1544,7 @@ svn_ra_serf__change_rev_prop(svn_ra_sess
const svn_string_t *value,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.replay(). */
svn_error_t *
svn_ra_serf__replay(svn_ra_session_t *ra_session,
svn_revnum_t revision,
@@ -1300,6 +1554,7 @@ svn_ra_serf__replay(svn_ra_session_t *ra
void *edit_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.replay_range(). */
svn_error_t *
svn_ra_serf__replay_range(svn_ra_session_t *ra_session,
svn_revnum_t start_revision,
@@ -1311,6 +1566,7 @@ svn_ra_serf__replay_range(svn_ra_session
void *replay_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.lock(). */
svn_error_t *
svn_ra_serf__lock(svn_ra_session_t *ra_session,
apr_hash_t *path_revs,
@@ -1320,6 +1576,7 @@ svn_ra_serf__lock(svn_ra_session_t *ra_s
void *lock_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.unlock(). */
svn_error_t *
svn_ra_serf__unlock(svn_ra_session_t *ra_session,
apr_hash_t *path_tokens,
@@ -1328,12 +1585,14 @@ svn_ra_serf__unlock(svn_ra_session_t *ra
void *lock_baton,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_lock(). */
svn_error_t *
svn_ra_serf__get_lock(svn_ra_session_t *ra_session,
svn_lock_t **lock,
const char *path,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_locks(). */
svn_error_t *
svn_ra_serf__get_locks(svn_ra_session_t *ra_session,
apr_hash_t **locks,
@@ -1341,13 +1600,19 @@ svn_ra_serf__get_locks(svn_ra_session_t
svn_depth_t depth,
apr_pool_t *pool);
-svn_error_t * svn_ra_serf__get_mergeinfo(svn_ra_session_t *ra_session,
- apr_hash_t **mergeinfo,
- const apr_array_header_t *paths,
- svn_revnum_t revision,
- svn_mergeinfo_inheritance_t inherit,
- svn_boolean_t include_descendants,
- apr_pool_t *pool);
+/* Request a mergeinfo-report from the URL attached to SESSION,
+ and fill in the MERGEINFO hash with the results.
+
+ Implements svn_ra__vtable_t.get_mergeinfo().
+ */
+svn_error_t *
+svn_ra_serf__get_mergeinfo(svn_ra_session_t *ra_session,
+ apr_hash_t **mergeinfo,
+ const apr_array_header_t *paths,
+ svn_revnum_t revision,
+ svn_mergeinfo_inheritance_t inherit,
+ svn_boolean_t include_descendants,
+ apr_pool_t *pool);
/* Exchange capabilities with the server, by sending an OPTIONS
* request announcing the client's capabilities, and by filling
@@ -1366,14 +1631,14 @@ svn_ra_serf__exchange_capabilities(svn_r
const char **corrected_url,
apr_pool_t *pool);
-/* Implements the has_capability RA layer function. */
+/* Implements svn_ra__vtable_t.has_capability(). */
svn_error_t *
svn_ra_serf__has_capability(svn_ra_session_t *ra_session,
svn_boolean_t *has,
const char *capability,
apr_pool_t *pool);
-/* Implements the get_deleted_rev RA layer function. */
+/* Implements svn_ra__vtable_t.get_deleted_rev(). */
svn_error_t *
svn_ra_serf__get_deleted_rev(svn_ra_session_t *session,
const char *path,
@@ -1382,6 +1647,18 @@ svn_ra_serf__get_deleted_rev(svn_ra_sess
svn_revnum_t *revision_deleted,
apr_pool_t *pool);
+/* Implements svn_ra__vtable_t.get_repos_root(). */
+svn_error_t *
+svn_ra_serf__get_repos_root(svn_ra_session_t *ra_session,
+ const char **url,
+ apr_pool_t *pool);
+
+/* Implements svn_ra__vtable_t.register_editor_shim_callbacks(). */
+svn_error_t *
+svn_ra_serf__register_editor_shim_callbacks(svn_ra_session_t *session,
+ svn_delta_shim_callbacks_t *callbacks);
+
+
/*** Authentication handler declarations ***/
/**
@@ -1408,16 +1685,14 @@ svn_ra_serf__error_on_status(int status_
const char *path,
const char *location);
-svn_error_t *
-svn_ra_serf__register_editor_shim_callbacks(svn_ra_session_t *session,
- svn_delta_shim_callbacks_t *callbacks);
-
-
+/* ###? */
svn_error_t *
svn_ra_serf__copy_into_spillbuf(svn_spillbuf_t **spillbuf,
serf_bucket_t *bkt,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
+
+/* ###? */
serf_bucket_t *
svn_ra_serf__create_sb_bucket(svn_spillbuf_t *spillbuf,
serf_bucket_alloc_t *allocator,
@@ -1425,12 +1700,6 @@ svn_ra_serf__create_sb_bucket(svn_spillb
apr_pool_t *scratch_pool);
-svn_error_t *
-svn_ra_serf__get_repos_root(svn_ra_session_t *ra_session,
- const char **url,
- apr_pool_t *pool);
-
-
#ifdef __cplusplus
}
#endif /* __cplusplus */
Modified: subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/replay.c
URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/replay.c?rev=1373783&r1=1373782&r2=1373783&view=diff
==============================================================================
--- subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/replay.c (original)
+++ subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/replay.c Thu Aug 16 10:17:48 2012
@@ -24,9 +24,6 @@
#include <apr_uri.h>
-
-#include <expat.h>
-
#include <serf.h>
#include "svn_pools.h"
@@ -132,7 +129,7 @@ typedef struct replay_context_t {
svn_ra_serf__xml_parser_t *parser_ctx;
/* The propfind for the revision properties of the current revision */
- svn_ra_serf__propfind_context_t *prop_ctx;
+ svn_ra_serf__handler_t *propfind_handler;
} replay_context_t;
@@ -191,20 +188,18 @@ start_replay(svn_ra_serf__xml_parser_t *
push_state(parser, ctx, REPORT);
/* Before we can continue, we need the revision properties. */
- SVN_ERR_ASSERT(!ctx->prop_ctx
- || svn_ra_serf__propfind_is_done(ctx->prop_ctx));
+ SVN_ERR_ASSERT(!ctx->propfind_handler || ctx->propfind_handler->done);
/* Create a pool for the commit editor. */
ctx->dst_rev_pool = svn_pool_create(ctx->src_rev_pool);
ctx->file_pool = svn_pool_create(ctx->dst_rev_pool);
- /* ### it would be nice to have a proper scratch_pool. */
SVN_ERR(svn_ra_serf__select_revprops(&ctx->props,
ctx->revprop_target,
ctx->revprop_rev,
ctx->revs_props,
ctx->dst_rev_pool,
- ctx->dst_rev_pool));
+ scratch_pool));
if (ctx->revstart_func)
{
@@ -228,7 +223,7 @@ start_replay(svn_ra_serf__xml_parser_t *
SVN_ERR(ctx->editor->set_target_revision(ctx->editor_baton,
SVN_STR_TO_REV(rev),
- ctx->dst_rev_pool));
+ scratch_pool));
}
else if (state == REPORT &&
strcmp(name.name, "open-root") == 0)
@@ -273,7 +268,7 @@ start_replay(svn_ra_serf__xml_parser_t *
info = push_state(parser, ctx, DELETE_ENTRY);
SVN_ERR(ctx->editor->delete_entry(file_name, SVN_STR_TO_REV(rev),
- info->baton, ctx->dst_rev_pool));
+ info->baton, scratch_pool));
svn_ra_serf__xml_pop_state(parser);
}
@@ -334,7 +329,7 @@ start_replay(svn_ra_serf__xml_parser_t *
{
replay_info_t *info = parser->state->private;
- SVN_ERR(ctx->editor->close_directory(info->baton, ctx->dst_rev_pool));
+ SVN_ERR(ctx->editor->close_directory(info->baton, scratch_pool));
svn_ra_serf__xml_pop_state(parser);
}
@@ -426,8 +421,7 @@ start_replay(svn_ra_serf__xml_parser_t *
checksum = svn_xml_get_attr_value("checksum", attrs);
- SVN_ERR(ctx->editor->close_file(info->baton, checksum,
- ctx->file_pool));
+ SVN_ERR(ctx->editor->close_file(info->baton, checksum, scratch_pool));
svn_ra_serf__xml_pop_state(parser);
}
@@ -643,10 +637,6 @@ svn_ra_serf__replay(svn_ra_session_t *ra
svn_ra_serf__xml_parser_t *parser_ctx;
svn_error_t *err;
const char *report_target;
- /* We're not really interested in the status code here in replay, but
- the XML parsing code will abort on error if it doesn't have a place
- to store the response status code. */
- int status_code;
SVN_ERR(svn_ra_serf__report_resource(&report_target, session, NULL, pool));
@@ -663,6 +653,7 @@ svn_ra_serf__replay(svn_ra_session_t *ra
handler = apr_pcalloc(pool, sizeof(*handler));
+ handler->handler_pool = pool;
handler->method = "REPORT";
handler->path = session->session_url_str;
handler->body_delegate = create_replay_body;
@@ -678,7 +669,6 @@ svn_ra_serf__replay(svn_ra_session_t *ra
parser_ctx->start = start_replay;
parser_ctx->end = end_replay;
parser_ctx->cdata = cdata_replay;
- parser_ctx->status_code = &status_code;
parser_ctx->done = &replay_ctx->done;
handler->response_handler = svn_ra_serf__handle_xml_parser;
@@ -752,10 +742,6 @@ svn_ra_serf__replay_range(svn_ra_session
svn_ra_serf__list_t *done_list;
svn_ra_serf__list_t *done_reports = NULL;
replay_context_t *replay_ctx;
- /* We're not really interested in the status code here in replay, but
- the XML parsing code will abort on error if it doesn't have a place
- to store the response status code. */
- int status_code;
if (session->cancel_func)
SVN_ERR(session->cancel_func(session->cancel_baton));
@@ -794,7 +780,7 @@ svn_ra_serf__replay_range(svn_ra_session
replay_ctx->revprop_rev = rev;
}
- SVN_ERR(svn_ra_serf__deliver_props(&replay_ctx->prop_ctx,
+ SVN_ERR(svn_ra_serf__deliver_props(&replay_ctx->propfind_handler,
replay_ctx->revs_props, session,
session->conns[0],
replay_ctx->revprop_target,
@@ -803,9 +789,13 @@ svn_ra_serf__replay_range(svn_ra_session
NULL,
replay_ctx->src_rev_pool));
+ /* Spin up the serf request for the PROPFIND. */
+ svn_ra_serf__request_create(replay_ctx->propfind_handler);
+
/* Send the replay report request. */
handler = apr_pcalloc(replay_ctx->src_rev_pool, sizeof(*handler));
+ handler->handler_pool = replay_ctx->src_rev_pool;
handler->method = "REPORT";
handler->path = session->session_url_str;
handler->body_delegate = create_replay_body;
@@ -828,7 +818,6 @@ svn_ra_serf__replay_range(svn_ra_session
parser_ctx->start = start_replay;
parser_ctx->end = end_replay;
parser_ctx->cdata = cdata_replay;
- parser_ctx->status_code = &status_code;
parser_ctx->done = &replay_ctx->done;
parser_ctx->done_list = &done_reports;
parser_ctx->done_item = &replay_ctx->done_item;
Propchange: subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/sb_bucket.c
------------------------------------------------------------------------------
svn:eol-style = native
Modified: subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/serf.c
URL: http://svn.apache.org/viewvc/subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/serf.c?rev=1373783&r1=1373782&r2=1373783&view=diff
==============================================================================
--- subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/serf.c (original)
+++ subversion/branches/compressed-pristines/subversion/libsvn_ra_serf/serf.c Thu Aug 16 10:17:48 2012
@@ -27,9 +27,6 @@
#include <apr_want.h>
#include <apr_uri.h>
-
-#include <expat.h>
-
#include <serf.h>
#include "svn_pools.h"
@@ -48,11 +45,13 @@
#include "private/svn_dav_protocol.h"
#include "private/svn_dep_compat.h"
#include "private/svn_fspath.h"
+#include "private/svn_subr_private.h"
#include "svn_private_config.h"
#include "ra_serf.h"
+/* Implements svn_ra__vtable_t.get_version(). */
static const svn_version_t *
ra_serf_version(void)
{
@@ -62,12 +61,14 @@ ra_serf_version(void)
#define RA_SERF_DESCRIPTION \
N_("Module for accessing a repository via WebDAV protocol using serf.")
+/* Implements svn_ra__vtable_t.get_description(). */
static const char *
ra_serf_get_description(void)
{
return _(RA_SERF_DESCRIPTION);
}
+/* Implements svn_ra__vtable_t.get_schemes(). */
static const char * const *
ra_serf_get_schemes(apr_pool_t *pool)
{
@@ -269,6 +270,11 @@ load_config(svn_ra_serf__session_t *sess
else
session->timeout = apr_time_from_sec(DEFAULT_HTTP_TIMEOUT);
+ if (session->timeout < 0) /* Always true for DEFAULT_HTTP_TIMEOUT */
+ session->timeout = apr_time_from_sec(600); /* 10 min */
+
+ SVN_ERR_ASSERT(session->timeout > 0);
+
/* Convert the proxy port value, if any. */
if (port_str)
{
@@ -334,10 +340,11 @@ svn_ra_serf__progress(void *progress_bat
}
}
+/* Implements svn_ra__vtable_t.open_session(). */
static svn_error_t *
svn_ra_serf__open(svn_ra_session_t *session,
const char **corrected_url,
- const char *repos_URL,
+ const char *session_URL,
const svn_ra_callbacks2_t *callbacks,
void *callback_baton,
apr_hash_t *config,
@@ -367,12 +374,12 @@ svn_ra_serf__open(svn_ra_session_t *sess
serf_sess->pool));
- status = apr_uri_parse(serf_sess->pool, repos_URL, &url);
+ status = apr_uri_parse(serf_sess->pool, session_URL, &url);
if (status)
{
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
- _("Illegal repository URL '%s'"),
- repos_URL);
+ _("Illegal URL '%s'"),
+ session_URL);
}
/* Contrary to what the comment for apr_uri_t.path says in apr-util 1.2.12 and
older, for root paths url.path will be "", where serf requires "/". */
@@ -383,40 +390,34 @@ svn_ra_serf__open(svn_ra_session_t *sess
url.port = apr_uri_port_of_scheme(url.scheme);
}
serf_sess->session_url = url;
- serf_sess->session_url_str = apr_pstrdup(serf_sess->pool, repos_URL);
+ serf_sess->session_url_str = apr_pstrdup(serf_sess->pool, session_URL);
serf_sess->using_ssl = (svn_cstring_casecmp(url.scheme, "https") == 0);
serf_sess->supports_deadprop_count = svn_tristate_unknown;
serf_sess->capabilities = apr_hash_make(serf_sess->pool);
- SVN_ERR(load_config(serf_sess, config, serf_sess->pool));
+ serf_sess->http10 = TRUE; /* until we confirm HTTP/1.1 */
+ serf_sess->http10 = FALSE; /* ### don't change behavior yet */
-
- serf_sess->conns = apr_palloc(serf_sess->pool, sizeof(*serf_sess->conns) * 4);
+ SVN_ERR(load_config(serf_sess, config, serf_sess->pool));
serf_sess->conns[0] = apr_pcalloc(serf_sess->pool,
sizeof(*serf_sess->conns[0]));
- serf_sess->conns[0]->http10 = TRUE; /* until we confirm HTTP/1.1 */
- serf_sess->conns[0]->http10 = FALSE; /* ### don't change behavior yet */
serf_sess->conns[0]->bkt_alloc =
serf_bucket_allocator_create(serf_sess->pool, NULL, NULL);
serf_sess->conns[0]->session = serf_sess;
serf_sess->conns[0]->last_status_code = -1;
- serf_sess->conns[0]->using_ssl = serf_sess->using_ssl;
- serf_sess->conns[0]->using_compression = serf_sess->using_compression;
- serf_sess->conns[0]->hostname = url.hostname;
-
/* create the user agent string */
if (callbacks->get_client_string)
callbacks->get_client_string(callback_baton, &client_string, pool);
if (client_string)
- serf_sess->conns[0]->useragent = apr_pstrcat(pool, USER_AGENT, "/",
- client_string, (char *)NULL);
+ serf_sess->useragent = apr_pstrcat(pool, USER_AGENT, "/",
+ client_string, (char *)NULL);
else
- serf_sess->conns[0]->useragent = USER_AGENT;
+ serf_sess->useragent = USER_AGENT;
/* go ahead and tell serf about the connection. */
status =
@@ -440,6 +441,7 @@ svn_ra_serf__open(svn_ra_session_t *sess
return svn_ra_serf__exchange_capabilities(serf_sess, corrected_url, pool);
}
+/* Implements svn_ra__vtable_t.reparent(). */
static svn_error_t *
svn_ra_serf__reparent(svn_ra_session_t *ra_session,
const char *url,
@@ -469,19 +471,22 @@ svn_ra_serf__reparent(svn_ra_session_t *
"URL '%s'"), url, session->repos_root_str);
}
- status = apr_uri_parse(session->pool, url, &new_url);
+ status = apr_uri_parse(pool, url, &new_url);
if (status)
{
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("Illegal repository URL '%s'"), url);
}
- session->session_url.path = new_url.path;
+ /* Maybe we should use a string buffer for these strings so we don't
+ allocate memory in the session on every reparent? */
+ session->session_url.path = apr_pstrdup(session->pool, new_url.path);
session->session_url_str = apr_pstrdup(session->pool, url);
return SVN_NO_ERROR;
}
+/* Implements svn_ra__vtable_t.get_session_url(). */
static svn_error_t *
svn_ra_serf__get_session_url(svn_ra_session_t *ra_session,
const char **url,
@@ -492,20 +497,19 @@ svn_ra_serf__get_session_url(svn_ra_sess
return SVN_NO_ERROR;
}
+/* Implements svn_ra__vtable_t.get_latest_revnum(). */
static svn_error_t *
svn_ra_serf__get_latest_revnum(svn_ra_session_t *ra_session,
svn_revnum_t *latest_revnum,
apr_pool_t *pool)
{
- const char *relative_url, *basecoll_url;
svn_ra_serf__session_t *session = ra_session->priv;
- return svn_ra_serf__get_baseline_info(&basecoll_url, &relative_url, session,
- NULL, session->session_url.path,
- SVN_INVALID_REVNUM, latest_revnum,
- pool);
+ return svn_error_trace(svn_ra_serf__get_youngest_revnum(
+ latest_revnum, session, pool));
}
+/* Implements svn_ra__vtable_t.rev_proplist(). */
static svn_error_t *
svn_ra_serf__rev_proplist(svn_ra_session_t *ra_session,
svn_revnum_t rev,
@@ -532,6 +536,7 @@ svn_ra_serf__rev_proplist(svn_ra_session
SVN_ERR(svn_ra_serf__discover_vcc(&propfind_path, session, NULL, pool));
}
+ /* ### fix: fetch hash of *just* the PATH@REV props. no nested hash. */
SVN_ERR(svn_ra_serf__retrieve_props(&props, session, session->conns[0],
propfind_path, rev, "0", all_props,
pool, pool));
@@ -542,6 +547,7 @@ svn_ra_serf__rev_proplist(svn_ra_session
return SVN_NO_ERROR;
}
+/* Implements svn_ra__vtable_t.rev_prop(). */
static svn_error_t *
svn_ra_serf__rev_prop(svn_ra_session_t *session,
svn_revnum_t rev,
@@ -559,71 +565,43 @@ svn_ra_serf__rev_prop(svn_ra_session_t *
}
static svn_error_t *
-fetch_path_props(svn_ra_serf__propfind_context_t **ret_prop_ctx,
- apr_hash_t **ret_props,
- const char **ret_path,
- svn_revnum_t *ret_revision,
+fetch_path_props(apr_hash_t **props,
svn_ra_serf__session_t *session,
- const char *rel_path,
+ const char *session_relpath,
svn_revnum_t revision,
const svn_ra_serf__dav_props_t *desired_props,
- apr_pool_t *pool)
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
{
- svn_ra_serf__propfind_context_t *prop_ctx;
- apr_hash_t *props;
- const char *path;
+ const char *url;
- path = session->session_url.path;
+ url = session->session_url.path;
/* If we have a relative path, append it. */
- if (rel_path)
- {
- path = svn_path_url_add_component2(path, rel_path, pool);
- }
-
- props = apr_hash_make(pool);
-
- /* If we were given a specific revision, we have to fetch the VCC and
- * do a PROPFIND off of that.
- */
- if (!SVN_IS_VALID_REVNUM(revision))
- {
- SVN_ERR(svn_ra_serf__deliver_props(&prop_ctx, props, session,
- session->conns[0], path, revision,
- "0", desired_props, NULL,
- pool));
- }
- else
- {
- const char *relative_url, *basecoll_url;
+ if (session_relpath)
+ url = svn_path_url_add_component2(url, session_relpath, scratch_pool);
- SVN_ERR(svn_ra_serf__get_baseline_info(&basecoll_url, &relative_url,
- session, NULL, path,
- revision, NULL, pool));
-
- /* We will try again with our new path; however, we're now
- * technically an unversioned resource because we are accessing
- * the revision's baseline-collection.
- */
- path = svn_path_url_add_component2(basecoll_url, relative_url, pool);
- revision = SVN_INVALID_REVNUM;
- SVN_ERR(svn_ra_serf__deliver_props(&prop_ctx, props, session,
- session->conns[0], path, revision,
- "0", desired_props, NULL,
- pool));
- }
-
- /* ### switch to svn_ra_serf__retrieve_props? */
- SVN_ERR(svn_ra_serf__wait_for_props(prop_ctx, session, pool));
-
- *ret_path = path;
- *ret_prop_ctx = prop_ctx;
- *ret_props = props;
- *ret_revision = revision;
+ /* If we were given a specific revision, get a URL that refers to that
+ specific revision (rather than floating with HEAD). */
+ if (SVN_IS_VALID_REVNUM(revision))
+ {
+ SVN_ERR(svn_ra_serf__get_stable_url(&url, NULL /* latest_revnum */,
+ session, NULL /* conn */,
+ url, revision,
+ scratch_pool, scratch_pool));
+ }
+
+ /* URL is stable, so we use SVN_INVALID_REVNUM since it is now irrelevant.
+ Or we started with SVN_INVALID_REVNUM and URL may be floating. */
+ SVN_ERR(svn_ra_serf__fetch_node_props(props, session->conns[0],
+ url, SVN_INVALID_REVNUM,
+ desired_props,
+ result_pool, scratch_pool));
return SVN_NO_ERROR;
}
+/* Implements svn_ra__vtable_t.check_path(). */
static svn_error_t *
svn_ra_serf__check_path(svn_ra_session_t *ra_session,
const char *rel_path,
@@ -633,13 +611,10 @@ svn_ra_serf__check_path(svn_ra_session_t
{
svn_ra_serf__session_t *session = ra_session->priv;
apr_hash_t *props;
- svn_ra_serf__propfind_context_t *prop_ctx;
- const char *path;
- svn_revnum_t fetched_rev;
- svn_error_t *err = fetch_path_props(&prop_ctx, &props, &path, &fetched_rev,
- session, rel_path,
- revision, check_path_props, pool);
+ svn_error_t *err = fetch_path_props(&props, session, rel_path,
+ revision, check_path_props,
+ pool, pool);
if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
{
@@ -648,11 +623,14 @@ svn_ra_serf__check_path(svn_ra_session_t
}
else
{
+ svn_kind_t res_kind;
+
/* Any other error, raise to caller. */
if (err)
- return err;
+ return svn_error_trace(err);
- SVN_ERR(svn_ra_serf__get_resource_type(kind, props, path, fetched_rev));
+ SVN_ERR(svn_ra_serf__get_resource_type(&res_kind, props));
+ *kind = svn__node_kind_from_kind(res_kind);
}
return SVN_NO_ERROR;
@@ -862,6 +840,7 @@ get_dirent_props(apr_uint32_t dirent_fie
return (svn_ra_serf__dav_props_t *) props->elts;
}
+/* Implements svn_ra__vtable_t.stat(). */
static svn_error_t *
svn_ra_serf__stat(svn_ra_session_t *ra_session,
const char *rel_path,
@@ -871,17 +850,14 @@ svn_ra_serf__stat(svn_ra_session_t *ra_s
{
svn_ra_serf__session_t *session = ra_session->priv;
apr_hash_t *props;
- svn_ra_serf__propfind_context_t *prop_ctx;
- const char *path;
- svn_revnum_t fetched_rev;
svn_error_t *err;
struct dirent_walker_baton_t dwb;
svn_tristate_t deadprop_count = svn_tristate_unknown;
- err = fetch_path_props(&prop_ctx, &props, &path, &fetched_rev,
+ err = fetch_path_props(&props,
session, rel_path, revision,
get_dirent_props(SVN_DIRENT_ALL, session, pool),
- pool);
+ pool, pool);
if (err)
{
if (err->apr_err == SVN_ERR_FS_NOT_FOUND)
@@ -897,9 +873,7 @@ svn_ra_serf__stat(svn_ra_session_t *ra_s
dwb.entry = apr_pcalloc(pool, sizeof(*dwb.entry));
dwb.supports_deadprop_count = &deadprop_count;
dwb.result_pool = pool;
- SVN_ERR(svn_ra_serf__walk_all_props(props, path, fetched_rev,
- dirent_walker, &dwb,
- pool));
+ SVN_ERR(svn_ra_serf__walk_node_props(props, dirent_walker, &dwb, pool));
if (deadprop_count == svn_tristate_false
&& session->supports_deadprop_count == svn_tristate_unknown
@@ -909,14 +883,12 @@ svn_ra_serf__stat(svn_ra_session_t *ra_s
information */
session->supports_deadprop_count = svn_tristate_false;
- SVN_ERR(fetch_path_props(&prop_ctx, &props, &path, &fetched_rev,
- session, rel_path, fetched_rev,
+ SVN_ERR(fetch_path_props(&props,
+ session, rel_path, SVN_INVALID_REVNUM,
get_dirent_props(SVN_DIRENT_ALL, session, pool),
- pool));
+ pool, pool));
- SVN_ERR(svn_ra_serf__walk_all_props(props, path, fetched_rev,
- dirent_walker, &dwb,
- pool));
+ SVN_ERR(svn_ra_serf__walk_node_props(props, dirent_walker, &dwb, pool));
}
if (deadprop_count != svn_tristate_unknown)
@@ -932,15 +904,13 @@ svn_ra_serf__stat(svn_ra_session_t *ra_s
* SVN_ERR_FS_NOT_DIRECTORY if not.
*/
static svn_error_t *
-resource_is_directory(apr_hash_t *props,
- const char *path,
- svn_revnum_t revision)
+resource_is_directory(apr_hash_t *props)
{
- svn_node_kind_t kind;
+ svn_kind_t kind;
- SVN_ERR(svn_ra_serf__get_resource_type(&kind, props, path, revision));
+ SVN_ERR(svn_ra_serf__get_resource_type(&kind, props));
- if (kind != svn_node_dir)
+ if (kind != svn_kind_dir)
{
return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
_("Can't get entries of non-directory"));
@@ -949,6 +919,7 @@ resource_is_directory(apr_hash_t *props,
return SVN_NO_ERROR;
}
+/* Implements svn_ra__vtable_t.get_dir(). */
static svn_error_t *
svn_ra_serf__get_dir(svn_ra_session_t *ra_session,
apr_hash_t **dirents,
@@ -975,34 +946,37 @@ svn_ra_serf__get_dir(svn_ra_session_t *r
public url. */
if (SVN_IS_VALID_REVNUM(revision) || fetched_rev)
{
- const char *relative_url, *basecoll_url;
-
- SVN_ERR(svn_ra_serf__get_baseline_info(&basecoll_url, &relative_url,
- session, NULL, path, revision,
- fetched_rev, pool));
-
- path = svn_path_url_add_component2(basecoll_url, relative_url, pool);
+ SVN_ERR(svn_ra_serf__get_stable_url(&path, fetched_rev,
+ session, NULL /* conn */,
+ path, revision,
+ pool, pool));
revision = SVN_INVALID_REVNUM;
}
+ /* REVISION is always SVN_INVALID_REVNUM */
+ SVN_ERR_ASSERT(!SVN_IS_VALID_REVNUM(revision));
/* If we're asked for children, fetch them now. */
if (dirents)
{
struct path_dirent_visitor_t dirent_walk;
apr_hash_t *props;
+ const char *rtype;
/* Always request node kind to check that path is really a
* directory.
*/
dirent_fields |= SVN_DIRENT_KIND;
SVN_ERR(svn_ra_serf__retrieve_props(&props, session, session->conns[0],
- path, revision, "1",
+ path, SVN_INVALID_REVNUM, "1",
get_dirent_props(dirent_fields,
session, pool),
pool, pool));
/* Check if the path is really a directory. */
- SVN_ERR(resource_is_directory(props, path, revision));
+ rtype = svn_ra_serf__get_prop(props, path, "DAV:", "resourcetype");
+ if (rtype == NULL || strcmp(rtype, "collection") != 0)
+ return svn_error_create(SVN_ERR_FS_NOT_DIRECTORY, NULL,
+ _("Can't get entries of non-directory"));
/* We're going to create two hashes to help the walker along.
* We're going to return the 2nd one back to the caller as it
@@ -1014,8 +988,9 @@ svn_ra_serf__get_dir(svn_ra_session_t *r
dirent_walk.supports_deadprop_count = svn_tristate_unknown;
dirent_walk.result_pool = pool;
- SVN_ERR(svn_ra_serf__walk_all_paths(props, revision, path_dirent_walker,
- &dirent_walk, pool));
+ SVN_ERR(svn_ra_serf__walk_all_paths(props, SVN_INVALID_REVNUM,
+ path_dirent_walker, &dirent_walk,
+ pool));
if (dirent_walk.supports_deadprop_count == svn_tristate_false
&& session->supports_deadprop_count == svn_tristate_unknown
@@ -1026,7 +1001,7 @@ svn_ra_serf__get_dir(svn_ra_session_t *r
session->supports_deadprop_count = svn_tristate_false;
SVN_ERR(svn_ra_serf__retrieve_props(&props, session,
session->conns[0],
- path, revision, "1",
+ path, SVN_INVALID_REVNUM, "1",
get_dirent_props(dirent_fields,
session, pool),
pool, pool));
@@ -1034,7 +1009,7 @@ svn_ra_serf__get_dir(svn_ra_session_t *r
SVN_ERR(svn_hash__clear(dirent_walk.full_paths, pool));
SVN_ERR(svn_hash__clear(dirent_walk.base_paths, pool));
- SVN_ERR(svn_ra_serf__walk_all_paths(props, revision,
+ SVN_ERR(svn_ra_serf__walk_all_paths(props, SVN_INVALID_REVNUM,
path_dirent_walker,
&dirent_walk, pool));
}
@@ -1050,14 +1025,17 @@ svn_ra_serf__get_dir(svn_ra_session_t *r
{
apr_hash_t *props;
- SVN_ERR(svn_ra_serf__retrieve_props(&props, session, session->conns[0],
- path, revision, "0", all_props,
- pool, pool));
+ SVN_ERR(svn_ra_serf__fetch_node_props(&props, session->conns[0],
+ path, SVN_INVALID_REVNUM,
+ all_props,
+ pool, pool));
+
/* Check if the path is really a directory. */
- SVN_ERR(resource_is_directory(props, path, revision));
+ SVN_ERR(resource_is_directory(props));
- SVN_ERR(svn_ra_serf__flatten_props(ret_props, props, path, revision,
- pool, pool));
+ /* ### flatten_props() does not copy PROPVALUE, but fetch_node_props()
+ ### put them into POOL, so we're okay. */
+ SVN_ERR(svn_ra_serf__flatten_props(ret_props, props, pool, pool));
}
return SVN_NO_ERROR;
@@ -1088,6 +1066,8 @@ svn_ra_serf__get_repos_root(svn_ra_sessi
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,