/* * scanlog.c: scanning the log for moves * * ==================================================================== * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * ==================================================================== */ /* ==================================================================== */ /*** Includes. ***/ #include "svn_hash.h" #include "svn_wc.h" #include "svn_client.h" #include "svn_error.h" #include "svn_config.h" #include "svn_time.h" #include "svn_dirent_uri.h" #include "svn_path.h" #include "svn_pools.h" #include "svn_io.h" #include "private/svn_client_private.h" #include "private/svn_wc_private.h" #include "private/svn_ra_private.h" #include "svnmover.h" #include "svn_private_config.h" /* From moves-scan-log branch */ svn_repos_move_info_t * svn_repos_move_info_create(const char *moved_from_repos_relpath, const char *moved_to_repos_relpath, svn_revnum_t revision, svn_revnum_t copyfrom_rev, svn_repos_move_info_t *prev, svn_repos_move_info_t *next, apr_pool_t *result_pool) { svn_repos_move_info_t *move = apr_palloc(result_pool, sizeof(*move)); move->moved_from_repos_relpath = moved_from_repos_relpath; move->moved_to_repos_relpath = moved_to_repos_relpath; move->revision = revision; move->copyfrom_rev = copyfrom_rev; move->prev = prev; move->next = next; return move; } const char * svn_client__format_move_chain_for_display(svn_repos_move_info_t *first_move, const char *indent, apr_pool_t *result_pool) { const char *s; svn_repos_move_info_t *last_move; last_move = first_move; while (last_move->next) last_move = last_move->next; if (last_move != first_move) { svn_repos_move_info_t *this_move; s = apr_psprintf(result_pool, _("Combined move:\n%s %s@%ld -> %s\n" "%sIndividual moves:\n"), indent, first_move->moved_from_repos_relpath, first_move->copyfrom_rev, last_move->moved_to_repos_relpath, indent); this_move = first_move; do { s = apr_pstrcat(result_pool, s, apr_psprintf( result_pool, _("%s [r%ld] %s@%ld -> %s\n"), indent, this_move->revision, this_move->moved_from_repos_relpath, this_move->copyfrom_rev, this_move->moved_to_repos_relpath), (char *)NULL); this_move = this_move->next; } while (this_move); } else s = apr_psprintf(result_pool, _(" [r%ld] %s@%ld -> %s\n"), first_move->revision, first_move->moved_from_repos_relpath, first_move->copyfrom_rev, first_move->moved_to_repos_relpath); return s; } struct scan_moves_log_receiver_baton { /*const char *anchor_abspath;*/ svn_client_ctx_t *ctx; svn_revnum_t start; svn_revnum_t end; svn_ra_session_t *ra_session; /* The moved nodes hash to be populated. * Maps a revision number to an array of svn_repos_move_info_t * objects describing moves which happened in the revision. * * Given a sequence of moves which happened in given revisions, such as: * rA: mv x->z * rA: mv a->b * rB: mv b->c * rC: mv c->d * we map each revision number to all moves which happened in the * revision, which looks as follows: * rA : [(rA, x->z), (rA, a->b)] * rB : [(rB, b->c)] * rC : [(rC, c->d)] * This allows an update to find relevant moves based on the base * revision of a node (during updates the base revision of each node * in the working copy is arbitrary so we might not know the nodes 'a' * and 'x' under these names). * Additionally, all moves pertaining to the same node are chained into a * doubly-linked list via 'next' and 'prev' pointers (see definition of * svn_repos_move_info_t). * This way, an update can look up all moves relevant to a node, forwards * or backwards in history, once it has located a relevant move in the chain. * This can be visualized as follows: * rA : [(rA, x->z, prev=>NULL, next=>NULL), * (rA, a->b, prev=>NULL, next=>(rB, b->c))] * rB : [(rB, b->c), prev=>(rA, a->b), next=>(rC, c->d)] * rC : [(rC, c->d), prev=>(rB, c->d), next=>NULL] */ apr_hash_t *moves; /* Temporary map of move-target paths to repos_move_info_t. * Used to link multiple moves of the same node across revisions. */ apr_hash_t *moves_by_target_path; } scan_moves_log_receiver_baton; struct copy_info { const char *copyto_path; const char *copyfrom_path; svn_revnum_t copyfrom_rev; } copy_info; /* Set *RELATED to true if the deleted node at repository relpath * DELETED_PATH@DELETED_REV is ancestrally related to the node at * repository relpath COPYFROM_PATH@COPYFROM_REV, else set it to false. * * ### JAF: In practice this attempts to trace back, starting from * DELETED_PATH@(DELETED_REV-1). What if that does not exist? */ static svn_error_t * check_ancestry(svn_boolean_t *related, const char *session_url, const char *repos_root_url, const char *deleted_path, svn_revnum_t deleted_rev, const char *copyfrom_path, svn_revnum_t copyfrom_rev, svn_client_ctx_t *ctx, apr_pool_t *scratch_pool) { apr_hash_t *locations; const char *old_url; const char *old_location; const char *relpath; svn_ra_session_t *ra_session2; apr_array_header_t *location_revisions; *related = FALSE; location_revisions = apr_array_make(scratch_pool, 1, sizeof(svn_revnum_t)); APR_ARRAY_PUSH(location_revisions, svn_revnum_t) = copyfrom_rev; old_url = svn_uri_canonicalize(apr_pstrcat(scratch_pool, repos_root_url, "/", deleted_path, NULL), scratch_pool); relpath = svn_uri_skip_ancestor(session_url, old_url, scratch_pool); SVN_ERR(svn_client_open_ra_session2(&ra_session2, session_url, NULL, ctx, scratch_pool, scratch_pool)); if (relpath == NULL) { svn_error_t *err; /* The deleted path is outside of the baton's RA session URL. * Try to open the new RA session to the repository root. */ SVN_ERR(svn_ra_reparent(ra_session2, repos_root_url, scratch_pool)); relpath = svn_uri_skip_ancestor(repos_root_url, old_url, scratch_pool); if (relpath == NULL) return SVN_NO_ERROR; err = svn_ra_get_locations(ra_session2, &locations, relpath, deleted_rev - 1, location_revisions, scratch_pool); if (err) { if (err->apr_err == SVN_ERR_RA_NOT_AUTHORIZED || err->apr_err == SVN_ERR_RA_DAV_FORBIDDEN) { svn_error_clear(err); return SVN_NO_ERROR; } else return svn_error_trace(err); } } else SVN_ERR(svn_ra_get_locations(ra_session2, &locations, relpath, deleted_rev - 1, location_revisions, scratch_pool)); old_location = apr_hash_get(locations, ©from_rev, sizeof(svn_revnum_t)); *related = (old_location && strcmp(old_location[0] == '/' ? old_location + 1 : old_location, copyfrom_path) == 0); return SVN_NO_ERROR; } static svn_error_t * scan_moves_log_receiver(void *baton, svn_log_entry_t *log_entry, apr_pool_t *scratch_pool) { apr_hash_index_t *hi; apr_hash_t *copies; apr_array_header_t *deleted_paths; struct scan_moves_log_receiver_baton *b = baton; apr_pool_t *result_pool = apr_hash_pool_get(b->moves); apr_pool_t *iterpool; int i; const char *session_url; const char *repos_root_url; apr_array_header_t *moves; if (b->ctx->notify_func2) { #if 0 svn_wc_notify_t *notify; notify = svn_wc_create_notify(b->anchor_abspath, svn_wc_notify_moves_scan_log_in_progress, scratch_pool); notify->moves_scan_log_start_rev = b->start; notify->moves_scan_log_end_rev = b->end; notify->moves_scan_log_current_rev = log_entry->revision; b->ctx->notify_func2(b->ctx->notify_baton2, notify, scratch_pool); #endif } if (log_entry->changed_paths2 == NULL) return SVN_NO_ERROR; copies = apr_hash_make(scratch_pool); deleted_paths = apr_array_make(scratch_pool, 0, sizeof(const char *)); /* Scan for copied and deleted nodes in this revision. */ for (hi = apr_hash_first(scratch_pool, log_entry->changed_paths2); hi; hi = apr_hash_next(hi)) { const char *path = apr_hash_this_key(hi); svn_log_changed_path2_t *data = apr_hash_this_val(hi); if ((data->action == 'A' || data->action == 'R') && data->copyfrom_path) { struct copy_info *copy; apr_array_header_t *copies_with_same_source_path; SVN_ERR_ASSERT(path[0] == '/'); if (data->copyfrom_path[0] == '/') data->copyfrom_path++; copy = apr_palloc(scratch_pool, sizeof(*copy)); copy->copyto_path = path + 1; /* Strip leading '/' */ copy->copyfrom_path = data->copyfrom_path; copy->copyfrom_rev = data->copyfrom_rev; copies_with_same_source_path = apr_hash_get(copies, data->copyfrom_path, APR_HASH_KEY_STRING); if (copies_with_same_source_path == NULL) { copies_with_same_source_path = apr_array_make( result_pool, 1, sizeof(struct copy_info *)); apr_hash_set(copies, copy->copyfrom_path, APR_HASH_KEY_STRING, copies_with_same_source_path); } APR_ARRAY_PUSH(copies_with_same_source_path, struct copy_info *) = copy; } if (data->action == 'D' || data->action == 'R') { const char *parent_path; /* ### Is this true? What does the API guarantee? Is it ### true that copyfrom_path is a relpath? */ SVN_ERR_ASSERT(path[0] == '/'); /* When a delete is within a copy the deleted path in the changed_paths2 hash is the copied path, but for the purposes of move detection we want the pre-copy path. ### Not sure if this is the correct thing to do. Yes, it ### allows us to detect moves in copies/moves but will it ### lead to false positives? Does it matter that the ### adjusted path may not have been committed? Does it ### matter that the adjusted path may be the same as ### another committed path? */ parent_path = svn_dirent_dirname(path, scratch_pool); while(strcmp(parent_path, "/")) { svn_log_changed_path2_t *data2 = apr_hash_get(log_entry->changed_paths2, parent_path, APR_HASH_KEY_STRING); if (data2 && data2->action == 'A') { const char *relpath = svn_dirent_skip_ancestor(parent_path, path); path = svn_dirent_join_many(scratch_pool, "/", data2->copyfrom_path, relpath, NULL); break; } else parent_path = svn_dirent_dirname(parent_path, scratch_pool); } APR_ARRAY_PUSH(deleted_paths, const char *) = path + 1; } } /* If a node was deleted at one location and copied from the deleted * location to a new location within the same revision, put the node * on the moved-nodes list. */ SVN_ERR(svn_ra_get_session_url(b->ra_session, &session_url, scratch_pool)); SVN_ERR(svn_ra_get_repos_root2(b->ra_session, &repos_root_url, scratch_pool)); iterpool = svn_pool_create(scratch_pool); for (i = 0; i < deleted_paths->nelts; i++) { const char *deleted_path; apr_array_header_t *copies_with_same_source_path; svn_repos_move_info_t *new_move; svn_repos_move_info_t *prior_move; svn_boolean_t related; int j; deleted_path = APR_ARRAY_IDX(deleted_paths, i, const char *); copies_with_same_source_path = apr_hash_get(copies, deleted_path, APR_HASH_KEY_STRING); if (copies_with_same_source_path == NULL) continue; svn_pool_clear(iterpool); for (j = 0; j < copies_with_same_source_path->nelts; j++) { struct copy_info *copy; copy = APR_ARRAY_IDX(copies_with_same_source_path, j, struct copy_info *); /* We found a deleted node which matches the copyfrom path of * a copied node. Verify that the deleted node is an ancestor * of the copied node. Tracing back history of the deleted node * from revision log_entry->revision-1 to the copyfrom-revision * we must end up at the copyfrom-path. */ SVN_ERR(check_ancestry(&related, session_url, repos_root_url, deleted_path, log_entry->revision, copy->copyfrom_path, copy->copyfrom_rev, b->ctx, iterpool)); if (!related) continue; /* ### TODO: * If the node was not copied from the most recent last-changed * revision of the deleted node, this is not a move but a * "copy from the past + delete". */ /* Remember details of this move. */ new_move = svn_repos_move_info_create( apr_pstrdup(result_pool, deleted_path), apr_pstrdup(result_pool, copy->copyto_path), log_entry->revision, copy->copyfrom_rev, NULL, NULL, result_pool); /* Link together multiple moves of the same node. */ prior_move = apr_hash_get(b->moves_by_target_path, new_move->moved_from_repos_relpath, APR_HASH_KEY_STRING); if (prior_move) { /* Tracing back history of the delete-half of the new move * to the copyfrom-revision of the prior move we must end up * at the delete-half of the prior move. */ SVN_ERR(check_ancestry(&related, session_url, repos_root_url, new_move->moved_from_repos_relpath, new_move->revision, prior_move->moved_from_repos_relpath, prior_move->copyfrom_rev, b->ctx, iterpool)); if (related) { prior_move->next = new_move; new_move->prev = prior_move; } } apr_hash_set(b->moves_by_target_path, new_move->moved_to_repos_relpath, APR_HASH_KEY_STRING, new_move); /* Add this move to the list of moves in this revision. */ moves = apr_hash_get(b->moves, &new_move->revision, sizeof(svn_revnum_t)); if (moves == NULL) { moves = apr_array_make(result_pool, 1, sizeof(svn_repos_move_info_t *)); APR_ARRAY_PUSH(moves, svn_repos_move_info_t *) = new_move; apr_hash_set(b->moves, &new_move->revision, sizeof(svn_revnum_t), moves); } else APR_ARRAY_PUSH(moves, svn_repos_move_info_t *) = new_move; } } svn_pool_destroy(iterpool); return SVN_NO_ERROR; } svn_error_t * svn_client__get_repos_moves(apr_hash_t **moves, const char *anchor_abspath, svn_ra_session_t *ra_session, svn_revnum_t start, svn_revnum_t end, svn_client_ctx_t *ctx, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { struct scan_moves_log_receiver_baton lrb; /*lrb.anchor_abspath = anchor_abspath;*/ lrb.ctx = ctx; lrb.moves = apr_hash_make(result_pool); lrb.start = start; lrb.end = end; lrb.ra_session = ra_session; lrb.moves_by_target_path = apr_hash_make(scratch_pool); if (ctx->notify_func2) { #if 0 svn_wc_notify_t *notify; notify = svn_wc_create_notify(b->anchor_abspath, svn_wc_notify_moves_scan_log_start, scratch_pool); notify->moves_scan_log_start_rev = start; notify->moves_scan_log_end_rev = end; notify->moves_scan_log_current_rev = start; ctx->notify_func2(b->ctx->notify_baton2, notify, scratch_pool); #endif } SVN_ERR(svn_ra_get_log2(ra_session, NULL, start, end, 0, TRUE, FALSE, FALSE, apr_array_make(scratch_pool, 0, sizeof(const char *)), scan_moves_log_receiver, &lrb, scratch_pool)); if (ctx->notify_func2) { #if 0 svn_wc_notify_t *notify; notify = svn_wc_create_notify(b->anchor_abspath, svn_wc_notify_moves_scan_log_done, scratch_pool); notify->moves_scan_log_start_rev = start; notify->moves_scan_log_end_rev = end; notify->moves_scan_log_current_rev = end; b->ctx->notify_func2(b->ctx->notify_baton2, notify, scratch_pool); #endif } if (moves) *moves = lrb.moves; return SVN_NO_ERROR; }