This is an automated email from the ASF dual-hosted git repository. nickva pushed a commit to branch fix-bad-parent-rev-tree in repository https://gitbox.apache.org/repos/asf/couchdb.git
commit ed96abdcc1f6e92ceb8150913ebdae506f4d946b Author: Nick Vatamaniuc <[email protected]> AuthorDate: Wed Nov 4 17:57:43 2026 -0500 Handle merging same rev but with a different parent Treat it as a new revision instead creating a broken rev tree. Since #6168 when we replicated a revision we already had locally, we kept its stored value (just updated the path, since it may have connected some ancestry paths together). However, since then, if a new rev's parent disagrees with the stored version's parent, for example, if we have stored 1-a -> 2-x -> 3-c, and got 1-z -> 2-x, the path couldn't join the existing branch and became a new one with 2-x as a leaf that had nothing stored. That's an invalid rev tree, and after that, opening the doc (including _changes, _all_docs) would fail with a function clause. This was found thanks to Bryan Green. Related: #6170 --- src/couch/src/couch_db_updater.erl | 43 ++++++++++++++---- .../test/eunit/couchdb_update_conflicts_tests.erl | 52 +++++++++++++++++++++- 2 files changed, 85 insertions(+), 10 deletions(-) diff --git a/src/couch/src/couch_db_updater.erl b/src/couch/src/couch_db_updater.erl index 5312e189a..76f8fd338 100644 --- a/src/couch/src/couch_db_updater.erl +++ b/src/couch/src/couch_db_updater.erl @@ -21,6 +21,8 @@ % 10 GiB -define(DEFAULT_MAX_PARTITION_SIZE, 16#280000000). +% Stem depth to check for duplicate rev parents +-define(STEM_DUP_CHECK_DEPTH, 16#7FFFFFFF). -record(merge_acc, { revs_limit, @@ -624,9 +626,8 @@ merge_rev_tree(_Db, OldInfo, NewDoc, _Client, true) -> % We're merging in revisions without caring about % conflicts. Most likely this is a replication update. OldTree = OldInfo#full_doc_info.rev_tree, - case replicated_path(OldTree, NewDoc) of - {ok, NewTree0} -> - {NewTree, _} = couch_key_tree:merge(OldTree, NewTree0), + case replicated_merge(OldTree, NewDoc) of + {ok, NewTree} -> OldInfo#full_doc_info{rev_tree = NewTree}; ignore -> OldInfo @@ -640,8 +641,16 @@ merge_rev_tree(_Db, OldInfo, NewDoc, _Client, true) -> % node of a longer path in the same request) there is nothing to store and it % is ignored, otherwise it's any revision not in the tree is a new revision. % revision not in the tree is new. -replicated_path(OldTree, #doc{revs = {Pos, [RevId | _]}, meta = Meta} = Doc) -> +% +% When we merge, we may get a strange case of a revision parent being different +% than what we already have in the tree. In that case after the merge we could +% end up with a ?REV_MISSIING leaf (since merge aborts). In that case we merge +% the sent Path body into the tree. It will create a conflict but that is the +% best we can do in such cases and is the behavior we always had. +% +replicated_merge(OldTree, #doc{revs = {Pos, [RevId | _]}, meta = Meta} = Doc) -> Path = couch_doc:to_path(Doc), + RevsOnly = lists:keymember(revs_only, 1, Meta), case couch_key_tree:get_full_key_paths(OldTree, [{Pos, RevId}]) of {[{Pos, [{RevId, Value} | _]} | _], []} -> Fun = fun @@ -649,14 +658,30 @@ replicated_path(OldTree, #doc{revs = {Pos, [RevId | _]}, meta = Meta} = Doc) -> (_Rev, V, branch) -> V end, [Path1] = couch_key_tree:map(Fun, [Path]), - {ok, Path1}; + case couch_key_tree:merge(OldTree, Path1) of + {NewTree, internal_node} -> + {ok, NewTree}; + {NewTree, _} -> + Folded = couch_key_tree:stem(NewTree, ?STEM_DUP_CHECK_DEPTH), + Leafs = couch_key_tree:get_all_leafs(Folded), + % If we're creating a new branch/leaf and have a + % REV_MISSING at a leaf and it's not a RevOnly update, put + % the incoming body (Path) in that position. + case lists:keymember(?REV_MISSING, 1, Leafs) of + false -> {ok, Folded}; + true -> replicated_new_rev(OldTree, Path, RevsOnly) + end + end; _ -> - case lists:keymember(revs_only, 1, Meta) of - true -> ignore; - false -> {ok, Path} - end + replicated_new_rev(OldTree, Path, RevsOnly) end. +replicated_new_rev(_Tree, _Path, true = _RevsOnly) -> + ignore; +replicated_new_rev(Tree, Path, false = _RevsOnly) -> + {Tree1, _} = couch_key_tree:merge(Tree, Path), + {ok, Tree1}. + % Revpos were set before the document was grafted onto the deleted revision and % point to rev 1. Update them to the new revpos. This is needed when we % re-create a document which was previously deleted. diff --git a/src/couch/test/eunit/couchdb_update_conflicts_tests.erl b/src/couch/test/eunit/couchdb_update_conflicts_tests.erl index 199a79c14..3146ae13a 100644 --- a/src/couch/test/eunit/couchdb_update_conflicts_tests.erl +++ b/src/couch/test/eunit/couchdb_update_conflicts_tests.erl @@ -382,7 +382,10 @@ replicated_mismatched_revslimit_test_() -> ?TDEF_FE(t_att_data), ?TDEF_FE(t_internal_node_stemmed), ?TDEF_FE(t_internal_node_full_path_patches_rev_tree), - ?TDEF_FE(t_multiple_revs_path_in_one_request) + ?TDEF_FE(t_multiple_revs_path_in_one_request), + ?TDEF_FE(t_internal_node_bad_parent), + ?TDEF_FE(t_revs_only_internal_node_bad_parent), + ?TDEF_FE(t_internal_node_other_root) ] } } @@ -496,6 +499,40 @@ t_multiple_revs_path_in_one_request(DbName) -> % 5-e internal never go through ?assertMatch([{{not_found, missing}, {5, ~"e"}}], revs(DbName, [{5, ~"e"}])). +t_internal_node_bad_parent(DbName) -> + update(DbName, [doc(4, [~"d", ~"c", ~"x"], [{~"val", ~"d"}])]), + % 3-c is an internal rev with parent 2-x. It's sent with a path that says + % its parent is 2-b (oops!), so we cannot fold it into 4-d's path. It + % should be a new rev (as opposed leaving a leaf behind with no body). + update(DbName, [doc(3, [~"c", ~"b", ~"a"], [{~"val", ~"c"}])]), + ?assertEqual([], i_got_no_body_and_nobody_cares(DbName)), + ?assertEqual([{3, ~"c", false, 3}, {4, ~"d", false, 3}], leafs(DbName)), + ?assertEqual(ok, compact(DbName)). + +t_revs_only_internal_node_bad_parent(DbName) -> + update(DbName, [doc(4, [~"d", ~"c", ~"x"], [{~"val", ~"d"}])]), + % As in t_internal_node_bad_parent but it's a prep_and_validate as revs_only case. + % Since we don't store anything anyway we expect it to be ignored. + Doc = doc(3, [~"c", ~"b", ~"a"], []), + update(DbName, [Doc#doc{meta = [{revs_only, true}]}]), + ?assertEqual([], i_got_no_body_and_nobody_cares(DbName)), + ?assertEqual([{4, ~"d", false, 3}], leafs(DbName)). + +t_internal_node_other_root(DbName) -> + update(DbName, [doc(3, [~"c", ~"x", ~"a"], [])]), + % 2-x is an internal rev under 1-a. Send it again as a leaf under 1-z + % (different root but same position). Paths can't be folded. We still + % shouldn't get a body-less leaf. + update(DbName, [doc(2, [~"x", ~"z"], [])]), + ?assertEqual([], i_got_no_body_and_nobody_cares(DbName)), + ?assertEqual([{2, ~"x", false, 2}, {3, ~"c", false, 3}], leafs(DbName)), + % Make sure we can open the doc and compact it + ?assertMatch( + {ok, #doc{revs = {3, [~"c" | _]}}}, + couch_util:with_db(DbName, fun(Db) -> couch_db:open_doc(Db, ?DOC_ID, []) end) + ), + ?assertEqual(ok, compact(DbName)). + two_roots(DbName) -> update(DbName, [doc(1, [~"a"], [{~"val", ~"a"}])]), update(DbName, [d_4_stemmed()]), @@ -562,6 +599,19 @@ update(DbName, Docs) -> couch_db:update_docs(Db, Docs, [], ?REPLICATED_CHANGES) end). +% Make sure we never have a bodyless leaf +i_got_no_body_and_nobody_cares(DbName) -> + couch_util:with_db(DbName, fun(Db) -> + #full_doc_info{rev_tree = Tree} = couch_db:get_full_doc_info(Db, ?DOC_ID), + [{P, R} || {?REV_MISSING, {P, [R | _]}} <- couch_key_tree:get_all_leafs(Tree)] + end). + +compact(DbName) -> + couch_util:with_db(DbName, fun(Db) -> + {ok, _} = couch_db:start_compact(Db), + couch_db:wait_for_compaction(Db) + end). + % Get a list of {Pos, RevId, Deleted, RevPathLength} for all leafs leafs(DbName) -> couch_util:with_db(DbName, fun(Db) ->
