You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by pb...@apache.org on 2012/10/06 20:31:33 UTC
svn commit: r1395146 [4/7] - in /subversion/branches/auto-props-sdc: ./
build/ build/ac-macros/ subversion/bindings/swig/
subversion/bindings/swig/include/
subversion/bindings/swig/perl/libsvn_swig_perl/
subversion/bindings/swig/perl/native/ subversion...
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.c Sat Oct 6 18:31:28 2012
@@ -59,6 +59,7 @@
#include "temp_serializer.h"
#include "private/svn_mergeinfo_private.h"
+#include "private/svn_subr_private.h"
#include "private/svn_fs_util.h"
#include "private/svn_fspath.h"
#include "../libsvn_fs/fs-loader.h"
@@ -120,8 +121,11 @@ typedef struct fs_txn_root_data_t
} fs_txn_root_data_t;
/* Declared here to resolve the circular dependencies. */
-static svn_error_t * get_dag(dag_node_t **dag_node_p, svn_fs_root_t *root,
- const char *path, apr_pool_t *pool);
+static svn_error_t * get_dag(dag_node_t **dag_node_p,
+ svn_fs_root_t *root,
+ const char *path,
+ svn_boolean_t needs_lock_cache,
+ apr_pool_t *pool);
static svn_fs_root_t *make_revision_root(svn_fs_t *fs, svn_revnum_t rev,
dag_node_t *root_dir,
@@ -135,6 +139,254 @@ static svn_error_t *make_txn_root(svn_fs
/*** Node Caching ***/
+/* 1st level cache */
+
+/* An entry in the first-level cache. REVISION and PATH form the key that
+ will ultimately be matched.
+ */
+typedef struct cache_entry_t
+{
+ /* hash value derived from PATH, REVISION.
+ Used to short-circuit failed lookups. */
+ apr_uint32_t hash_value;
+
+ /* revision to which the NODE belongs */
+ svn_revnum_t revision;
+
+ /* path of the NODE */
+ char *path;
+
+ /* cached value of strlen(PATH). */
+ apr_size_t path_len;
+
+ /* the node allocated in the cache's pool. NULL for empty entries. */
+ dag_node_t *node;
+} cache_entry_t;
+
+/* Number of entries in the cache. Keep this low to keep pressure on the
+ CPU caches low as well. A binary value is most efficient. If we walk
+ a directory tree, we want enough entries to store nodes for all files
+ without overwriting the nodes for the parent folder. That way, there
+ will be no unnecessary misses (except for a few random ones caused by
+ hash collision).
+
+ The actual number of instances may be higher but entries that got
+ overwritten are no longer visible.
+ */
+enum { BUCKET_COUNT = 256 };
+
+/* Each pool that has received a DAG node, will hold at least on lock on
+ our cache to ensure that the node remains valid despite being allocated
+ in the cache's pool. This is the structure to represent the lock.
+ */
+typedef struct cache_lock_t
+{
+ /* pool holding the lock */
+ apr_pool_t *pool;
+
+ /* cache being locked */
+ fs_fs_dag_cache_t *cache;
+
+ /* next lock. NULL at EOL */
+ struct cache_lock_t *next;
+
+ /* previous lock. NULL at list head. Only then this==cache->first_lock */
+ struct cache_lock_t *prev;
+} cache_lock_t;
+
+/* The actual cache structure. All nodes will be allocated in POOL.
+ When the number of INSERTIONS (i.e. objects created form that pool)
+ exceeds a certain threshold, the pool will be cleared and the cache
+ with it.
+
+ To ensure that nodes returned from this structure remain valid, the
+ cache will get locked for the lifetime of the _receiving_ pools (i.e.
+ those in which we would allocate the node if there was no cache.).
+ The cache will only be cleared FIRST_LOCK is 0.
+ */
+struct fs_fs_dag_cache_t
+{
+ /* fixed number of (possibly empty) cache entries */
+ cache_entry_t buckets[BUCKET_COUNT];
+
+ /* pool used for all node allocation */
+ apr_pool_t *pool;
+
+ /* number of entries created from POOL since the last cleanup */
+ apr_size_t insertions;
+
+ /* Property lookups etc. have a very high locality (75% re-hit).
+ Thus, remember the last hit location for optimistic lookup. */
+ apr_size_t last_hit;
+
+ /* List of receiving pools that are still alive. */
+ cache_lock_t *first_lock;
+};
+
+/* Cleanup function to be called when a receiving pool gets cleared.
+ Unlocks the cache once.
+ */
+static apr_status_t
+unlock_cache(void *baton_void)
+{
+ cache_lock_t *lock = baton_void;
+
+ /* remove lock from chain. Update the head */
+ if (lock->next)
+ lock->next->prev = lock->prev;
+ if (lock->prev)
+ lock->prev->next = lock->next;
+ else
+ lock->cache->first_lock = lock->next;
+
+ return APR_SUCCESS;
+}
+
+/* Cleanup function to be called when the cache itself gets destroyed.
+ In that case, we must unregister all unlock requests.
+ */
+static apr_status_t
+unregister_locks(void *baton_void)
+{
+ fs_fs_dag_cache_t *cache = baton_void;
+ cache_lock_t *lock;
+
+ for (lock = cache->first_lock; lock; lock = lock->next)
+ apr_pool_cleanup_kill(lock->pool,
+ lock,
+ unlock_cache);
+
+ return APR_SUCCESS;
+}
+
+fs_fs_dag_cache_t*
+svn_fs_fs__create_dag_cache(apr_pool_t *pool)
+{
+ fs_fs_dag_cache_t *result = apr_pcalloc(pool, sizeof(*result));
+ result->pool = svn_pool_create(pool);
+
+ apr_pool_cleanup_register(pool,
+ result,
+ unregister_locks,
+ apr_pool_cleanup_null);
+
+ return result;
+}
+
+/* Prevent the entries in CACHE from being destroyed, for as long as the
+ POOL lives.
+ */
+static void
+lock_cache(fs_fs_dag_cache_t* cache, apr_pool_t *pool)
+{
+ /* we only need to lock / unlock once per pool. Since we will often ask
+ for multiple nodes with the same pool, we can reduce the overhead.
+ However, if e.g. pools are being used in an alternating pattern,
+ we may lock the cache more than once for the same pool (and register
+ just as many cleanup actions).
+ */
+ cache_lock_t *lock = cache->first_lock;
+
+ /* try to find an existing lock for POOL.
+ But limit the time spent on chasing pointers. */
+ int limiter = 8;
+ while (lock && --limiter)
+ if (lock->pool == pool)
+ return;
+
+ /* create a new lock and put it at the beginning of the lock chain */
+ lock = apr_palloc(pool, sizeof(*lock));
+ lock->cache = cache;
+ lock->pool = pool;
+ lock->next = cache->first_lock;
+ lock->prev = NULL;
+
+ if (cache->first_lock)
+ cache->first_lock->prev = lock;
+ cache->first_lock = lock;
+
+ /* instruct POOL to remove the look upon cleanup */
+ apr_pool_cleanup_register(pool,
+ lock,
+ unlock_cache,
+ apr_pool_cleanup_null);
+}
+
+/* Clears the CACHE at regular intervals (destroying all cached nodes)
+ */
+static void
+auto_clear_dag_cache(fs_fs_dag_cache_t* cache)
+{
+ if (cache->first_lock == NULL && cache->insertions > BUCKET_COUNT)
+ {
+ apr_pool_clear(cache->pool);
+
+ memset(cache->buckets, 0, sizeof(cache->buckets));
+ cache->insertions = 0;
+ }
+}
+
+/* For the given REVISION and PATH, return the respective entry in CACHE.
+ If the entry is empty, its NODE member will be NULL and the caller
+ may then set it to the corresponding DAG node allocated in CACHE->POOL.
+ */
+static cache_entry_t *
+cache_lookup( fs_fs_dag_cache_t *cache
+ , svn_revnum_t revision
+ , const char *path)
+{
+ apr_size_t i, bucket_index;
+ apr_size_t path_len = strlen(path);
+ apr_uint32_t hash_value = revision;
+
+ /* optimistic lookup: hit the same bucket again? */
+ cache_entry_t *result = &cache->buckets[cache->last_hit];
+ if ( (result->revision == revision)
+ && (result->path_len == path_len)
+ && !memcmp(result->path, path, path_len))
+ {
+ return result;
+ }
+
+ /* need to do a full lookup. Calculate the hash value
+ (HASH_VALUE has been initialized to REVISION). */
+ for (i = 0; i + 4 <= path_len; i += 4)
+ hash_value = hash_value * 0xd1f3da69 + *(const apr_uint32_t*)(path + i);
+
+ for (; i < path_len; ++i)
+ hash_value = hash_value * 33 + path[i];
+
+ bucket_index = hash_value + (hash_value >> 16);
+ bucket_index = (bucket_index + (bucket_index >> 8)) % BUCKET_COUNT;
+
+ /* access the corresponding bucket and remember its location */
+ result = &cache->buckets[bucket_index];
+ cache->last_hit = bucket_index;
+
+ /* if it is *NOT* a match, clear the bucket, expect the caller to fill
+ in the node and count it as an insertion */
+ if ( (result->hash_value != hash_value)
+ || (result->revision != revision)
+ || (result->path_len != path_len)
+ || memcmp(result->path, path, path_len))
+ {
+ result->hash_value = hash_value;
+ result->revision = revision;
+ if (result->path_len < path_len)
+ result->path = apr_palloc(cache->pool, path_len + 1);
+ result->path_len = path_len;
+ memcpy(result->path, path, path_len + 1);
+
+ result->node = NULL;
+
+ cache->insertions++;
+ }
+
+ return result;
+}
+
+/* 2nd level cache */
+
/* Find and return the DAG node cache for ROOT and the key that
should be used for PATH. */
static void
@@ -160,32 +412,75 @@ locate_cache(svn_cache__t **cache,
}
/* Return NODE for PATH from ROOT's node cache, or NULL if the node
- isn't cached; the node is copied into POOL. */
+ isn't cached; read it from the FS. *NODE remains valid until either
+ POOL or the FS gets cleared or destroyed (whichever comes first).
+
+ Since locking can be expensive and POOL may be long-living, for
+ nodes that will not need to survive the next call to this function,
+ set NEEDS_LOCK_CACHE to FALSE. */
static svn_error_t *
dag_node_cache_get(dag_node_t **node_p,
svn_fs_root_t *root,
const char *path,
+ svn_boolean_t needs_lock_cache,
apr_pool_t *pool)
{
svn_boolean_t found;
- dag_node_t *node;
+ dag_node_t *node = NULL;
svn_cache__t *cache;
const char *key;
SVN_ERR_ASSERT(*path == '/');
- locate_cache(&cache, &key, root, path, pool);
-
- SVN_ERR(svn_cache__get((void **) &node, &found, cache, key, pool));
- if (found && node)
+ if (!root->is_txn_root)
{
- /* Patch up the FS, since this might have come from an old FS
- * object. */
- svn_fs_fs__dag_set_fs(node, root->fs);
- *node_p = node;
+ /* immutable DAG node. use the global caches for it */
+
+ fs_fs_data_t *ffd = root->fs->fsap_data;
+ cache_entry_t *bucket;
+
+ auto_clear_dag_cache(ffd->dag_node_cache);
+ bucket = cache_lookup(ffd->dag_node_cache, root->rev, path);
+ if (bucket->node == NULL)
+ {
+ locate_cache(&cache, &key, root, path, pool);
+ SVN_ERR(svn_cache__get((void **)&node, &found, cache, key,
+ ffd->dag_node_cache->pool));
+ if (found && node)
+ {
+ /* Patch up the FS, since this might have come from an old FS
+ * object. */
+ svn_fs_fs__dag_set_fs(node, root->fs);
+ bucket->node = node;
+ }
+ }
+ else
+ {
+ node = bucket->node;
+ }
+
+ /* if we found a node, make sure it remains valid at least as long
+ as it would when allocated in POOL. */
+ if (node && needs_lock_cache)
+ lock_cache(ffd->dag_node_cache, pool);
}
else
- *node_p = NULL;
+ {
+ /* DAG is mutable / may become invalid. Use the TXN-local cache */
+
+ locate_cache(&cache, &key, root, path, pool);
+
+ SVN_ERR(svn_cache__get((void **) &node, &found, cache, key, pool));
+ if (found && node)
+ {
+ /* Patch up the FS, since this might have come from an old FS
+ * object. */
+ svn_fs_fs__dag_set_fs(node, root->fs);
+ }
+ }
+
+ *node_p = node;
+
return SVN_NO_ERROR;
}
@@ -504,7 +799,7 @@ get_copy_inheritance(copy_id_inherit_t *
SVN_ERR(svn_fs_fs__dag_get_copyroot(©root_rev, ©root_path,
child->node));
SVN_ERR(svn_fs_fs__revision_root(©root_root, fs, copyroot_rev, pool));
- SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, pool));
+ SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, FALSE, pool));
copyroot_id = svn_fs_fs__dag_get_id(copyroot_node);
if (svn_fs_fs__id_compare(copyroot_id, child_id) == -1)
@@ -592,7 +887,9 @@ open_path(parent_path_t **parent_path_p,
dag_node_t *here; /* The directory we're currently looking at. */
parent_path_t *parent_path; /* The path from HERE up to the root. */
const char *rest; /* The portion of PATH we haven't traversed yet. */
- const char *canon_path = svn_fs__canonicalize_abspath(path, pool);
+ const char *canon_path = svn_fs__is_canonical_abspath(path)
+ ? path
+ : svn_fs__canonicalize_abspath(path, pool);
const char *path_so_far = "/";
apr_pool_t *iterpool = svn_pool_create(pool);
@@ -641,7 +938,8 @@ open_path(parent_path_t **parent_path_p,
/* If we found a directory entry, follow it. First, we
check our node cache, and, failing that, we hit the DAG
layer. */
- SVN_ERR(dag_node_cache_get(&cached_node, root, path_so_far, pool));
+ SVN_ERR(dag_node_cache_get(&cached_node, root, path_so_far, TRUE,
+ pool));
if (cached_node)
child = cached_node;
else
@@ -770,7 +1068,8 @@ make_path_mutable(svn_fs_root_t *root,
parent_path->node));
SVN_ERR(svn_fs_fs__revision_root(©root_root, root->fs,
copyroot_rev, pool));
- SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path, pool));
+ SVN_ERR(get_dag(©root_node, copyroot_root, copyroot_path,
+ FALSE, pool));
child_id = svn_fs_fs__dag_get_id(parent_path->node);
copyroot_id = svn_fs_fs__dag_get_id(copyroot_node);
@@ -807,29 +1106,47 @@ make_path_mutable(svn_fs_root_t *root,
/* Open the node identified by PATH in ROOT. Set DAG_NODE_P to the
node we find, allocated in POOL. Return the error
- SVN_ERR_FS_NOT_FOUND if this node doesn't exist. */
+ SVN_ERR_FS_NOT_FOUND if this node doesn't exist.
+
+ Since locking can be expensive and POOL may be long-living, for
+ nodes that will not need to survive the next call to this function,
+ set NEEDS_LOCK_CACHE to FALSE. */
static svn_error_t *
get_dag(dag_node_t **dag_node_p,
svn_fs_root_t *root,
const char *path,
+ svn_boolean_t needs_lock_cache,
apr_pool_t *pool)
{
parent_path_t *parent_path;
- dag_node_t *node;
+ dag_node_t *node = NULL;
- /* Canonicalize the input PATH. */
- path = svn_fs__canonicalize_abspath(path, pool);
+ /* First we look for the DAG in our cache
+ (if the path may be canonical). */
+ if (*path == '/')
+ SVN_ERR(dag_node_cache_get(&node, root, path, needs_lock_cache, pool));
- /* First we look for the DAG in our cache. */
- SVN_ERR(dag_node_cache_get(&node, root, path, pool));
if (! node)
{
- /* Call open_path with no flags, as we want this to return an error
- if the node for which we are searching doesn't exist. */
- SVN_ERR(open_path(&parent_path, root, path, 0, NULL, pool));
- node = parent_path->node;
+ /* Canonicalize the input PATH. */
+ if (!svn_fs__is_canonical_abspath(path))
+ {
+ path = svn_fs__canonicalize_abspath(path, pool);
- /* No need to cache our find -- open_path() will do that for us. */
+ /* Try again with the corrected path. */
+ SVN_ERR(dag_node_cache_get(&node, root, path, needs_lock_cache,
+ pool));
+ }
+
+ if (! node)
+ {
+ /* Call open_path with no flags, as we want this to return an
+ * error if the node for which we are searching doesn't exist. */
+ SVN_ERR(open_path(&parent_path, root, path, 0, NULL, pool));
+ node = parent_path->node;
+
+ /* No need to cache our find -- open_path() will do that for us. */
+ }
}
*dag_node_p = node;
@@ -894,7 +1211,7 @@ svn_fs_fs__node_id(const svn_fs_id_t **i
{
dag_node_t *node;
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
*id_p = svn_fs_fs__id_copy(svn_fs_fs__dag_get_id(node), pool);
}
return SVN_NO_ERROR;
@@ -909,7 +1226,7 @@ svn_fs_fs__node_created_rev(svn_revnum_t
{
dag_node_t *node;
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
return svn_fs_fs__dag_get_revision(revision, node, pool);
}
@@ -924,7 +1241,7 @@ fs_node_created_path(const char **create
{
dag_node_t *node;
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, TRUE, pool));
*created_path = svn_fs_fs__dag_get_created_path(node);
return SVN_NO_ERROR;
@@ -988,7 +1305,7 @@ fs_node_prop(svn_string_t **value_p,
dag_node_t *node;
apr_hash_t *proplist;
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
SVN_ERR(svn_fs_fs__dag_get_proplist(&proplist, node, pool));
*value_p = NULL;
if (proplist)
@@ -1011,7 +1328,7 @@ fs_node_proplist(apr_hash_t **table_p,
apr_hash_t *table;
dag_node_t *node;
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
SVN_ERR(svn_fs_fs__dag_get_proplist(&table, node, pool));
*table_p = table ? table : apr_hash_make(pool);
@@ -1127,8 +1444,8 @@ fs_props_changed(svn_boolean_t *changed_
(SVN_ERR_FS_GENERAL, NULL,
_("Cannot compare property value between two different filesystems"));
- SVN_ERR(get_dag(&node1, root1, path1, pool));
- SVN_ERR(get_dag(&node2, root2, path2, pool));
+ SVN_ERR(get_dag(&node1, root1, path1, TRUE, pool));
+ SVN_ERR(get_dag(&node2, root2, path2, TRUE, pool));
return svn_fs_fs__dag_things_different(changed_p, NULL,
node1, node2);
}
@@ -1141,7 +1458,7 @@ fs_props_changed(svn_boolean_t *changed_
static svn_error_t *
get_root(dag_node_t **node, svn_fs_root_t *root, apr_pool_t *pool)
{
- return get_dag(node, root, "", pool);
+ return get_dag(node, root, "/", TRUE, pool);
}
@@ -1805,7 +2122,7 @@ fs_dir_entries(apr_hash_t **table_p,
dag_node_t *node;
/* Get the entries for this path in the caller's pool. */
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
return svn_fs_fs__dag_dir_entries(table_p, node, pool);
}
@@ -1959,7 +2276,7 @@ copy_helper(svn_fs_root_t *from_root,
_("Copy from mutable tree not currently supported"));
/* Get the NODE for FROM_PATH in FROM_ROOT.*/
- SVN_ERR(get_dag(&from_node, from_root, from_path, pool));
+ SVN_ERR(get_dag(&from_node, from_root, from_path, TRUE, pool));
/* Build up the parent path from TO_PATH in TO_ROOT. If the last
component does not exist, it's not that big a deal. We'll just
@@ -2036,7 +2353,7 @@ copy_helper(svn_fs_root_t *from_root,
pool));
/* Make a record of this modification in the changes table. */
- SVN_ERR(get_dag(&new_node, to_root, to_path, pool));
+ SVN_ERR(get_dag(&new_node, to_root, to_path, TRUE, pool));
SVN_ERR(add_change(to_root->fs, txn_id, to_path,
svn_fs_fs__dag_get_id(new_node), kind, FALSE, FALSE,
svn_fs_fs__dag_node_kind(from_node),
@@ -2139,7 +2456,7 @@ fs_copied_from(svn_revnum_t *rev_p,
{
/* There is no cached entry, look it up the old-fashioned
way. */
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, TRUE, pool));
SVN_ERR(svn_fs_fs__dag_get_copyfrom_rev(©from_rev, node));
SVN_ERR(svn_fs_fs__dag_get_copyfrom_path(©from_path, node));
}
@@ -2211,7 +2528,7 @@ fs_file_length(svn_filesize_t *length_p,
dag_node_t *file;
/* First create a dag_node_t from the root/path pair. */
- SVN_ERR(get_dag(&file, root, path, pool));
+ SVN_ERR(get_dag(&file, root, path, FALSE, pool));
/* Now fetch its length */
return svn_fs_fs__dag_file_length(length_p, file, pool);
@@ -2230,7 +2547,7 @@ fs_file_checksum(svn_checksum_t **checks
{
dag_node_t *file;
- SVN_ERR(get_dag(&file, root, path, pool));
+ SVN_ERR(get_dag(&file, root, path, FALSE, pool));
return svn_fs_fs__dag_file_checksum(checksum, file, kind, pool);
}
@@ -2249,7 +2566,7 @@ fs_file_contents(svn_stream_t **contents
svn_stream_t *file_stream;
/* First create a dag_node_t from the root/path pair. */
- SVN_ERR(get_dag(&node, root, path, pool));
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
/* Then create a readable stream from the dag_node_t. */
SVN_ERR(svn_fs_fs__dag_get_contents(&file_stream, node, pool));
@@ -2261,6 +2578,25 @@ fs_file_contents(svn_stream_t **contents
/* --- End machinery for svn_fs_file_contents() --- */
+/* --- Machinery for svn_fs_try_process_file_contents() --- */
+
+static svn_error_t *
+fs_try_process_file_contents(svn_boolean_t *success,
+ svn_fs_root_t *root,
+ const char *path,
+ svn_fs_process_contents_func_t processor,
+ void* baton,
+ apr_pool_t *pool)
+{
+ dag_node_t *node;
+ SVN_ERR(get_dag(&node, root, path, FALSE, pool));
+
+ return svn_fs_fs__dag_try_process_file_contents(success, node,
+ processor, baton, pool);
+}
+
+/* --- End machinery for svn_fs_try_process_file_contents() --- */
+
/* --- Machinery for svn_fs_apply_textdelta() --- */
@@ -2635,8 +2971,8 @@ fs_contents_changed(svn_boolean_t *chang
(SVN_ERR_FS_GENERAL, NULL, _("'%s' is not a file"), path2);
}
- SVN_ERR(get_dag(&node1, root1, path1, pool));
- SVN_ERR(get_dag(&node2, root2, path2, pool));
+ SVN_ERR(get_dag(&node1, root1, path1, TRUE, pool));
+ SVN_ERR(get_dag(&node2, root2, path2, TRUE, pool));
return svn_fs_fs__dag_things_different(NULL, changed_p,
node1, node2);
}
@@ -2656,10 +2992,10 @@ fs_get_file_delta_stream(svn_txdelta_str
dag_node_t *source_node, *target_node;
if (source_root && source_path)
- SVN_ERR(get_dag(&source_node, source_root, source_path, pool));
+ SVN_ERR(get_dag(&source_node, source_root, source_path, TRUE, pool));
else
source_node = NULL;
- SVN_ERR(get_dag(&target_node, target_root, target_path, pool));
+ SVN_ERR(get_dag(&target_node, target_root, target_path, TRUE, pool));
/* Create a delta stream that turns the source into the target. */
return svn_fs_fs__dag_get_file_delta_stream(stream_p, source_node,
@@ -3143,7 +3479,7 @@ history_prev(void *baton, apr_pool_t *po
SVN_ERR(svn_fs_fs__revision_root(©root_root, fs, copyroot_rev,
pool));
- SVN_ERR(get_dag(&node, copyroot_root, copyroot_path, pool));
+ SVN_ERR(get_dag(&node, copyroot_root, copyroot_path, FALSE, pool));
copy_dst = svn_fs_fs__dag_get_created_path(node);
/* If our current path was the very destination of the copy,
@@ -3340,7 +3676,7 @@ crawl_directory_dag_for_mergeinfo(svn_fs
svn_pool_clear(iterpool);
kid_path = svn_fspath__join(this_path, dirent->name, iterpool);
- SVN_ERR(get_dag(&kid_dag, root, kid_path, iterpool));
+ SVN_ERR(get_dag(&kid_dag, root, kid_path, TRUE, iterpool));
SVN_ERR(svn_fs_fs__dag_has_mergeinfo(&has_mergeinfo, kid_dag));
SVN_ERR(svn_fs_fs__dag_has_descendants_with_mergeinfo(&go_down, kid_dag));
@@ -3522,7 +3858,7 @@ add_descendant_mergeinfo(svn_mergeinfo_c
dag_node_t *this_dag;
svn_boolean_t go_down;
- SVN_ERR(get_dag(&this_dag, root, path, scratch_pool));
+ SVN_ERR(get_dag(&this_dag, root, path, TRUE, scratch_pool));
SVN_ERR(svn_fs_fs__dag_has_descendants_with_mergeinfo(&go_down,
this_dag));
if (go_down)
@@ -3649,6 +3985,7 @@ static root_vtable_t root_vtable = {
fs_file_length,
fs_file_checksum,
fs_file_contents,
+ fs_try_process_file_contents,
fs_make_file,
fs_apply_textdelta,
fs_apply_text,
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.h
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.h?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.h (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_fs_fs/tree.h Sat Oct 6 18:31:28 2012
@@ -23,12 +23,19 @@
#ifndef SVN_LIBSVN_FS_TREE_H
#define SVN_LIBSVN_FS_TREE_H
+#include "fs.h"
+
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
+/* In POOL, create an instance of a DAG node 1st level cache.
+ The POOL will be cleared at regular intervals. */
+fs_fs_dag_cache_t*
+svn_fs_fs__create_dag_cache(apr_pool_t *pool);
+
/* Set *ROOT_P to the root directory of revision REV in filesystem FS.
Allocate the structure in POOL. */
svn_error_t *svn_fs_fs__revision_root(svn_fs_root_t **root_p, svn_fs_t *fs,
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_fs_util/fs-util.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_fs_util/fs-util.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_fs_util/fs-util.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_fs_util/fs-util.c Sat Oct 6 18:31:28 2012
@@ -35,6 +35,40 @@
#include "private/svn_fspath.h"
#include "../libsvn_fs/fs-loader.h"
+svn_boolean_t
+svn_fs__is_canonical_abspath(const char *path)
+{
+ size_t path_len;
+ const char *end;
+
+ /* No PATH? No problem. */
+ if (! path)
+ return TRUE;
+
+ /* Empty PATH? That's just "/". */
+ if (! *path)
+ return FALSE;
+
+ /* No leading slash? Fix that. */
+ if (*path != '/')
+ return FALSE;
+
+ /* check for trailing '/' */
+ path_len = strlen(path);
+ if (path_len == 1)
+ return TRUE;
+ if (path[path_len - 1] == '/')
+ return FALSE;
+
+ /* check for "//" */
+ end = path + path_len - 1;
+ for (; path != end; ++path)
+ if ((path[0] == '/') && (path[1] == '/'))
+ return FALSE;
+
+ return TRUE;
+}
+
const char *
svn_fs__canonicalize_abspath(const char *path, apr_pool_t *pool)
{
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_ra_local/ra_plugin.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_ra_local/ra_plugin.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_ra_local/ra_plugin.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_ra_local/ra_plugin.c Sat Oct 6 18:31:28 2012
@@ -337,7 +337,7 @@ make_reporter(svn_ra_session_t *session,
pool));
/* Build a reporter baton. */
- SVN_ERR(svn_repos_begin_report2(&rbaton,
+ SVN_ERR(svn_repos_begin_report3(&rbaton,
revision,
sess->repos,
sess->fs_path->data,
@@ -351,6 +351,8 @@ make_reporter(svn_ra_session_t *session,
edit_baton,
NULL,
NULL,
+ 1024 * 1024, /* process-local transfers
+ should be fast */
pool));
/* Wrap the report baton given us by the repos layer with our own
@@ -752,6 +754,8 @@ svn_ra_local__get_commit_editor(svn_ra_s
revprop_table = apr_hash_copy(pool, revprop_table);
apr_hash_set(revprop_table, SVN_PROP_REVISION_AUTHOR, APR_HASH_KEY_STRING,
svn_string_create(sess->username, pool));
+ apr_hash_set(revprop_table, SVN_PROP_TXN_CLIENT_COMPAT_VERSION,
+ APR_HASH_KEY_STRING, svn_string_create(SVN_VER_NUMBER, pool));
/* Get the repos commit-editor */
return svn_repos_get_commit_editor5
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/commit.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/commit.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/commit.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/commit.c Sat Oct 6 18:31:28 2012
@@ -2113,7 +2113,7 @@ close_file(void *file_baton,
{
handler->body_delegate = create_put_body;
handler->body_delegate_baton = ctx;
- handler->body_type = "application/vnd.svn-svndiff";
+ handler->body_type = SVN_SVNDIFF_MIME_TYPE;
}
handler->header_delegate = setup_put_headers;
@@ -2269,6 +2269,7 @@ svn_ra_serf__get_commit_editor(svn_ra_se
apr_hash_index_t *hi;
const char *repos_root;
const char *base_relpath;
+ svn_boolean_t supports_ephemeral_props;
ctx = apr_pcalloc(pool, sizeof(*ctx));
@@ -2289,6 +2290,23 @@ svn_ra_serf__get_commit_editor(svn_ra_se
svn_string_dup(val, pool));
}
+ /* If the server supports ephemeral properties, add some carrying
+ interesting version information. */
+ SVN_ERR(svn_ra_serf__has_capability(ra_session, &supports_ephemeral_props,
+ SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS,
+ pool));
+ if (supports_ephemeral_props)
+ {
+ apr_hash_set(ctx->revprop_table,
+ apr_pstrdup(pool, SVN_PROP_TXN_CLIENT_COMPAT_VERSION),
+ APR_HASH_KEY_STRING,
+ svn_string_create(SVN_VER_NUMBER, pool));
+ apr_hash_set(ctx->revprop_table,
+ apr_pstrdup(pool, SVN_PROP_TXN_USER_AGENT),
+ APR_HASH_KEY_STRING,
+ svn_string_create(session->useragent, pool));
+ }
+
ctx->callback = callback;
ctx->callback_baton = callback_baton;
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/options.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/options.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/options.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/options.c Sat Oct 6 18:31:28 2012
@@ -205,6 +205,12 @@ capabilities_headers_iterator_callback(v
SVN_RA_CAPABILITY_INHERITED_PROPS,
APR_HASH_KEY_STRING, capability_yes);
}
+ if (svn_cstring_match_list(SVN_DAV_NS_DAV_SVN_EPHEMERAL_TXNPROPS, vals))
+ {
+ apr_hash_set(session->capabilities,
+ SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS, APR_HASH_KEY_STRING,
+ capability_yes);
+ }
}
/* SVN-specific headers -- if present, server supports HTTP protocol v2 */
@@ -325,6 +331,8 @@ options_response_handler(serf_request_t
APR_HASH_KEY_STRING, capability_no);
apr_hash_set(session->capabilities, SVN_RA_CAPABILITY_INHERITED_PROPS,
APR_HASH_KEY_STRING, capability_no);
+ apr_hash_set(session->capabilities, SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS,
+ APR_HASH_KEY_STRING, capability_no);
/* Then see which ones we can discover. */
serf_bucket_headers_do(hdrs, capabilities_headers_iterator_callback,
@@ -333,7 +341,7 @@ options_response_handler(serf_request_t
opt_ctx->headers_processed = TRUE;
}
- /* Execute the 'real' response handler to XML-parse the repsonse body. */
+ /* Execute the 'real' response handler to XML-parse the response body. */
return opt_ctx->inner_handler(request, response, opt_ctx->inner_baton, pool);
}
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/update.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/update.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/update.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_ra_serf/update.c Sat Oct 6 18:31:28 2012
@@ -933,12 +933,23 @@ handle_fetch(serf_request_t *request,
return error_fetch(request, fetch_ctx, err);
}
- if (val && svn_cstring_casecmp(val, "application/vnd.svn-svndiff") == 0)
+ if (val && svn_cstring_casecmp(val, SVN_SVNDIFF_MIME_TYPE) == 0)
{
fetch_ctx->delta_stream =
svn_txdelta_parse_svndiff(info->textdelta,
info->textdelta_baton,
TRUE, info->editor_pool);
+
+ /* Validate the delta base claimed by the server matches
+ what we asked for! */
+ val = serf_bucket_headers_get(hdrs, SVN_DAV_DELTA_BASE_HEADER);
+ if (val && (strcmp(val, info->delta_base) != 0))
+ {
+ err = svn_error_createf(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
+ _("GET request returned unexpected "
+ "delta base: %s"), val);
+ return error_fetch(request, fetch_ctx, err);
+ }
}
else
{
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/client.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/client.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/client.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/client.c Sat Oct 6 18:31:28 2012
@@ -258,9 +258,10 @@ static svn_error_t *ra_svn_set_path(void
{
ra_svn_reporter_baton_t *b = baton;
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "set-path", "crb(?c)w",
- path, rev, start_empty, lock_token,
- svn_depth_to_word(depth)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_set_path,
+ path, rev, start_empty, lock_token,
+ svn_depth_to_word(depth)));
return SVN_NO_ERROR;
}
@@ -269,7 +270,8 @@ static svn_error_t *ra_svn_delete_path(v
{
ra_svn_reporter_baton_t *b = baton;
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "delete-path", "c", path));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_delete_path, path));
return SVN_NO_ERROR;
}
@@ -283,9 +285,11 @@ static svn_error_t *ra_svn_link_path(voi
{
ra_svn_reporter_baton_t *b = baton;
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "link-path", "ccrb(?c)w",
- path, url, rev, start_empty, lock_token,
- svn_depth_to_word(depth)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_link_path,
+ path, url, rev, start_empty,
+ lock_token,
+ svn_depth_to_word(depth)));
return SVN_NO_ERROR;
}
@@ -294,7 +298,8 @@ static svn_error_t *ra_svn_finish_report
{
ra_svn_reporter_baton_t *b = baton;
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, b->pool, "finish-report", ""));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, b->pool,
+ svn_ra_svn_cmd_finish_report));
SVN_ERR(handle_auth_request(b->sess_baton, b->pool));
SVN_ERR(svn_ra_svn_drive_editor2(b->conn, b->pool, b->editor, b->edit_baton,
NULL, FALSE));
@@ -307,7 +312,8 @@ static svn_error_t *ra_svn_abort_report(
{
ra_svn_reporter_baton_t *b = baton;
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, b->pool, "abort-report", ""));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, b->pool,
+ svn_ra_svn_cmd_abort_report));
return SVN_NO_ERROR;
}
@@ -454,8 +460,9 @@ static void handle_child_process_error(a
|| apr_file_open_stdout(&out_file, pool))
return;
- conn = svn_ra_svn_create_conn2(NULL, in_file, out_file,
- SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, pool);
+ conn = svn_ra_svn_create_conn3(NULL, in_file, out_file,
+ SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, 0,
+ 0, pool);
err = svn_error_wrap_apr(status, _("Error in child process: %s"), desc);
svn_error_clear(svn_ra_svn_write_cmd_failure(conn, pool, err));
svn_error_clear(err);
@@ -522,8 +529,9 @@ static svn_error_t *make_tunnel(const ch
apr_file_inherit_unset(proc->out);
/* Guard against dotfile output to stdout on the server. */
- *conn = svn_ra_svn_create_conn2(NULL, proc->out, proc->in,
- SVN_DELTA_COMPRESSION_LEVEL_DEFAULT, pool);
+ *conn = svn_ra_svn_create_conn3(NULL, proc->out, proc->in,
+ SVN_DELTA_COMPRESSION_LEVEL_DEFAULT,
+ 0, 0, pool);
err = svn_ra_svn_skip_leading_garbage(*conn, pool);
if (err)
return svn_error_quick_wrap(
@@ -586,17 +594,34 @@ static svn_error_t *open_session(svn_ra_
sess->callbacks = callbacks;
sess->callbacks_baton = callbacks_baton;
sess->bytes_read = sess->bytes_written = 0;
-
+
if (tunnel_argv)
SVN_ERR(make_tunnel(tunnel_argv, &conn, pool));
else
{
SVN_ERR(make_connection(uri->hostname, uri->port, &sock, pool));
- conn = svn_ra_svn_create_conn2(sock, NULL, NULL,
+ conn = svn_ra_svn_create_conn3(sock, NULL, NULL,
SVN_DELTA_COMPRESSION_LEVEL_DEFAULT,
- pool);
+ 0, 0, pool);
}
+ /* Build the useragent string, querying the client for any
+ customizations it wishes to note. For historical reasons, we
+ still deliver the hard-coded client version info
+ (SVN_RA_SVN__DEFAULT_USERAGENT) and the customized client string
+ separately in the protocol/capabilities handshake below. But the
+ commit logic wants the combined form for use with the
+ SVN_PROP_TXN_USER_AGENT ephemeral property because that's
+ consistent with our DAV approach. */
+ if (sess->callbacks->get_client_string != NULL)
+ SVN_ERR(sess->callbacks->get_client_string(sess->callbacks_baton,
+ &client_string, pool));
+ if (client_string)
+ sess->useragent = apr_pstrcat(pool, SVN_RA_SVN__DEFAULT_USERAGENT "/",
+ client_string, (char *)NULL);
+ else
+ sess->useragent = SVN_RA_SVN__DEFAULT_USERAGENT;
+
/* Make sure we set conn->session before reading from it,
* because the reader and writer functions expect a non-NULL value. */
sess->conn = conn;
@@ -623,10 +648,6 @@ static svn_error_t *open_session(svn_ra_
return svn_error_create(SVN_ERR_RA_SVN_BAD_VERSION, NULL,
_("Server does not support edit pipelining"));
- if (sess->callbacks->get_client_string != NULL)
- SVN_ERR(sess->callbacks->get_client_string(sess->callbacks_baton,
- &client_string, pool));
-
/* In protocol version 2, we send back our protocol version, our
* capability list, and the URL, and subsequently there is an auth
* request. */
@@ -639,7 +660,9 @@ static svn_error_t *open_session(svn_ra_
SVN_RA_SVN_CAP_DEPTH,
SVN_RA_SVN_CAP_MERGEINFO,
SVN_RA_SVN_CAP_LOG_REVPROPS,
- url, "SVN/" SVN_VER_NUMBER, client_string));
+ url,
+ SVN_RA_SVN__DEFAULT_USERAGENT,
+ client_string));
SVN_ERR(handle_auth_request(sess, pool));
/* This is where the security layer would go into effect if we
@@ -753,7 +776,8 @@ static svn_error_t *ra_svn_reparent(svn_
svn_ra_svn__session_baton_t *new_sess;
apr_uri_t uri;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "reparent", "c", url));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_reparent, url));
err = handle_auth_request(sess, pool);
if (! err)
{
@@ -802,7 +826,8 @@ static svn_error_t *ra_svn_get_latest_re
svn_ra_svn__session_baton_t *sess_baton = session->priv;
svn_ra_svn_conn_t *conn = sess_baton->conn;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "get-latest-rev", ""));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_get_latest_rev));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "r", rev));
return SVN_NO_ERROR;
@@ -815,7 +840,8 @@ static svn_error_t *ra_svn_get_dated_rev
svn_ra_svn__session_baton_t *sess_baton = session->priv;
svn_ra_svn_conn_t *conn = sess_baton->conn;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "get-dated-rev", "c",
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_get_dated_rev,
svn_time_to_cstring(tm, pool)));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "r", rev));
@@ -859,11 +885,14 @@ static svn_error_t *ra_svn_change_rev_pr
}
if (has_atomic_revprops)
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "change-rev-prop2", "rc(?s)(b?s)",
- rev, name, value, dont_care, old_value));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_change_rev_prop2,
+ rev, name, value, dont_care,
+ old_value));
else
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "change-rev-prop", "rc?s",
- rev, name, value));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_change_rev_prop,
+ rev, name, value));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, ""));
@@ -900,7 +929,8 @@ static svn_error_t *ra_svn_rev_proplist(
svn_ra_svn_conn_t *conn = sess_baton->conn;
apr_array_header_t *proplist;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "rev-proplist", "r", rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_rev_proplist, rev));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "l", &proplist));
SVN_ERR(svn_ra_svn_parse_proplist(proplist, pool, props));
@@ -914,7 +944,8 @@ static svn_error_t *ra_svn_rev_prop(svn_
svn_ra_svn__session_baton_t *sess_baton = session->priv;
svn_ra_svn_conn_t *conn = sess_baton->conn;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "rev-prop", "rc", rev, name));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_rev_prop, rev, name));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "(?s)", value));
return SVN_NO_ERROR;
@@ -966,6 +997,21 @@ static svn_error_t *ra_svn_commit(svn_ra
_("Server doesn't support setting arbitrary "
"revision properties during commit"));
+ /* If the server supports ephemeral txnprops, add the one that
+ reports the client's version level string. */
+ if (svn_ra_svn_has_capability(conn, SVN_RA_SVN_CAP_COMMIT_REVPROPS) &&
+ svn_ra_svn_has_capability(conn, SVN_RA_SVN_CAP_EPHEMERAL_TXNPROPS))
+ {
+ apr_hash_set(revprop_table,
+ apr_pstrdup(pool, SVN_PROP_TXN_CLIENT_COMPAT_VERSION),
+ APR_HASH_KEY_STRING,
+ svn_string_create(SVN_VER_NUMBER, pool));
+ apr_hash_set(revprop_table,
+ apr_pstrdup(pool, SVN_PROP_TXN_USER_AGENT),
+ APR_HASH_KEY_STRING,
+ svn_string_create(sess_baton->useragent, pool));
+ }
+
/* Tell the server we're starting the commit.
Send log message here for backwards compatibility with servers
before 1.5. */
@@ -998,6 +1044,7 @@ static svn_error_t *ra_svn_commit(svn_ra
ccb = apr_palloc(pool, sizeof(*ccb));
ccb->sess_baton = sess_baton;
ccb->pool = pool;
+ ccb->new_rev = NULL;
ccb->callback = callback;
ccb->callback_baton = callback_baton;
@@ -1097,8 +1144,9 @@ static svn_error_t *ra_svn_get_file(svn_
svn_checksum_ctx_t *checksum_ctx;
apr_pool_t *iterpool;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "get-file", "c(?r)bb", path,
- rev, (props != NULL), (stream != NULL)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_get_file, path, rev,
+ (props != NULL), (stream != NULL)));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "(?c)rl",
&expected_digest,
@@ -1328,9 +1376,10 @@ static svn_error_t *ra_svn_update(svn_ra
svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
/* Tell the server we want to start an update. */
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "update", "(?r)cbwb", rev, target,
- recurse, svn_depth_to_word(depth),
- send_copyfrom_args));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool, svn_ra_svn_cmd_update,
+ rev, target, recurse,
+ svn_depth_to_word(depth),
+ send_copyfrom_args));
SVN_ERR(handle_auth_request(sess_baton, pool));
/* Fetch a reporter for the caller to drive. The reporter will drive
@@ -1353,9 +1402,9 @@ static svn_error_t *ra_svn_switch(svn_ra
svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
/* Tell the server we want to start a switch. */
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "switch", "(?r)cbcw", rev,
- target, recurse, switch_url,
- svn_depth_to_word(depth)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool, svn_ra_svn_cmd_switch,
+ rev, target, recurse, switch_url,
+ svn_depth_to_word(depth)));
SVN_ERR(handle_auth_request(sess_baton, pool));
/* Fetch a reporter for the caller to drive. The reporter will drive
@@ -1378,9 +1427,9 @@ static svn_error_t *ra_svn_status(svn_ra
svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
/* Tell the server we want to start a status operation. */
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "status", "cb(?r)w",
- target, recurse, rev,
- svn_depth_to_word(depth)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool, svn_ra_svn_cmd_status,
+ target, recurse, rev,
+ svn_depth_to_word(depth)));
SVN_ERR(handle_auth_request(sess_baton, pool));
/* Fetch a reporter for the caller to drive. The reporter will drive
@@ -1406,10 +1455,10 @@ static svn_error_t *ra_svn_diff(svn_ra_s
svn_boolean_t recurse = DEPTH_TO_RECURSE(depth);
/* Tell the server we want to start a diff. */
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "diff", "(?r)cbbcbw", rev,
- target, recurse, ignore_ancestry,
- versus_url, text_deltas,
- svn_depth_to_word(depth)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool, svn_ra_svn_cmd_diff,
+ rev, target, recurse, ignore_ancestry,
+ versus_url, text_deltas,
+ svn_depth_to_word(depth)));
SVN_ERR(handle_auth_request(sess_baton, pool));
/* Fetch a reporter for the caller to drive. The reporter will drive
@@ -1641,7 +1690,9 @@ static svn_error_t *ra_svn_check_path(sv
svn_ra_svn_conn_t *conn = sess_baton->conn;
const char *kind_word;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "check-path", "c(?r)", path, rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_check_path,
+ path, rev));
SVN_ERR(handle_auth_request(sess_baton, pool));
SVN_ERR(svn_ra_svn_read_cmd_response(conn, pool, "w", &kind_word));
*kind = svn_node_kind_from_word(kind_word);
@@ -1670,7 +1721,8 @@ static svn_error_t *ra_svn_stat(svn_ra_s
apr_array_header_t *list = NULL;
svn_dirent_t *the_dirent;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "stat", "c(?r)", path, rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool, svn_ra_svn_cmd_stat,
+ path, rev));
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
N_("'stat' not implemented")));
@@ -1848,9 +1900,10 @@ static svn_error_t *ra_svn_get_file_revs
rev_pool = svn_pool_create(pool);
chunk_pool = svn_pool_create(pool);
- SVN_ERR(svn_ra_svn_write_cmd(sess_baton->conn, pool, "get-file-revs",
- "c(?r)(?r)b", path, start, end,
- include_merged_revisions));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(sess_baton->conn, pool,
+ svn_ra_svn_cmd_get_file_revs,
+ path, start, end,
+ include_merged_revisions));
/* Servers before 1.1 don't support this command. Check for this here. */
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
@@ -1979,9 +2032,10 @@ static svn_error_t *ra_svn_lock_compat(s
path = key;
revnum = val;
- SVN_ERR(svn_ra_svn_write_cmd(conn, iterpool, "lock", "c(?c)b(?r)",
- path, comment,
- steal_lock, *revnum));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, iterpool,
+ svn_ra_svn_cmd_lock,
+ path, comment,
+ steal_lock, *revnum));
/* Servers before 1.2 doesn't support locking. Check this here. */
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
@@ -2044,8 +2098,9 @@ static svn_error_t *ra_svn_unlock_compat
else
token = NULL;
- SVN_ERR(svn_ra_svn_write_cmd(conn, iterpool, "unlock", "c(?c)b",
- path, token, break_lock));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, iterpool,
+ svn_ra_svn_cmd_unlock,
+ path, token, break_lock));
/* Servers before 1.2 don't support locking. Check this here. */
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, iterpool),
@@ -2332,7 +2387,8 @@ static svn_error_t *ra_svn_get_lock(svn_
svn_ra_svn_conn_t* conn = sess->conn;
apr_array_header_t *list;
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "get-lock", "c", path));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_get_lock, path));
/* Servers before 1.2 doesn't support locking. Check this here. */
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
@@ -2384,8 +2440,9 @@ static svn_error_t *ra_svn_get_locks(svn
SVN_ERR(path_relative_to_root(session, &abs_path, full_url, pool));
abs_path = svn_fspath__canonicalize(abs_path, pool);
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "get-locks", "c(w)", path,
- svn_depth_to_word(depth)));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_get_locks, path,
+ svn_depth_to_word(depth)));
/* Servers before 1.2 doesn't support locking. Check this here. */
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
@@ -2442,8 +2499,9 @@ static svn_error_t *ra_svn_replay(svn_ra
{
svn_ra_svn__session_baton_t *sess = session->priv;
- SVN_ERR(svn_ra_svn_write_cmd(sess->conn, pool, "replay", "rrb", revision,
- low_water_mark, send_deltas));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(sess->conn, pool,
+ svn_ra_svn_cmd_replay, revision,
+ low_water_mark, send_deltas));
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
N_("Server doesn't support the replay "
@@ -2472,9 +2530,10 @@ ra_svn_replay_range(svn_ra_session_t *se
svn_revnum_t rev;
svn_boolean_t drive_aborted = FALSE;
- SVN_ERR(svn_ra_svn_write_cmd(sess->conn, pool, "replay-range", "rrrb",
- start_revision, end_revision,
- low_water_mark, send_deltas));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(sess->conn, pool,
+ svn_ra_svn_cmd_replay_range,
+ start_revision, end_revision,
+ low_water_mark, send_deltas));
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess, pool),
N_("Server doesn't support the "
@@ -2551,6 +2610,9 @@ static svn_error_t *ra_svn_has_capabilit
else if (strcmp(capability, SVN_RA_CAPABILITY_INHERITED_PROPS) == 0)
*has = svn_ra_svn_has_capability(sess->conn,
SVN_RA_SVN_CAP_INHERITED_PROPS);
+ else if (strcmp(capability, SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS) == 0)
+ *has = svn_ra_svn_has_capability(sess->conn,
+ SVN_RA_SVN_CAP_EPHEMERAL_TXNPROPS);
else /* Don't know any other capabilities, so error. */
{
return svn_error_createf
@@ -2574,8 +2636,9 @@ ra_svn_get_deleted_rev(svn_ra_session_t
svn_ra_svn_conn_t *conn = sess_baton->conn;
/* Transmit the parameters. */
- SVN_ERR(svn_ra_svn_write_cmd(conn, pool, "get-deleted-rev", "crr",
- path, peg_revision, end_revision));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(conn, pool,
+ svn_ra_svn_cmd_get_deleted_rev,
+ path, peg_revision, end_revision));
/* Servers before 1.6 don't support this command. Check for this here. */
SVN_ERR(handle_unsupported_cmd(handle_auth_request(sess_baton, pool),
Modified: subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/editorp.c
URL: http://svn.apache.org/viewvc/subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/editorp.c?rev=1395146&r1=1395145&r2=1395146&view=diff
==============================================================================
--- subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/editorp.c (original)
+++ subversion/branches/auto-props-sdc/subversion/libsvn_ra_svn/editorp.c Sat Oct 6 18:31:28 2012
@@ -121,13 +121,23 @@ static ra_svn_baton_t *ra_svn_make_baton
/* Check for an early error status report from the consumer. If we
* get one, abort the edit and return the error. */
-static svn_error_t *check_for_error(ra_svn_edit_baton_t *eb, apr_pool_t *pool)
+static svn_error_t *
+check_for_error_internal(ra_svn_edit_baton_t *eb, apr_pool_t *pool)
{
SVN_ERR_ASSERT(!eb->got_status);
+
+ /* reset TX counter */
+ eb->conn->written_since_error_check = 0;
+
+ /* if we weren't asked to always check, wait for at least the next TX */
+ eb->conn->may_check_for_error = eb->conn->error_check_interval == 0;
+
+ /* any incoming data? */
if (svn_ra_svn__input_waiting(eb->conn, pool))
{
eb->got_status = TRUE;
- SVN_ERR(svn_ra_svn_write_cmd(eb->conn, pool, "abort-edit", ""));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(eb->conn, pool,
+ svn_ra_svn_cmd_abort_edit));
SVN_ERR(svn_ra_svn_read_cmd_response(eb->conn, pool, ""));
/* We shouldn't get here if the consumer is doing its job. */
return svn_error_create(SVN_ERR_RA_SVN_MALFORMED_DATA, NULL,
@@ -136,13 +146,22 @@ static svn_error_t *check_for_error(ra_s
return SVN_NO_ERROR;
}
+static svn_error_t *
+check_for_error(ra_svn_edit_baton_t *eb, apr_pool_t *pool)
+{
+ return eb->conn->may_check_for_error
+ ? check_for_error_internal(eb, pool)
+ : SVN_NO_ERROR;
+}
+
static svn_error_t *ra_svn_target_rev(void *edit_baton, svn_revnum_t rev,
apr_pool_t *pool)
{
ra_svn_edit_baton_t *eb = edit_baton;
SVN_ERR(check_for_error(eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(eb->conn, pool, "target-rev", "r", rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(eb->conn, pool,
+ svn_ra_svn_cmd_target_rev, rev));
return SVN_NO_ERROR;
}
@@ -153,8 +172,9 @@ static svn_error_t *ra_svn_open_root(voi
const char *token = make_token('d', eb, pool);
SVN_ERR(check_for_error(eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(eb->conn, pool, "open-root", "(?r)c", rev,
- token));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(eb->conn, pool,
+ svn_ra_svn_cmd_open_root, rev,
+ token));
*root_baton = ra_svn_make_baton(eb->conn, pool, eb, token);
return SVN_NO_ERROR;
}
@@ -165,8 +185,9 @@ static svn_error_t *ra_svn_delete_entry(
ra_svn_baton_t *b = parent_baton;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "delete-entry", "c(?r)c",
- path, rev, b->token));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_delete_entry,
+ path, rev, b->token));
return SVN_NO_ERROR;
}
@@ -181,8 +202,10 @@ static svn_error_t *ra_svn_add_dir(const
SVN_ERR_ASSERT((copy_path && SVN_IS_VALID_REVNUM(copy_rev))
|| (!copy_path && !SVN_IS_VALID_REVNUM(copy_rev)));
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "add-dir", "ccc(?cr)", path,
- b->token, token, copy_path, copy_rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_add_dir, path,
+ b->token, token, copy_path,
+ copy_rev));
*child_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
return SVN_NO_ERROR;
}
@@ -195,8 +218,9 @@ static svn_error_t *ra_svn_open_dir(cons
const char *token = make_token('d', b->eb, pool);
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "open-dir", "ccc(?r)",
- path, b->token, token, rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_open_dir,
+ path, b->token, token, rev));
*child_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
return SVN_NO_ERROR;
}
@@ -208,8 +232,9 @@ static svn_error_t *ra_svn_change_dir_pr
ra_svn_baton_t *b = dir_baton;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "change-dir-prop", "cc(?s)",
- b->token, name, value));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_change_dir_prop,
+ b->token, name, value));
return SVN_NO_ERROR;
}
@@ -218,7 +243,9 @@ static svn_error_t *ra_svn_close_dir(voi
ra_svn_baton_t *b = dir_baton;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "close-dir", "c", b->token));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_close_dir,
+ b->token));
return SVN_NO_ERROR;
}
@@ -233,8 +260,9 @@ static svn_error_t *ra_svn_absent_dir(co
return SVN_NO_ERROR;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "absent-dir", "cc", path,
- b->token));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_absent_dir, path,
+ b->token));
return SVN_NO_ERROR;
}
@@ -251,8 +279,10 @@ static svn_error_t *ra_svn_add_file(cons
SVN_ERR_ASSERT((copy_path && SVN_IS_VALID_REVNUM(copy_rev))
|| (!copy_path && !SVN_IS_VALID_REVNUM(copy_rev)));
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "add-file", "ccc(?cr)", path,
- b->token, token, copy_path, copy_rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_add_file, path,
+ b->token, token, copy_path,
+ copy_rev));
*file_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
return SVN_NO_ERROR;
}
@@ -267,8 +297,9 @@ static svn_error_t *ra_svn_open_file(con
const char *token = make_token('c', b->eb, pool);
SVN_ERR(check_for_error(b->eb, b->pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "open-file", "ccc(?r)",
- path, b->token, token, rev));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_open_file,
+ path, b->token, token, rev));
*file_baton = ra_svn_make_baton(b->conn, pool, b->eb, token);
return SVN_NO_ERROR;
}
@@ -282,8 +313,9 @@ static svn_error_t *ra_svn_svndiff_handl
SVN_ERR(check_for_error(b->eb, b->pool));
str.data = data;
str.len = *len;
- return svn_ra_svn_write_cmd(b->conn, b->pool, "textdelta-chunk", "cs",
- b->token, &str);
+ return svn_ra_svn_write_templated_cmd(b->conn, b->pool,
+ svn_ra_svn_cmd_textdelta_chunk,
+ b->token, &str);
}
static svn_error_t *ra_svn_svndiff_close_handler(void *baton)
@@ -291,8 +323,9 @@ static svn_error_t *ra_svn_svndiff_close
ra_svn_baton_t *b = baton;
SVN_ERR(check_for_error(b->eb, b->pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, b->pool, "textdelta-end", "c",
- b->token));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, b->pool,
+ svn_ra_svn_cmd_textdelta_end,
+ b->token));
return SVN_NO_ERROR;
}
@@ -307,8 +340,9 @@ static svn_error_t *ra_svn_apply_textdel
/* Tell the other side we're starting a text delta. */
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "apply-textdelta", "c(?c)",
- b->token, base_checksum));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_apply_textdelta,
+ b->token, base_checksum));
/* Transform the window stream to an svndiff stream. Reuse the
* file baton for the stream handler, since it has all the
@@ -337,8 +371,9 @@ static svn_error_t *ra_svn_change_file_p
ra_svn_baton_t *b = file_baton;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "change-file-prop", "cc(?s)",
- b->token, name, value));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_change_file_prop,
+ b->token, name, value));
return SVN_NO_ERROR;
}
@@ -349,8 +384,9 @@ static svn_error_t *ra_svn_close_file(vo
ra_svn_baton_t *b = file_baton;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "close-file", "c(?c)",
- b->token, text_checksum));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_close_file,
+ b->token, text_checksum));
return SVN_NO_ERROR;
}
@@ -365,8 +401,9 @@ static svn_error_t *ra_svn_absent_file(c
return SVN_NO_ERROR;
SVN_ERR(check_for_error(b->eb, pool));
- SVN_ERR(svn_ra_svn_write_cmd(b->conn, pool, "absent-file", "cc", path,
- b->token));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(b->conn, pool,
+ svn_ra_svn_cmd_absent_file, path,
+ b->token));
return SVN_NO_ERROR;
}
@@ -377,11 +414,13 @@ static svn_error_t *ra_svn_close_edit(vo
SVN_ERR_ASSERT(!eb->got_status);
eb->got_status = TRUE;
- SVN_ERR(svn_ra_svn_write_cmd(eb->conn, pool, "close-edit", ""));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(eb->conn, pool,
+ svn_ra_svn_cmd_close_edit));
err = svn_ra_svn_read_cmd_response(eb->conn, pool, "");
if (err)
{
- svn_error_clear(svn_ra_svn_write_cmd(eb->conn, pool, "abort-edit", ""));
+ svn_error_clear(svn_ra_svn_write_templated_cmd(eb->conn, pool,
+ svn_ra_svn_cmd_abort_edit));
return err;
}
if (eb->callback)
@@ -395,7 +434,8 @@ static svn_error_t *ra_svn_abort_edit(vo
if (eb->got_status)
return SVN_NO_ERROR;
- SVN_ERR(svn_ra_svn_write_cmd(eb->conn, pool, "abort-edit", ""));
+ SVN_ERR(svn_ra_svn_write_templated_cmd(eb->conn, pool,
+ svn_ra_svn_cmd_abort_edit));
SVN_ERR(svn_ra_svn_read_cmd_response(eb->conn, pool, ""));
return SVN_NO_ERROR;
}
@@ -911,30 +951,47 @@ svn_error_t *svn_ra_svn_drive_editor2(sv
while (!state.done)
{
svn_pool_clear(subpool);
- SVN_ERR(svn_ra_svn_read_tuple(conn, subpool, "wl", &cmd, ¶ms));
- for (i = 0; ra_svn_edit_cmds[i].cmd; i++)
- {
- if (strcmp(cmd, ra_svn_edit_cmds[i].cmd) == 0)
- break;
- }
- if (ra_svn_edit_cmds[i].cmd)
- err = (*ra_svn_edit_cmds[i].handler)(conn, subpool, params, &state);
- else if (strcmp(cmd, "failure") == 0)
+ if (editor)
{
- /* While not really an editor command this can occur when
- reporter->finish_report() fails before the first editor command */
- if (aborted)
- *aborted = TRUE;
- err = svn_ra_svn__handle_failure_status(params, pool);
- return svn_error_compose_create(
- err,
- editor->abort_edit(edit_baton, subpool));
+ SVN_ERR(svn_ra_svn_read_tuple(conn, subpool, "wl", &cmd, ¶ms));
+ for (i = 0; ra_svn_edit_cmds[i].cmd; i++)
+ if (strcmp(cmd, ra_svn_edit_cmds[i].cmd) == 0)
+ break;
+
+ if (ra_svn_edit_cmds[i].cmd)
+ err = (*ra_svn_edit_cmds[i].handler)(conn, subpool, params, &state);
+ else if (strcmp(cmd, "failure") == 0)
+ {
+ /* While not really an editor command this can occur when
+ reporter->finish_report() fails before the first editor
+ command */
+ if (aborted)
+ *aborted = TRUE;
+ err = svn_ra_svn__handle_failure_status(params, pool);
+ return svn_error_compose_create(
+ err,
+ editor->abort_edit(edit_baton, subpool));
+ }
+ else
+ {
+ err = svn_error_createf(SVN_ERR_RA_SVN_UNKNOWN_CMD, NULL,
+ _("Unknown command '%s'"), cmd);
+ err = svn_error_create(SVN_ERR_RA_SVN_CMD_ERR, err, NULL);
+ }
}
else
{
- err = svn_error_createf(SVN_ERR_RA_SVN_UNKNOWN_CMD, NULL,
- _("Unknown command '%s'"), cmd);
- err = svn_error_create(SVN_ERR_RA_SVN_CMD_ERR, err, NULL);
+ const char* command = NULL;
+ SVN_ERR(svn_ra_svn__read_command_only(conn, subpool, &command));
+ if (strcmp(command, "close-edit") == 0)
+ {
+ state.done = TRUE;
+ if (aborted)
+ *aborted = FALSE;
+ err = svn_ra_svn_write_cmd_response(conn, pool, "");
+ }
+ else
+ err = NULL;
}
if (err && err->apr_err == SVN_ERR_RA_SVN_CMD_ERR)
@@ -944,7 +1001,8 @@ svn_error_t *svn_ra_svn_drive_editor2(sv
if (!state.done)
{
/* Abort the edit and use non-blocking I/O to write the error. */
- svn_error_clear(editor->abort_edit(edit_baton, subpool));
+ if (editor)
+ svn_error_clear(editor->abort_edit(edit_baton, subpool));
svn_ra_svn__set_block_handler(conn, blocked_write, &state);
}
write_err = svn_ra_svn_write_cmd_failure(