You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@subversion.apache.org by ju...@apache.org on 2013/01/06 03:33:39 UTC
svn commit: r1429457 [13/21] - in /subversion/branches/tree-read-api: ./
build/ build/ac-macros/ build/generator/templates/ build/win32/
contrib/server-side/svncutter/ doc/ subversion/bindings/cxxhl/include/
subversion/bindings/cxxhl/include/svncxxhl/ ...
Modified: subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_update_move.c
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_update_move.c?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_update_move.c (original)
+++ subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_update_move.c Sun Jan 6 02:33:34 2013
@@ -23,13 +23,50 @@
/* This editor is used during resolution of tree conflicts.
*
- * An operation such as update can produce incoming changes for a
- * locally moved-away subtree, causing a tree-conflict to be flagged.
+ * When an update (or switch) produces incoming changes for a locally
+ * moved-away subtree, it updates the base nodes of the moved-away tree
+ * and flags a tree-conflict on the moved-away root node.
* This editor transfers these changes from the moved-away part of the
* working copy to the corresponding moved-here part of the working copy.
*
* Both the driver and receiver components of the editor are implemented
* in this file.
+ *
+ * The driver sees two NODES trees: the move source tree and the move
+ * destination tree. When the move is initially made these trees are
+ * equivalent, the destination is a copy of the source. The source is
+ * a single-op-depth, single-revision, deleted layer [1] and the
+ * destination has an equivalent single-op-depth, single-revision
+ * layer. The destination may have additional higher op-depths
+ * representing adds, deletes, moves within the move destination. [2]
+ *
+ * After the intial move an update, or this editor for trees that have
+ * been moved more than once, has modified the NODES in the move
+ * source, and introduced a tree-conflict since the source and
+ * destination trees are no longer equivalent. The source is a
+ * different revision and may have text, property and tree changes
+ * compared to the destination. The driver will compare the two NODES
+ * trees and drive an editor to change the destination tree so that it
+ * once again matches the source tree. Changes made to the
+ * destination NODES tree to achieve this match will be merged into
+ * the working files/directories.
+ *
+ * The whole drive occurs as one single wc.db transaction. At the end
+ * of the transaction the destination NODES table should have a layer
+ * that is equivalent to the source NODES layer, there should be
+ * workqueue items to make any required changes to working
+ * files/directories in the move destination, and there should be
+ * tree-conflicts in the move destination where it was not possible to
+ * update the working files/directories.
+ *
+ * [1] The move source tree is single-revision because we currently do
+ * not allow a mixed-rev move, and therefore it is single op-depth
+ * regardless whether it is a base layer or a nested move.
+ *
+ * [2] The source tree also may have additional higher op-depths,
+ * representing a replacement, but this editor only reads from the
+ * single-op-depth layer of it, and makes no changes of any kind
+ * within the source tree.
*/
#define SVN_WC__I_AM_WC_DB
@@ -38,7 +75,9 @@
#include "svn_dirent_uri.h"
#include "svn_editor.h"
#include "svn_error.h"
+#include "svn_hash.h"
#include "svn_wc.h"
+#include "svn_props.h"
#include "svn_pools.h"
#include "private/svn_skel.h"
@@ -46,6 +85,7 @@
#include "private/svn_wc_private.h"
#include "wc.h"
+#include "props.h"
#include "wc_db_private.h"
#include "wc-queries.h"
#include "conflicts.h"
@@ -53,14 +93,22 @@
/*
* Receiver code.
+ *
+ * The receiver is an editor that, when driven with a certain change, will
+ * merge the edits into the working/actual state of the move destination
+ * at MOVE_ROOT_DST_RELPATH (in struct tc_editor_baton), perhaps raising
+ * conflicts if necessary.
+ *
+ * The receiver should not need to refer directly to the move source, as
+ * the driver should provide all relevant information about the change to
+ * be made at the move destination.
*/
struct tc_editor_baton {
- const char *move_root_src_relpath;
- const char *move_root_dst_relpath;
+ svn_skel_t **work_items;
svn_wc__db_t *db;
svn_wc__db_wcroot_t *wcroot;
- svn_skel_t **work_items;
+ const char *move_root_dst_relpath;
svn_wc_conflict_version_t *old_version;
svn_wc_conflict_version_t *new_version;
svn_wc_notify_func2_t notify_func;
@@ -68,6 +116,119 @@ struct tc_editor_baton {
apr_pool_t *result_pool;
};
+/* If LOCAL_RELPATH is shadowed then raise a tree-conflict on the root
+ of the obstruction if such a tree-conflict does not already exist. */
+static svn_error_t *
+check_tree_conflict(svn_boolean_t *is_conflicted,
+ struct tc_editor_baton *b,
+ const char *local_relpath,
+ svn_node_kind_t kind,
+ apr_pool_t *scratch_pool)
+{
+ svn_sqlite__stmt_t *stmt;
+ svn_boolean_t have_row;
+ int dst_op_depth = relpath_depth(b->move_root_dst_relpath);
+ int op_depth;
+ const char *conflict_root_relpath = local_relpath;
+ const char *moved_to_relpath;
+ svn_skel_t *conflict;
+ svn_wc_conflict_version_t *version;
+
+ SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
+ STMT_SELECT_LOWEST_WORKING_NODE));
+ SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, local_relpath,
+ dst_op_depth));
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ if (have_row)
+ op_depth = svn_sqlite__column_int(stmt, 0);
+ SVN_ERR(svn_sqlite__reset(stmt));
+
+ if (!have_row)
+ {
+ *is_conflicted = FALSE;
+ return SVN_NO_ERROR;
+ }
+
+ *is_conflicted = TRUE;
+
+ while (relpath_depth(conflict_root_relpath) > op_depth)
+ conflict_root_relpath = svn_relpath_dirname(conflict_root_relpath,
+ scratch_pool);
+
+ SVN_ERR(svn_wc__db_read_conflict_internal(&conflict, b->wcroot,
+ conflict_root_relpath,
+ scratch_pool, scratch_pool));
+
+ if (conflict)
+ /* ### TODO: check this is the right sort of tree-conflict? */
+ return SVN_NO_ERROR;
+
+ SVN_ERR(svn_wc__db_scan_deletion_internal(NULL, &moved_to_relpath,
+ NULL, NULL,
+ b->wcroot, conflict_root_relpath,
+ scratch_pool, scratch_pool));
+
+ conflict = svn_wc__conflict_skel_create(scratch_pool);
+ SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+ conflict, NULL,
+ svn_dirent_join(b->wcroot->abspath, conflict_root_relpath,
+ scratch_pool),
+ (moved_to_relpath
+ ? svn_wc_conflict_reason_moved_away
+ : svn_wc_conflict_reason_deleted),
+ svn_wc_conflict_action_edit,
+ scratch_pool,
+ scratch_pool));
+
+ version = svn_wc_conflict_version_create2(b->old_version->repos_url,
+ b->old_version->repos_uuid,
+ local_relpath,
+ b->old_version->peg_rev,
+ kind,
+ scratch_pool);
+
+ SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict, version,
+ scratch_pool, scratch_pool));
+ SVN_ERR(svn_wc__db_mark_conflict_internal(b->wcroot, conflict_root_relpath,
+ conflict, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+/* Mark a unversioned-add tree-conflict on RELPATH. */
+static svn_error_t *
+mark_unversioned_add_conflict(struct tc_editor_baton *b,
+ const char *relpath,
+ svn_node_kind_t kind,
+ apr_pool_t *scratch_pool)
+{
+ svn_skel_t *conflict = svn_wc__conflict_skel_create(scratch_pool);
+ svn_wc_conflict_version_t *version;
+
+ SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(
+ conflict, NULL,
+ svn_dirent_join(b->wcroot->abspath, relpath,
+ scratch_pool),
+ svn_wc_conflict_reason_unversioned,
+ svn_wc_conflict_action_add,
+ scratch_pool,
+ scratch_pool));
+
+ version = svn_wc_conflict_version_create2(b->old_version->repos_url,
+ b->old_version->repos_uuid,
+ relpath,
+ b->old_version->peg_rev,
+ kind,
+ scratch_pool);
+
+ SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict, version,
+ scratch_pool, scratch_pool));
+ SVN_ERR(svn_wc__db_mark_conflict_internal(b->wcroot, relpath,
+ conflict, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
static svn_error_t *
tc_editor_add_directory(void *baton,
const char *relpath,
@@ -76,7 +237,48 @@ tc_editor_add_directory(void *baton,
svn_revnum_t replaces_rev,
apr_pool_t *scratch_pool)
{
- return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
+ struct tc_editor_baton *b = baton;
+ int op_depth = relpath_depth(b->move_root_dst_relpath);
+ svn_boolean_t is_conflicted;
+ const char *abspath;
+ svn_node_kind_t kind;
+ svn_skel_t *work_item;
+
+ /* Update NODES, only the bits not covered by the later call to
+ replace_moved_layer. */
+ SVN_ERR(svn_wc__db_extend_parent_delete(b->wcroot, relpath, svn_kind_dir,
+ op_depth, scratch_pool));
+
+ /* Check for NODES tree-conflict. */
+ SVN_ERR(check_tree_conflict(&is_conflicted, b, relpath, svn_node_dir,
+ scratch_pool));
+ if (is_conflicted)
+ return SVN_NO_ERROR;
+
+ /* Check for unversioned tree-conflict */
+ abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
+ SVN_ERR(svn_io_check_path(abspath, &kind, scratch_pool));
+
+ switch (kind)
+ {
+ case svn_node_file:
+ default:
+ SVN_ERR(mark_unversioned_add_conflict(b, relpath, svn_node_dir,
+ scratch_pool));
+ break;
+
+ case svn_node_none:
+ SVN_ERR(svn_wc__wq_build_dir_install(&work_item, b->db, abspath,
+ scratch_pool, b->result_pool));
+
+ SVN_ERR(svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_item,
+ scratch_pool));
+ /* Fall through */
+ case svn_node_dir:
+ break;
+ }
+
+ return SVN_NO_ERROR;
}
static svn_error_t *
@@ -88,7 +290,49 @@ tc_editor_add_file(void *baton,
svn_revnum_t replaces_rev,
apr_pool_t *scratch_pool)
{
- return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
+ struct tc_editor_baton *b = baton;
+ int op_depth = relpath_depth(b->move_root_dst_relpath);
+ svn_boolean_t is_conflicted;
+ const char *abspath;
+ svn_node_kind_t kind;
+ svn_skel_t *work_item;
+
+ /* Update NODES, only the bits not covered by the later call to
+ replace_moved_layer. */
+ SVN_ERR(svn_wc__db_extend_parent_delete(b->wcroot, relpath, svn_kind_file,
+ op_depth, scratch_pool));
+
+ /* Check for NODES tree-conflict. */
+ SVN_ERR(check_tree_conflict(&is_conflicted, b, relpath, svn_node_file,
+ scratch_pool));
+ if (is_conflicted)
+ return SVN_NO_ERROR;
+
+ /* Check for unversioned tree-conflict */
+ abspath = svn_dirent_join(b->wcroot->abspath, relpath, scratch_pool);
+ SVN_ERR(svn_io_check_path(abspath, &kind, scratch_pool));
+
+ if (kind != svn_node_none)
+ {
+ SVN_ERR(mark_unversioned_add_conflict(b, relpath, svn_node_file,
+ scratch_pool));
+ return SVN_NO_ERROR;
+ }
+
+ /* Update working file. */
+ SVN_ERR(svn_wc__wq_build_file_install(&work_item, b->db,
+ svn_dirent_join(b->wcroot->abspath,
+ relpath,
+ scratch_pool),
+ NULL,
+ FALSE /* FIXME: use_commit_times? */,
+ TRUE /* record_file_info */,
+ scratch_pool, b->result_pool));
+
+ SVN_ERR(svn_wc__db_wq_add(b->db, b->wcroot->abspath, work_item,
+ scratch_pool));
+
+ return SVN_NO_ERROR;
}
static svn_error_t *
@@ -112,72 +356,199 @@ tc_editor_add_absent(void *baton,
return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
}
+/* All the info we need about one version of a working node. */
+typedef struct working_node_version_t
+{
+ svn_wc_conflict_version_t *location_and_kind;
+ apr_hash_t *props;
+ const svn_checksum_t *checksum; /* for files only */
+} working_node_version_t;
+
+static svn_error_t *
+create_conflict_markers(svn_skel_t **work_items,
+ const char *local_abspath,
+ svn_wc__db_t *db,
+ const char *repos_relpath,
+ svn_skel_t *conflict_skel,
+ const working_node_version_t *old_version,
+ const working_node_version_t *new_version,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
+{
+ svn_skel_t *work_item;
+ svn_wc_conflict_version_t *original_version;
+
+ original_version = svn_wc_conflict_version_dup(
+ old_version->location_and_kind, scratch_pool);
+ original_version->path_in_repos = repos_relpath;
+ original_version->node_kind = svn_node_file;
+ SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_skel,
+ original_version,
+ scratch_pool,
+ scratch_pool));
+ /* According to this func's doc string, it is "Currently only used for
+ * property conflicts as text conflict markers are just in-wc files." */
+ SVN_ERR(svn_wc__conflict_create_markers(&work_item, db,
+ local_abspath,
+ conflict_skel,
+ scratch_pool,
+ scratch_pool));
+ *work_items = svn_wc__wq_merge(*work_items, work_item, result_pool);
+
+ return SVN_NO_ERROR;
+}
+
static svn_error_t *
-tc_editor_alter_directory(void *baton,
- const char *relpath,
- svn_revnum_t revision,
- const apr_array_header_t *children,
- apr_hash_t *props,
- apr_pool_t *scratch_pool)
+update_working_props(svn_wc_notify_state_t *prop_state,
+ svn_skel_t **conflict_skel,
+ apr_array_header_t **propchanges,
+ apr_hash_t **actual_props,
+ svn_wc__db_t *db,
+ const char *local_abspath,
+ const struct working_node_version_t *old_version,
+ const struct working_node_version_t *new_version,
+ apr_pool_t *result_pool,
+ apr_pool_t *scratch_pool)
{
- return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
+ apr_hash_t *new_actual_props;
+
+ /*
+ * Run a 3-way prop merge to update the props, using the pre-update
+ * props as the merge base, the post-update props as the
+ * merge-left version, and the current props of the
+ * moved-here working file as the merge-right version.
+ */
+ SVN_ERR(svn_wc__db_read_props(actual_props,
+ db, local_abspath,
+ result_pool, scratch_pool));
+ SVN_ERR(svn_prop_diffs(propchanges, new_version->props, old_version->props,
+ result_pool));
+ SVN_ERR(svn_wc__merge_props(conflict_skel, prop_state,
+ &new_actual_props,
+ db, local_abspath,
+ old_version->props, old_version->props,
+ *actual_props, *propchanges,
+ result_pool, scratch_pool));
+ /* Install the new actual props. Don't set the conflict_skel yet, because
+ we might need to add a text conflict to it as well. */
+ SVN_ERR(svn_wc__db_op_set_props(db, local_abspath,
+ new_actual_props,
+ svn_wc__has_magic_property(*propchanges),
+ NULL/*conflict_skel*/, NULL/*work_items*/,
+ scratch_pool));
+
+ return SVN_NO_ERROR;
}
-/* Check whether the node at LOCAL_RELPATH in the working copy at WCROOT
- * is shadowed by some node at a higher op depth than EXPECTED_OP_DEPTH. */
static svn_error_t *
-check_shadowed_node(svn_boolean_t *is_shadowed,
- int expected_op_depth,
- const char *local_relpath,
- svn_wc__db_wcroot_t *wcroot)
+tc_editor_alter_directory(void *baton,
+ const char *dst_relpath,
+ svn_revnum_t expected_move_dst_revision,
+ const apr_array_header_t *children,
+ apr_hash_t *new_props,
+ apr_pool_t *scratch_pool)
{
- svn_sqlite__stmt_t *stmt;
- svn_boolean_t have_row;
+ struct tc_editor_baton *b = baton;
+ const char *move_dst_repos_relpath;
+ svn_revnum_t move_dst_revision;
+ svn_kind_t move_dst_kind;
+ working_node_version_t old_version, new_version;
+ svn_wc__db_status_t status;
+ svn_boolean_t is_conflicted;
- SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
- STMT_SELECT_WORKING_NODE));
- SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id, local_relpath));
- SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ SVN_ERR_ASSERT(expected_move_dst_revision == b->old_version->peg_rev);
- while (have_row)
+ SVN_ERR(check_tree_conflict(&is_conflicted, b, dst_relpath, svn_node_dir,
+ scratch_pool));
+ if (is_conflicted)
+ return SVN_NO_ERROR;
+
+ /* Get kind, revision, and checksum of the moved-here node. */
+ SVN_ERR(svn_wc__db_depth_get_info(&status, &move_dst_kind, &move_dst_revision,
+ &move_dst_repos_relpath, NULL, NULL, NULL,
+ NULL, NULL, &old_version.checksum, NULL,
+ NULL, &old_version.props,
+ b->wcroot, dst_relpath,
+ relpath_depth(b->move_root_dst_relpath),
+ scratch_pool, scratch_pool));
+ SVN_ERR_ASSERT(move_dst_revision == expected_move_dst_revision);
+ SVN_ERR_ASSERT(move_dst_kind == svn_kind_dir);
+
+ old_version.location_and_kind = b->old_version;
+ new_version.location_and_kind = b->new_version;
+
+ new_version.checksum = NULL; /* not a file */
+ new_version.props = new_props ? new_props : old_version.props;
+
+ if (new_props)
{
- int op_depth = svn_sqlite__column_int(stmt, 0);
+ const char *dst_abspath = svn_dirent_join(b->wcroot->abspath,
+ dst_relpath,
+ scratch_pool);
+ svn_wc_notify_state_t prop_state;
+ svn_skel_t *conflict_skel = NULL;
+ apr_hash_t *actual_props;
+ apr_array_header_t *propchanges;
+
+ SVN_ERR(update_working_props(&prop_state, &conflict_skel,
+ &propchanges, &actual_props,
+ b->db, dst_abspath,
+ &old_version, &new_version,
+ b->result_pool, scratch_pool));
- if (op_depth > expected_op_depth)
+ if (conflict_skel)
{
- *is_shadowed = TRUE;
- SVN_ERR(svn_sqlite__reset(stmt));
-
- return SVN_NO_ERROR;
+ SVN_ERR(create_conflict_markers(b->work_items, dst_abspath,
+ b->db, move_dst_repos_relpath,
+ conflict_skel,
+ &old_version, &new_version,
+ b->result_pool, scratch_pool));
+ SVN_ERR(svn_wc__db_mark_conflict_internal(b->wcroot, dst_relpath,
+ conflict_skel,
+ scratch_pool));
}
- SVN_ERR(svn_sqlite__step(&have_row, stmt));
- }
+ if (b->notify_func)
+ {
+ svn_wc_notify_t *notify;
- *is_shadowed = FALSE;
- SVN_ERR(svn_sqlite__reset(stmt));
+ notify = svn_wc_create_notify(dst_abspath,
+ svn_wc_notify_update_update,
+ scratch_pool);
+ notify->kind = svn_node_dir;
+ notify->content_state = svn_wc_notify_state_inapplicable;
+ notify->prop_state = prop_state;
+ notify->old_revision = b->old_version->peg_rev;
+ notify->revision = b->new_version->peg_rev;
+ b->notify_func(b->notify_baton, notify, scratch_pool);
+ }
+ }
return SVN_NO_ERROR;
}
-/* Update text and prop contents of the working file at DST_RELPATH
- * in the working copy at WCROOT, from OLD_VERSION to NEW_VERSION,
- * based on pristine contents identified by MOVE_SRC_CHECKSUM and
- * MOVE_DST_CHECKSUM. MOVE_DST_REPOS_RELPATH is the repository path
- * the node at DST_RELPATH would be committed to.
- * Use working copy database DB.
+
+/* Merge the difference between OLD_VERSION and NEW_VERSION into
+ * the working file at LOCAL_RELPATH.
+ *
+ * The term 'old' refers to the pre-update state, which is the state of
+ * (some layer of) LOCAL_RELPATH while this function runs; and 'new'
+ * refers to the post-update state, as found at the (base layer of) the
+ * move source path while this function runs.
+ *
+ * LOCAL_RELPATH is a file in the working copy at WCROOT in DB, and
+ * REPOS_RELPATH is the repository path it would be committed to.
+ *
* Use NOTIFY_FUNC and NOTIFY_BATON for notifications.
- * Add any required work items to *WORK_ITEMS, allocated in RESULT_POOL.
+ * Set *WORK_ITEMS to any required work items, allocated in RESULT_POOL.
* Use SCRATCH_POOL for temporary allocations. */
static svn_error_t *
update_working_file(svn_skel_t **work_items,
- const char *dst_relpath,
- const char *move_dst_repos_relpath,
- const svn_checksum_t *move_src_checksum,
- const svn_checksum_t *move_dst_checksum,
- svn_wc_conflict_version_t *old_version,
- svn_wc_conflict_version_t *new_version,
+ const char *local_relpath,
+ const char *repos_relpath,
+ const working_node_version_t *old_version,
+ const working_node_version_t *new_version,
svn_wc__db_wcroot_t *wcroot,
svn_wc__db_t *db,
svn_wc_notify_func2_t notify_func,
@@ -185,15 +556,31 @@ update_working_file(svn_skel_t **work_it
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
- const char *moved_to_abspath = svn_dirent_join(wcroot->abspath,
- dst_relpath,
- scratch_pool);
- const char *pre_update_pristine_abspath;
- const char *post_update_pristine_abspath;
- svn_skel_t *conflict_skel;
+ const char *local_abspath = svn_dirent_join(wcroot->abspath,
+ local_relpath,
+ scratch_pool);
+ const char *old_pristine_abspath;
+ const char *new_pristine_abspath;
+ svn_skel_t *conflict_skel = NULL;
+ apr_hash_t *actual_props;
+ apr_array_header_t *propchanges;
enum svn_wc_merge_outcome_t merge_outcome;
- svn_wc_notify_state_t content_state;
- svn_wc_notify_t *notify;
+ svn_wc_notify_state_t prop_state, content_state;
+
+ SVN_ERR(update_working_props(&prop_state, &conflict_skel, &propchanges,
+ &actual_props, db, local_abspath,
+ old_version, new_version,
+ result_pool, scratch_pool));
+
+ /* If there are any conflicts to be stored, convert them into work items
+ * too. */
+ if (conflict_skel)
+ {
+ SVN_ERR(create_conflict_markers(work_items, local_abspath, db,
+ repos_relpath, conflict_skel,
+ old_version, new_version,
+ result_pool, scratch_pool));
+ }
/*
* Run a 3-way merge to update the file, using the pre-update
@@ -201,51 +588,44 @@ update_working_file(svn_skel_t **work_it
* text as the merge-left version, and the current content of the
* moved-here working file as the merge-right version.
*/
- SVN_ERR(svn_wc__db_pristine_get_path(&pre_update_pristine_abspath,
+ SVN_ERR(svn_wc__db_pristine_get_path(&old_pristine_abspath,
db, wcroot->abspath,
- move_dst_checksum,
+ old_version->checksum,
scratch_pool, scratch_pool));
- SVN_ERR(svn_wc__db_pristine_get_path(&post_update_pristine_abspath,
+ SVN_ERR(svn_wc__db_pristine_get_path(&new_pristine_abspath,
db, wcroot->abspath,
- move_src_checksum,
+ new_version->checksum,
scratch_pool, scratch_pool));
SVN_ERR(svn_wc__internal_merge(work_items, &conflict_skel,
&merge_outcome, db,
- pre_update_pristine_abspath,
- post_update_pristine_abspath,
- moved_to_abspath,
- moved_to_abspath,
+ old_pristine_abspath,
+ new_pristine_abspath,
+ local_abspath,
+ local_abspath,
NULL, NULL, NULL, /* diff labels */
- NULL, /* actual props */
+ actual_props,
FALSE, /* dry-run */
NULL, /* diff3-cmd */
NULL, /* merge options */
- NULL, /* prop_diff */
+ propchanges,
NULL, NULL, /* cancel_func + baton */
result_pool, scratch_pool));
- if (merge_outcome == svn_wc_merge_conflict)
+ /* If there are any conflicts to be stored, convert them into work items
+ * too. */
+ if (conflict_skel)
{
- svn_skel_t *work_item;
- svn_wc_conflict_version_t *original_version;
+ SVN_ERR(create_conflict_markers(work_items, local_abspath, db,
+ repos_relpath, conflict_skel,
+ old_version, new_version,
+ result_pool, scratch_pool));
+ SVN_ERR(svn_wc__db_mark_conflict_internal(wcroot, local_relpath,
+ conflict_skel,
+ scratch_pool));
+ }
- if (conflict_skel)
- {
- original_version = svn_wc_conflict_version_dup(old_version,
- scratch_pool);
- original_version->path_in_repos = move_dst_repos_relpath;
- original_version->node_kind = svn_node_file;
- SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_skel,
- original_version,
- scratch_pool,
- scratch_pool));
- SVN_ERR(svn_wc__conflict_create_markers(&work_item, db,
- moved_to_abspath,
- conflict_skel,
- scratch_pool,
- scratch_pool));
- *work_items = svn_wc__wq_merge(*work_items, work_item, result_pool);
- }
+ if (merge_outcome == svn_wc_merge_conflict)
+ {
content_state = svn_wc_notify_state_conflicted;
}
else
@@ -253,7 +633,7 @@ update_working_file(svn_skel_t **work_it
svn_boolean_t is_locally_modified;
SVN_ERR(svn_wc__internal_file_modified_p(&is_locally_modified,
- db, moved_to_abspath,
+ db, local_abspath,
FALSE /* exact_comparison */,
scratch_pool));
if (is_locally_modified)
@@ -262,70 +642,83 @@ update_working_file(svn_skel_t **work_it
content_state = svn_wc_notify_state_changed;
}
- notify = svn_wc_create_notify(moved_to_abspath,
- svn_wc_notify_update_update,
- scratch_pool);
- notify->kind = svn_node_file;
- notify->content_state = content_state;
- notify->prop_state = svn_wc_notify_state_unknown; /* ### TODO */
- notify->old_revision = old_version->peg_rev;
- notify->revision = new_version->peg_rev;
- notify_func(notify_baton, notify, scratch_pool);
+ if (notify_func)
+ {
+ svn_wc_notify_t *notify;
+
+ notify = svn_wc_create_notify(local_abspath,
+ svn_wc_notify_update_update,
+ scratch_pool);
+ notify->kind = svn_node_file;
+ notify->content_state = content_state;
+ notify->prop_state = prop_state;
+ notify->old_revision = old_version->location_and_kind->peg_rev;
+ notify->revision = new_version->location_and_kind->peg_rev;
+ notify_func(notify_baton, notify, scratch_pool);
+ }
return SVN_NO_ERROR;
}
+/* Edit the file found at the move destination, which is initially at
+ * the old state. Merge the changes into the "working"/"actual" file.
+ */
static svn_error_t *
tc_editor_alter_file(void *baton,
const char *dst_relpath,
svn_revnum_t expected_move_dst_revision,
- apr_hash_t *props,
- const svn_checksum_t *move_src_checksum,
- svn_stream_t *post_update_contents,
+ apr_hash_t *new_props,
+ const svn_checksum_t *new_checksum,
+ svn_stream_t *new_contents,
apr_pool_t *scratch_pool)
{
struct tc_editor_baton *b = baton;
- const svn_checksum_t *move_dst_checksum;
const char *move_dst_repos_relpath;
svn_revnum_t move_dst_revision;
svn_kind_t move_dst_kind;
+ working_node_version_t old_version, new_version;
+ svn_boolean_t is_conflicted;
+
+ SVN_ERR(check_tree_conflict(&is_conflicted, b, dst_relpath, svn_node_file,
+ scratch_pool));
+ if (is_conflicted)
+ return SVN_NO_ERROR;
/* Get kind, revision, and checksum of the moved-here node. */
SVN_ERR(svn_wc__db_depth_get_info(NULL, &move_dst_kind, &move_dst_revision,
&move_dst_repos_relpath, NULL, NULL, NULL,
- NULL, NULL, &move_dst_checksum, NULL,
- NULL, b->wcroot, dst_relpath,
+ NULL, NULL, &old_version.checksum, NULL,
+ NULL, &old_version.props,
+ b->wcroot, dst_relpath,
relpath_depth(b->move_root_dst_relpath),
scratch_pool, scratch_pool));
SVN_ERR_ASSERT(move_dst_revision == expected_move_dst_revision);
SVN_ERR_ASSERT(move_dst_kind == svn_kind_file);
+ old_version.location_and_kind = b->old_version;
+ new_version.location_and_kind = b->new_version;
+
+ /* If new checksum is null that means no change; similarly props. */
+ new_version.checksum = new_checksum ? new_checksum : old_version.checksum;
+ new_version.props = new_props ? new_props : old_version.props;
+
/* ### TODO update revision etc. in NODES table */
/* Update file and prop contents if the update has changed them. */
- if (!svn_checksum_match(move_src_checksum, move_dst_checksum)
+ if (!svn_checksum_match(new_checksum, old_version.checksum)
/* ### || props have changed */)
{
- svn_boolean_t is_shadowed;
+ svn_skel_t *work_item;
- /* If the node is shadowed by a higher layer, we need to flag a
- * tree conflict and must not touch the working file. */
- SVN_ERR(check_shadowed_node(&is_shadowed,
- relpath_depth(b->move_root_dst_relpath),
- dst_relpath, b->wcroot));
- if (is_shadowed)
- {
- /* ### TODO flag tree conflict */
- }
- else
- SVN_ERR(update_working_file(b->work_items, dst_relpath,
- move_dst_repos_relpath,
- move_src_checksum, move_dst_checksum,
- b->old_version, b->new_version,
- b->wcroot, b->db,
- b->notify_func, b->notify_baton,
- b->result_pool, scratch_pool));
+ SVN_ERR(update_working_file(&work_item, dst_relpath,
+ move_dst_repos_relpath,
+ &old_version, &new_version,
+ b->wcroot, b->db,
+ b->notify_func, b->notify_baton,
+ b->result_pool, scratch_pool));
+ *b->work_items = svn_wc__wq_merge(*b->work_items, work_item,
+ b->result_pool);
}
return SVN_NO_ERROR;
@@ -348,7 +741,23 @@ tc_editor_delete(void *baton,
svn_revnum_t revision,
apr_pool_t *scratch_pool)
{
- return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL, NULL);
+ struct tc_editor_baton *b = baton;
+ svn_sqlite__stmt_t *stmt;
+ int op_depth = relpath_depth(b->move_root_dst_relpath);
+
+ /* Deleting the ROWS is valid so long as we update the parent before
+ committing the transaction. */
+ SVN_ERR(svn_sqlite__get_statement(&stmt, b->wcroot->sdb,
+ STMT_DELETE_WORKING_OP_DEPTH));
+ SVN_ERR(svn_sqlite__bindf(stmt, "isd", b->wcroot->wc_id, relpath, op_depth));
+ SVN_ERR(svn_sqlite__step_done(stmt));
+
+ /* Retract any base-delete. */
+ SVN_ERR(svn_wc__db_retract_parent_delete(b->wcroot, relpath, op_depth,
+ scratch_pool));
+
+ /* ### TODO check for, and flag, tree conflict */
+ return SVN_NO_ERROR;
}
static svn_error_t *
@@ -387,18 +796,22 @@ tc_editor_complete(void *baton,
apr_pool_t *scratch_pool)
{
struct tc_editor_baton *b = baton;
- svn_wc_notify_t *notify;
- notify = svn_wc_create_notify(svn_dirent_join(b->wcroot->abspath,
- b->move_root_dst_relpath,
- scratch_pool),
- svn_wc_notify_update_completed,
- scratch_pool);
- notify->kind = svn_node_none;
- notify->content_state = svn_wc_notify_state_inapplicable;
- notify->prop_state = svn_wc_notify_state_inapplicable;
- notify->revision = b->new_version->peg_rev;
- b->notify_func(b->notify_baton, notify, scratch_pool);
+ if (b->notify_func)
+ {
+ svn_wc_notify_t *notify;
+
+ notify = svn_wc_create_notify(svn_dirent_join(b->wcroot->abspath,
+ b->move_root_dst_relpath,
+ scratch_pool),
+ svn_wc_notify_update_completed,
+ scratch_pool);
+ notify->kind = svn_node_none;
+ notify->content_state = svn_wc_notify_state_inapplicable;
+ notify->prop_state = svn_wc_notify_state_inapplicable;
+ notify->revision = b->new_version->peg_rev;
+ b->notify_func(b->notify_baton, notify, scratch_pool);
+ }
return SVN_NO_ERROR;
}
@@ -410,6 +823,7 @@ tc_editor_abort(void *baton,
return SVN_NO_ERROR;
}
+/* The editor callback table implementing the receiver. */
static const svn_editor_cb_many_t editor_ops = {
tc_editor_add_directory,
tc_editor_add_file,
@@ -429,6 +843,18 @@ static const svn_editor_cb_many_t editor
/*
* Driver code.
+ *
+ * The scenario is that a subtree has been locally moved, and then the base
+ * layer on the source side of the move has received an update to a new
+ * state. The destination subtree has not yet been updated, and still
+ * matches the pre-update state of the source subtree.
+ *
+ * The edit driver drives the receiver with the difference between the
+ * pre-update state (as found now at the move-destination) and the
+ * post-update state (found now at the move-source).
+ *
+ * We currently assume that both the pre-update and post-update states are
+ * single-revision.
*/
/* Set *OPERATION, *LOCAL_CHANGE, *INCOMING_CHANGE, *OLD_VERSION, *NEW_VERSION
@@ -442,8 +868,8 @@ get_tc_info(svn_wc_operation_t *operatio
svn_wc_conflict_action_t *incoming_change,
svn_wc_conflict_version_t **old_version,
svn_wc_conflict_version_t **new_version,
- const char *src_abspath,
svn_wc__db_t *db,
+ const char *src_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
@@ -488,14 +914,55 @@ get_tc_info(svn_wc_operation_t *operatio
const char *repos_relpath;
svn_revnum_t revision;
svn_node_kind_t node_kind;
+ svn_wc__db_status_t status;
+
+ /* The scan dance: read_info then scan_delete then base_get
+ or scan_addition. Use the internal/relpath functions
+ here? */
+ SVN_ERR(svn_wc__db_read_info(&status, &kind, &revision,
+ &repos_relpath, &repos_root_url,
+ &repos_uuid, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL,
+ db, src_abspath, result_pool,
+ scratch_pool));
+ if (status == svn_wc__db_status_deleted)
+ {
+ const char *base_del_abspath, *work_del_abspath;
+ SVN_ERR(svn_wc__db_scan_deletion(&base_del_abspath, NULL,
+ &work_del_abspath,
+ NULL, db, src_abspath,
+ scratch_pool, scratch_pool));
+ SVN_ERR_ASSERT(base_del_abspath || work_del_abspath);
+ if (base_del_abspath)
+ {
+ SVN_ERR(svn_wc__db_base_get_info(NULL, &kind, &revision,
+ &repos_relpath,
+ &repos_root_url,
+ &repos_uuid,
+ NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL,
+ db, src_abspath, result_pool,
+ scratch_pool));
+ }
+ else if (work_del_abspath)
+ {
+ work_del_abspath = svn_dirent_dirname(work_del_abspath,
+ scratch_pool);
+ SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, &repos_relpath,
+ &repos_root_url, &repos_uuid,
+ NULL, NULL, NULL,
+ &revision, NULL, NULL,
+ db, work_del_abspath,
+ scratch_pool, scratch_pool));
+ repos_relpath = svn_relpath_join(repos_relpath,
+ svn_dirent_skip_ancestor(work_del_abspath,
+ src_abspath),
+ scratch_pool);
+ }
+ }
- /* Construct new_version from BASE info. */
- SVN_ERR(svn_wc__db_base_get_info(NULL, &kind, &revision,
- &repos_relpath, &repos_root_url,
- &repos_uuid, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL, NULL, NULL,
- db, src_abspath, result_pool,
- scratch_pool));
node_kind = svn__node_kind_from_kind(kind);
*new_version = svn_wc_conflict_version_create2(repos_root_url,
repos_uuid,
@@ -519,6 +986,7 @@ get_tc_info(svn_wc_operation_t *operatio
*/
static svn_error_t *
update_moved_away_file(svn_editor_t *tc_editor,
+ svn_boolean_t add,
const char *src_relpath,
const char *dst_relpath,
const char *move_root_dst_relpath,
@@ -528,26 +996,35 @@ update_moved_away_file(svn_editor_t *tc_
apr_pool_t *scratch_pool)
{
svn_kind_t kind;
- svn_stream_t *post_update_contents;
- const svn_checksum_t *move_src_checksum;
-
+ svn_stream_t *new_contents;
+ const svn_checksum_t *new_checksum;
+ apr_hash_t *new_props;
+
/* Read post-update contents from the updated moved-away file and tell
* the editor to merge them into the moved-here file. */
SVN_ERR(svn_wc__db_read_pristine_info(NULL, &kind, NULL, NULL, NULL, NULL,
- &move_src_checksum, NULL, NULL, db,
- svn_dirent_join(wcroot->abspath,
- src_relpath,
- scratch_pool),
+ &new_checksum, NULL, NULL, &new_props,
+ db, svn_dirent_join(wcroot->abspath,
+ src_relpath,
+ scratch_pool),
scratch_pool, scratch_pool));
- SVN_ERR(svn_wc__db_pristine_read(&post_update_contents, NULL, db,
- wcroot->abspath, move_src_checksum,
+ SVN_ERR(svn_wc__db_pristine_read(&new_contents, NULL, db,
+ wcroot->abspath, new_checksum,
scratch_pool, scratch_pool));
- SVN_ERR(svn_editor_alter_file(tc_editor, dst_relpath,
- move_root_dst_revision,
- NULL, /* ### TODO props */
- move_src_checksum,
- post_update_contents));
- SVN_ERR(svn_stream_close(post_update_contents));
+
+ if (add)
+ /* FIXME: editor API violation: missing svn_editor_alter_directory. */
+ SVN_ERR(svn_editor_add_file(tc_editor, dst_relpath,
+ new_checksum, new_contents,
+ apr_hash_make(scratch_pool), /* ### TODO props */
+ move_root_dst_revision));
+ else
+ SVN_ERR(svn_editor_alter_file(tc_editor, dst_relpath,
+ move_root_dst_revision,
+ new_props, new_checksum,
+ new_contents));
+
+ SVN_ERR(svn_stream_close(new_contents));
return SVN_NO_ERROR;
}
@@ -556,6 +1033,8 @@ update_moved_away_file(svn_editor_t *tc_
*/
static svn_error_t *
update_moved_away_dir(svn_editor_t *tc_editor,
+ svn_boolean_t add,
+ apr_hash_t *children_hash,
const char *src_relpath,
const char *dst_relpath,
const char *move_root_dst_relpath,
@@ -564,11 +1043,25 @@ update_moved_away_dir(svn_editor_t *tc_e
svn_wc__db_wcroot_t *wcroot,
apr_pool_t *scratch_pool)
{
- /* ### notify */
-
- /* ### update prop content if changed */
-
- /* ### update list of children if changed */
+ apr_array_header_t *new_children;
+ apr_hash_t *new_props;
+ const char *src_abspath = svn_dirent_join(wcroot->abspath,
+ src_relpath,
+ scratch_pool);
+
+ SVN_ERR(svn_hash_keys(&new_children, children_hash, scratch_pool));
+
+ SVN_ERR(svn_wc__db_read_pristine_props(&new_props, db, src_abspath,
+ scratch_pool, scratch_pool));
+
+ if (add)
+ SVN_ERR(svn_editor_add_directory(tc_editor, dst_relpath,
+ new_children, new_props,
+ move_root_dst_revision));
+ else
+ SVN_ERR(svn_editor_alter_directory(tc_editor, dst_relpath,
+ move_root_dst_revision,
+ new_children, new_props));
return SVN_NO_ERROR;
}
@@ -577,85 +1070,171 @@ update_moved_away_dir(svn_editor_t *tc_e
*/
static svn_error_t *
update_moved_away_subtree(svn_editor_t *tc_editor,
+ svn_boolean_t add,
const char *src_relpath,
const char *dst_relpath,
+ int src_op_depth,
const char *move_root_dst_relpath,
svn_revnum_t move_root_dst_revision,
svn_wc__db_t *db,
svn_wc__db_wcroot_t *wcroot,
apr_pool_t *scratch_pool)
{
- const apr_array_header_t *children;
+ apr_hash_t *src_children, *dst_children;
apr_pool_t *iterpool;
- int i;
+ apr_hash_index_t *hi;
+
+ SVN_ERR(svn_wc__db_get_children_op_depth(&src_children, wcroot,
+ src_relpath, src_op_depth,
+ scratch_pool, scratch_pool));
- SVN_ERR(update_moved_away_dir(tc_editor, src_relpath, dst_relpath,
+ SVN_ERR(update_moved_away_dir(tc_editor, add, src_children,
+ src_relpath, dst_relpath,
move_root_dst_relpath,
move_root_dst_revision,
db, wcroot, scratch_pool));
- SVN_ERR(svn_wc__db_base_get_children(&children, db,
- svn_dirent_join(wcroot->abspath,
- src_relpath,
- scratch_pool),
- scratch_pool, scratch_pool));
+ SVN_ERR(svn_wc__db_get_children_op_depth(&dst_children, wcroot,
+ dst_relpath,
+ relpath_depth(move_root_dst_relpath),
+ scratch_pool, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
- for (i = 0; i < children->nelts; i++)
+ for (hi = apr_hash_first(scratch_pool, src_children);
+ hi;
+ hi = apr_hash_next(hi))
+ {
+ const char *src_name = svn__apr_hash_index_key(hi);
+ svn_kind_t *src_kind = svn__apr_hash_index_val(hi);
+ svn_kind_t *dst_kind = apr_hash_get(dst_children, src_name,
+ APR_HASH_KEY_STRING);
+ svn_boolean_t is_add = FALSE;
+ const char *child_src_relpath, *child_dst_relpath;
+
+ svn_pool_clear(iterpool);
+
+ child_src_relpath = svn_relpath_join(src_relpath, src_name, iterpool);
+ child_dst_relpath = svn_relpath_join(dst_relpath, src_name, iterpool);
+
+ if (!dst_kind || (*src_kind != *dst_kind))
+ {
+ is_add = TRUE;
+ if (dst_kind)
+ /* FIXME:editor API violation:missing svn_editor_alter_directory. */
+ SVN_ERR(svn_editor_delete(tc_editor, child_dst_relpath,
+ move_root_dst_revision));
+ }
+
+ if (*src_kind == svn_kind_file || *src_kind == svn_kind_symlink)
+ {
+ SVN_ERR(update_moved_away_file(tc_editor, is_add,
+ child_src_relpath,
+ child_dst_relpath,
+ move_root_dst_relpath,
+ move_root_dst_revision,
+ db, wcroot, iterpool));
+ }
+ else if (*src_kind == svn_kind_dir)
+ {
+ SVN_ERR(update_moved_away_subtree(tc_editor, is_add,
+ child_src_relpath,
+ child_dst_relpath,
+ src_op_depth,
+ move_root_dst_relpath,
+ move_root_dst_revision,
+ db, wcroot, iterpool));
+ }
+ else
+ ; /* ### TODO */
+
+ apr_hash_set(dst_children, src_name, APR_HASH_KEY_STRING, NULL);
+ }
+ for (hi = apr_hash_first(scratch_pool, dst_children);
+ hi;
+ hi = apr_hash_next(hi))
{
- const char *child_src_relpath;
- svn_kind_t child_kind;
- const char *child_dst_op_root_relpath;
+ const char *dst_name = svn__apr_hash_index_key(hi);
const char *child_dst_relpath;
svn_pool_clear(iterpool);
+ child_dst_relpath = svn_relpath_join(dst_relpath, dst_name, iterpool);
- child_src_relpath = svn_relpath_join(src_relpath,
- APR_ARRAY_IDX(children, i,
- const char *),
- iterpool);
-
- /* Is this child part of our move operation? */
- /* ### need to handle children which were newly added or removed
- * ### during the update */
- SVN_ERR(svn_wc__db_scan_deletion_internal(NULL, &child_dst_relpath, NULL,
- &child_dst_op_root_relpath,
- wcroot, child_src_relpath,
- iterpool, iterpool));
- if (child_dst_op_root_relpath == NULL ||
- strcmp(child_dst_op_root_relpath, move_root_dst_relpath) != 0)
- continue;
-
- SVN_ERR(svn_wc__db_base_get_info_internal(NULL, &child_kind,
- NULL, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL,
- NULL, NULL, NULL, NULL,
- wcroot, child_src_relpath,
- iterpool, iterpool));
-
- if (child_kind == svn_kind_file || child_kind == svn_kind_symlink)
- SVN_ERR(update_moved_away_file(tc_editor, child_src_relpath,
- child_dst_relpath,
- move_root_dst_relpath,
- move_root_dst_revision,
- db, wcroot, iterpool));
- else if (child_kind == svn_kind_dir)
- SVN_ERR(update_moved_away_subtree(tc_editor, child_src_relpath,
- child_dst_relpath,
- move_root_dst_relpath,
- move_root_dst_revision,
- db, wcroot, iterpool));
+ /* FIXME: editor API violation: missing svn_editor_alter_directory. */
+ SVN_ERR(svn_editor_delete(tc_editor, child_dst_relpath,
+ move_root_dst_revision));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
-/* ### Drive TC_EDITOR so as to ...
+/* Update the single op-depth layer in the move destination subtree
+ rooted at DST_RELPATH to make it match the move source subtree
+ rooted at SRC_RELPATH. */
+static svn_error_t *
+replace_moved_layer(const char *src_relpath,
+ const char *dst_relpath,
+ int src_op_depth,
+ svn_wc__db_t *db,
+ svn_wc__db_wcroot_t *wcroot,
+ apr_pool_t *scratch_pool)
+{
+ svn_sqlite__stmt_t *stmt;
+ svn_boolean_t have_row;
+ int dst_op_depth = relpath_depth(dst_relpath);
+
+ /* Replace entire subtree at one op-depth. */
+ SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+ STMT_SELECT_LOCAL_RELPATH_OP_DEPTH));
+ SVN_ERR(svn_sqlite__bindf(stmt, "isd", wcroot->wc_id,
+ src_relpath, src_op_depth));
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ while (have_row)
+ {
+ svn_error_t *err;
+ svn_sqlite__stmt_t *stmt2;
+ const char *src_cp_relpath = svn_sqlite__column_text(stmt, 0, NULL);
+ const char *dst_cp_relpath
+ = svn_relpath_join(dst_relpath,
+ svn_relpath_skip_ancestor(src_relpath,
+ src_cp_relpath),
+ scratch_pool);
+
+ err = svn_sqlite__get_statement(&stmt2, wcroot->sdb,
+ STMT_COPY_NODE_MOVE);
+ if (!err)
+ err = svn_sqlite__bindf(stmt2, "isdsds", wcroot->wc_id,
+ src_cp_relpath, src_op_depth,
+ dst_cp_relpath, dst_op_depth,
+ svn_relpath_dirname(dst_cp_relpath,
+ scratch_pool));
+ if (!err)
+ err = svn_sqlite__step_done(stmt2);
+ if (err)
+ return svn_error_compose_create(err, svn_sqlite__reset(stmt));
+
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ }
+ SVN_ERR(svn_sqlite__reset(stmt));
+
+ return SVN_NO_ERROR;
+}
+
+/* Transfer changes from the move source to the move destination.
+ *
+ * Drive the editor TC_EDITOR with the difference between DST_RELPATH
+ * (at its own op-depth) and SRC_RELPATH (at op-depth zero).
+ *
+ * Then update the single op-depth layer in the move destination subtree
+ * rooted at DST_RELPATH to make it match the move source subtree
+ * rooted at SRC_RELPATH.
+ *
+ * ### And the other params?
*/
static svn_error_t *
drive_tree_conflict_editor(svn_editor_t *tc_editor,
const char *src_relpath,
const char *dst_relpath,
+ int src_op_depth,
svn_wc_operation_t operation,
svn_wc_conflict_reason_t local_change,
svn_wc_conflict_action_t incoming_change,
@@ -680,100 +1259,110 @@ drive_tree_conflict_editor(svn_editor_t
src_relpath, scratch_pool),
scratch_pool));
- /*
- * Drive the TC editor to transfer incoming changes from the move source
- * to the move destination.
- *
- * The pre-update tree is within dst at the op-depth of the move's op-root.
- * The post-update base tree is within src at op-depth zero.
- *
- * We walk the move source (i.e. the post-update tree), comparing each node
+ /* We walk the move source (i.e. the post-update tree), comparing each node
* with the equivalent node at the move destination and applying the update
- * to nodes at the move destination.
- */
+ * to nodes at the move destination. */
if (old_version->node_kind == svn_node_file)
- SVN_ERR(update_moved_away_file(tc_editor, src_relpath, dst_relpath,
+ SVN_ERR(update_moved_away_file(tc_editor, FALSE, src_relpath, dst_relpath,
dst_relpath, old_version->peg_rev,
db, wcroot, scratch_pool));
else if (old_version->node_kind == svn_node_dir)
- SVN_ERR(update_moved_away_subtree(tc_editor, src_relpath, dst_relpath,
+ SVN_ERR(update_moved_away_subtree(tc_editor, FALSE,
+ src_relpath, dst_relpath,
+ src_op_depth,
dst_relpath, old_version->peg_rev,
db, wcroot, scratch_pool));
SVN_ERR(svn_editor_complete(tc_editor));
+ SVN_ERR(replace_moved_layer(src_relpath, dst_relpath, src_op_depth,
+ db, wcroot, scratch_pool));
+
return SVN_NO_ERROR;
}
-struct update_moved_away_conflict_victim_baton {
- svn_skel_t **work_items;
- const char *victim_relpath;
- svn_wc_operation_t operation;
- svn_wc_conflict_reason_t local_change;
- svn_wc_conflict_action_t incoming_change;
- svn_wc_conflict_version_t *old_version;
- svn_wc_conflict_version_t *new_version;
- svn_wc__db_t *db;
- svn_wc_notify_func2_t notify_func;
- void *notify_baton;
- svn_cancel_func_t cancel_func;
- void *cancel_baton;
- apr_pool_t *result_pool;
-};
-
/* The body of svn_wc__db_update_moved_away_conflict_victim(), which see.
- * An implementation of svn_wc__db_txn_callback_t. */
+ */
static svn_error_t *
-update_moved_away_conflict_victim(void *baton,
+update_moved_away_conflict_victim(svn_skel_t **work_items,
+ svn_wc__db_t *db,
svn_wc__db_wcroot_t *wcroot,
const char *victim_relpath,
+ svn_wc_operation_t operation,
+ svn_wc_conflict_reason_t local_change,
+ svn_wc_conflict_action_t incoming_change,
+ svn_wc_conflict_version_t *old_version,
+ svn_wc_conflict_version_t *new_version,
+ svn_wc_notify_func2_t notify_func,
+ void *notify_baton,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
- struct update_moved_away_conflict_victim_baton *b = baton;
svn_editor_t *tc_editor;
struct tc_editor_baton *tc_editor_baton;
+ svn_sqlite__stmt_t *stmt;
+ svn_boolean_t have_row;
+ int src_op_depth;
/* ### assumes wc write lock already held */
/* Construct editor baton. */
tc_editor_baton = apr_pcalloc(scratch_pool, sizeof(*tc_editor_baton));
- tc_editor_baton->move_root_src_relpath = b->victim_relpath;
SVN_ERR(svn_wc__db_scan_deletion_internal(
NULL, &tc_editor_baton->move_root_dst_relpath, NULL, NULL,
- wcroot, b->victim_relpath, scratch_pool, scratch_pool));
+ wcroot, victim_relpath, scratch_pool, scratch_pool));
if (tc_editor_baton->move_root_dst_relpath == NULL)
return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
_("The node '%s' has not been moved away"),
svn_dirent_local_style(
- svn_dirent_join(wcroot->abspath,
- b->victim_relpath,
+ svn_dirent_join(wcroot->abspath, victim_relpath,
scratch_pool),
scratch_pool));
- tc_editor_baton->old_version= b->old_version;
- tc_editor_baton->new_version= b->new_version;
- tc_editor_baton->db = b->db;
+ tc_editor_baton->old_version= old_version;
+ tc_editor_baton->new_version= new_version;
+ tc_editor_baton->db = db;
tc_editor_baton->wcroot = wcroot;
- tc_editor_baton->work_items = b->work_items;
- tc_editor_baton->notify_func = b->notify_func;
- tc_editor_baton->notify_baton = b->notify_baton;
- tc_editor_baton->result_pool = b->result_pool;
+ tc_editor_baton->work_items = work_items;
+ tc_editor_baton->notify_func = notify_func;
+ tc_editor_baton->notify_baton = notify_baton;
+ tc_editor_baton->result_pool = result_pool;
+ /* ### TODO get from svn_wc__db_scan_deletion_internal? */
+ SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->sdb,
+ STMT_SELECT_NODE_INFO));
+ SVN_ERR(svn_sqlite__bindf(stmt, "is", wcroot->wc_id, victim_relpath));
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ if (have_row)
+ SVN_ERR(svn_sqlite__step(&have_row, stmt));
+ if (have_row)
+ src_op_depth = svn_sqlite__column_int(stmt, 0);
+ SVN_ERR(svn_sqlite__reset(stmt));
+ if (!have_row)
+ return svn_error_createf(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE, NULL,
+ _("'%s' is not deleted"),
+ svn_dirent_local_style(
+ svn_dirent_join(wcroot->abspath, victim_relpath,
+ scratch_pool),
+ scratch_pool));
/* Create the editor... */
SVN_ERR(svn_editor_create(&tc_editor, tc_editor_baton,
- b->cancel_func, b->cancel_baton,
+ cancel_func, cancel_baton,
scratch_pool, scratch_pool));
SVN_ERR(svn_editor_setcb_many(tc_editor, &editor_ops, scratch_pool));
/* ... and drive it. */
SVN_ERR(drive_tree_conflict_editor(tc_editor,
- tc_editor_baton->move_root_src_relpath,
+ victim_relpath,
tc_editor_baton->move_root_dst_relpath,
- b->operation,
- b->local_change, b->incoming_change,
+ src_op_depth,
+ operation,
+ local_change, incoming_change,
tc_editor_baton->old_version,
tc_editor_baton->new_version,
- b->db, wcroot,
- b->cancel_func, b->cancel_baton,
+ db, wcroot,
+ cancel_func, cancel_baton,
scratch_pool));
return SVN_NO_ERROR;
@@ -782,8 +1371,8 @@ update_moved_away_conflict_victim(void *
svn_error_t *
svn_wc__db_update_moved_away_conflict_victim(svn_skel_t **work_items,
- const char *victim_abspath,
svn_wc__db_t *db,
+ const char *victim_abspath,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
@@ -791,7 +1380,6 @@ svn_wc__db_update_moved_away_conflict_vi
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
- struct update_moved_away_conflict_victim_baton b;
svn_wc__db_wcroot_t *wcroot;
const char *local_relpath;
svn_wc_operation_t operation;
@@ -802,30 +1390,23 @@ svn_wc__db_update_moved_away_conflict_vi
SVN_ERR(get_tc_info(&operation, &local_change, &incoming_change,
&old_version, &new_version,
- victim_abspath, db, scratch_pool, scratch_pool));
+ db, victim_abspath,
+ scratch_pool, scratch_pool));
SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath,
db, victim_abspath,
scratch_pool, scratch_pool));
VERIFY_USABLE_WCROOT(wcroot);
- b.work_items = work_items;
- b.victim_relpath = local_relpath;
- b.operation = operation;
- b.local_change = local_change;
- b.incoming_change = incoming_change;
- b.old_version = old_version;
- b.new_version = new_version;
- b.db = db;
- b.notify_func = notify_func;
- b.notify_baton = notify_baton;
- b.cancel_func = cancel_func;
- b.cancel_baton = cancel_baton;
- b.result_pool = result_pool;
-
- SVN_ERR(svn_wc__db_with_txn(wcroot, local_relpath,
- update_moved_away_conflict_victim, &b,
- scratch_pool));
+ SVN_WC__DB_WITH_TXN(
+ update_moved_away_conflict_victim(
+ work_items, db, wcroot, local_relpath,
+ operation, local_change, incoming_change,
+ old_version, new_version,
+ notify_func, notify_baton,
+ cancel_func, cancel_baton,
+ result_pool, scratch_pool),
+ wcroot);
return SVN_NO_ERROR;
}
Modified: subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_util.c
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_util.c?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_util.c (original)
+++ subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_util.c Sun Jan 6 02:33:34 2013
@@ -153,8 +153,8 @@ svn_wc__db_util_open_db(svn_sqlite__db_t
/* Some helpful transaction helpers.
- Instead of directly using SQLite transactions, these wrappers take care of
- simple cases by allowing consumers to worry about wrapping the wcroot and
+ Instead of directly using SQLite transactions, these wrappers
+ relieve the consumer from the need to wrap the wcroot and
local_relpath, which are almost always used within the transaction.
This also means if we later want to implement some wc_db-specific txn
Modified: subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_wcroot.c
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_wcroot.c?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_wcroot.c (original)
+++ subversion/branches/tree-read-api/subversion/libsvn_wc/wc_db_wcroot.c Sun Jan 6 02:33:34 2013
@@ -685,7 +685,54 @@ try_symlink_as_dir:
}
else
{
- /* We found a wc-1 working copy directory. */
+ /* We found something that looks like a wc-1 working copy directory.
+ However, if the format version is 12 and the .svn/entries file
+ is only 3 bytes long, then it's a breadcrumb in a wc-ng working
+ copy that's missing an .svn/wc.db, or its .svn/wc.db is corrupt. */
+ if (wc_format == SVN_WC__WC_NG_VERSION /* 12 */)
+ {
+ apr_finfo_t info;
+
+ /* Check attributes of .svn/entries */
+ const char *admin_abspath = svn_wc__adm_child(
+ local_abspath, SVN_WC__ADM_ENTRIES, scratch_pool);
+ svn_error_t *err = svn_io_stat(&info, admin_abspath, APR_FINFO_SIZE,
+ scratch_pool);
+
+ /* If the former does not succeed, something is seriously wrong. */
+ if (err)
+ return svn_error_createf(
+ SVN_ERR_WC_CORRUPT, err,
+ _("The working copy at '%s' is corrupt."),
+ svn_dirent_local_style(local_abspath, scratch_pool));
+ svn_error_clear(err);
+
+ if (3 == info.size)
+ {
+ /* Check existence of .svn/wc.db */
+ admin_abspath = svn_wc__adm_child(local_abspath, SDB_FILE,
+ scratch_pool);
+ err = svn_io_stat(&info, admin_abspath, APR_FINFO_SIZE,
+ scratch_pool);
+ if (err && APR_STATUS_IS_ENOENT(err->apr_err))
+ {
+ svn_error_clear(err);
+ return svn_error_createf(
+ SVN_ERR_WC_CORRUPT, NULL,
+ _("The working copy database at '%s' is missing."),
+ svn_dirent_local_style(local_abspath, scratch_pool));
+ }
+ else
+ /* We should never have reached this point in the code
+ if .svn/wc.db exists; therefore it's best to assume
+ it's corrupt. */
+ return svn_error_createf(
+ SVN_ERR_WC_CORRUPT, err,
+ _("The working copy database at '%s' is corrupt."),
+ svn_dirent_local_style(local_abspath, scratch_pool));
+ }
+ }
+
SVN_ERR(svn_wc__db_pdh_create_wcroot(wcroot,
apr_pstrdup(db->state_pool, local_abspath),
NULL, UNKNOWN_WC_ID, wc_format,
Modified: subversion/branches/tree-read-api/subversion/libsvn_wc/wc_trees.c
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/libsvn_wc/wc_trees.c?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/libsvn_wc/wc_trees.c (original)
+++ subversion/branches/tree-read-api/subversion/libsvn_wc/wc_trees.c Sun Jan 6 02:33:34 2013
@@ -168,7 +168,7 @@ wc_treen_read_file(svn_tree_node_t *node
SVN_ERR(svn_wc__db_base_get_info(NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &checksum,
- NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL,
tb->wc_ctx->db, abspath,
scratch_pool, scratch_pool));
if (checksum)
Modified: subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.c
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.c?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.c (original)
+++ subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.c Sun Jan 6 02:33:34 2013
@@ -50,6 +50,7 @@
#define OP_SYNC_FILE_FLAGS "sync-file-flags"
#define OP_PREJ_INSTALL "prej-install"
#define OP_DIRECTORY_REMOVE "dir-remove"
+#define OP_DIRECTORY_INSTALL "dir-install"
#define OP_POSTUPGRADE "postupgrade"
@@ -148,7 +149,7 @@ run_base_remove(svn_wc__db_t *db,
¬_present_rev, NULL,
NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
- NULL, NULL,
+ NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
}
@@ -382,10 +383,6 @@ svn_wc__wq_build_file_commit(svn_skel_t
SVN_ERR(svn_wc__db_to_relpath(&local_relpath, db, local_abspath,
local_abspath, result_pool, scratch_pool));
- /* This are currently ignored, they are here for compat. */
- svn_skel__prepend_int(FALSE, *work_item, result_pool);
- svn_skel__prepend_int(FALSE, *work_item, result_pool);
-
svn_skel__prepend_str(local_relpath, *work_item, result_pool);
svn_skel__prepend_str(OP_FILE_COMMIT, *work_item, result_pool);
@@ -1016,6 +1013,51 @@ svn_wc__wq_build_file_copy_translated(sv
return SVN_NO_ERROR;
}
+/* ------------------------------------------------------------------------ */
+
+/* OP_DIRECTORY_INSTALL */
+
+static svn_error_t *
+run_dir_install(svn_wc__db_t *db,
+ const svn_skel_t *work_item,
+ const char *wri_abspath,
+ svn_cancel_func_t cancel_func,
+ void *cancel_baton,
+ apr_pool_t *scratch_pool)
+{
+ const svn_skel_t *arg1 = work_item->children->next;
+ const char *local_relpath;
+ const char *local_abspath;
+
+ local_relpath = apr_pstrmemdup(scratch_pool, arg1->data, arg1->len);
+ SVN_ERR(svn_wc__db_from_relpath(&local_abspath, db, wri_abspath,
+ local_relpath, scratch_pool, scratch_pool));
+
+ SVN_ERR(svn_wc__ensure_directory(local_abspath, scratch_pool));
+
+ return SVN_NO_ERROR;
+}
+
+svn_error_t *
+svn_wc__wq_build_dir_install(svn_skel_t **work_item,
+ svn_wc__db_t *db,
+ const char *local_abspath,
+ apr_pool_t *scratch_pool,
+ apr_pool_t *result_pool)
+{
+ const char *local_relpath;
+
+ *work_item = svn_skel__make_empty_list(result_pool);
+
+ SVN_ERR(svn_wc__db_to_relpath(&local_relpath, db, local_abspath,
+ local_abspath, result_pool, scratch_pool));
+ svn_skel__prepend_str(local_relpath, *work_item, result_pool);
+
+ svn_skel__prepend_str(OP_DIRECTORY_INSTALL, *work_item, result_pool);
+
+ return SVN_NO_ERROR;
+}
+
/* ------------------------------------------------------------------------ */
@@ -1370,6 +1412,7 @@ static const struct work_item_dispatch d
{ OP_SYNC_FILE_FLAGS, run_sync_file_flags },
{ OP_PREJ_INSTALL, run_prej_install },
{ OP_DIRECTORY_REMOVE, run_dir_remove },
+ { OP_DIRECTORY_INSTALL, run_dir_install },
/* Upgrade steps */
{ OP_POSTUPGRADE, run_postupgrade },
Modified: subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.h
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.h?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.h (original)
+++ subversion/branches/tree-read-api/subversion/libsvn_wc/workqueue.h Sun Jan 6 02:33:34 2013
@@ -93,8 +93,8 @@ svn_wc__wq_run(svn_wc__db_t *db,
/* Set *WORK_ITEM to a new work item that will install the working
copy file at LOCAL_ABSPATH. If USE_COMMIT_TIMES is TRUE, then the newly
installed file will use the nodes CHANGE_DATE for the file timestamp.
- If RECORD_FILEINFO is TRUE, then the resulting LAST_MOD_TIME and
- TRANSLATED_SIZE will be recorded in the database.
+ If RECORD_FILEINFO is TRUE, then the resulting RECORDED_TIME and
+ RECORDED_SIZE will be recorded in the database.
If SOURCE_ABSPATH is NULL, then the pristine contents will be installed
(with appropriate translation). If SOURCE_ABSPATH is not NULL, then it
@@ -215,6 +215,14 @@ svn_wc__wq_build_file_commit(svn_skel_t
apr_pool_t *result_pool,
apr_pool_t *scratch_pool);
+/* Set *WORK_ITEM to a new work item that will install the working
+ copy directory at LOCAL_ABSPATH. */
+svn_error_t *
+svn_wc__wq_build_dir_install(svn_skel_t **work_item,
+ svn_wc__db_t *db,
+ const char *local_abspath,
+ apr_pool_t *scratch_pool,
+ apr_pool_t *result_pool);
svn_error_t *
svn_wc__wq_build_postupgrade(svn_skel_t **work_item,
Modified: subversion/branches/tree-read-api/subversion/mod_authz_svn/INSTALL
URL: http://svn.apache.org/viewvc/subversion/branches/tree-read-api/subversion/mod_authz_svn/INSTALL?rev=1429457&r1=1429456&r2=1429457&view=diff
==============================================================================
--- subversion/branches/tree-read-api/subversion/mod_authz_svn/INSTALL (original)
+++ subversion/branches/tree-read-api/subversion/mod_authz_svn/INSTALL Sun Jan 6 02:33:34 2013
@@ -100,6 +100,50 @@ II. Configuration
NOTE: AuthzSVNReposRelativeAccessFile filename causes the authz file
to be read from <repo path>/conf/<filename>
+ E. Example 5: Authz file stored in a Subversion repository
+
+ This configuration allows storing of the authz file in a repository.
+
+ <Location /svn>
+ DAV svn
+ SVNParentPath /path/to/reposparent
+
+ AuthType Basic
+ AuthName "Subversion repository"
+ AuthUserFile /path/to/htpasswd/file
+
+ AuthzSVNAccessFile file:///path/to/repos/authz
+
+ Require valid-user
+ </Location>
+
+ NOTE: http:// and svn:// URLs are not supported, only local file://
+ absolute URLs may be used. The URL does not have to point to the
+ same repository as the repository being accessed. If you wish to
+ restrict access to this authz file and it is in the same repository
+ you should include a rule for it.
+
+ F. Example 5: Authz file stored inside the repository being accessed.
+
+ This configuration allows providing a relative path within the
+ repository being accessed.
+
+ <Location /svn>
+ DAV svn
+ SVNParentPath /path/to/reposparent
+
+ AuthType Basic
+ AuthName "Subversion repository"
+ AuthUserFile /path/to/htpasswd/file
+
+ AuthzSVNAccessFile ^/authz
+
+ Require valid-user
+ </Location>
+
+ NOTE: You should include rules in your authz file to restirct access
+ to the authz file as desired.
+
2. Specifying permissions
The file format of the access file looks like this: