delete.c revision 299742
1/* 2 * delete.c: wrappers around wc delete functionality. 3 * 4 * ==================================================================== 5 * Licensed to the Apache Software Foundation (ASF) under one 6 * or more contributor license agreements. See the NOTICE file 7 * distributed with this work for additional information 8 * regarding copyright ownership. The ASF licenses this file 9 * to you under the Apache License, Version 2.0 (the 10 * "License"); you may not use this file except in compliance 11 * with the License. You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, 16 * software distributed under the License is distributed on an 17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 18 * KIND, either express or implied. See the License for the 19 * specific language governing permissions and limitations 20 * under the License. 21 * ==================================================================== 22 */ 23 24/* ==================================================================== */ 25 26 27 28/*** Includes. ***/ 29 30#include <apr_file_io.h> 31#include "svn_hash.h" 32#include "svn_types.h" 33#include "svn_pools.h" 34#include "svn_wc.h" 35#include "svn_client.h" 36#include "svn_error.h" 37#include "svn_dirent_uri.h" 38#include "svn_path.h" 39#include "client.h" 40 41#include "private/svn_client_private.h" 42#include "private/svn_wc_private.h" 43#include "private/svn_ra_private.h" 44 45#include "svn_private_config.h" 46 47 48/*** Code. ***/ 49 50/* Baton for find_undeletables */ 51struct can_delete_baton_t 52{ 53 const char *root_abspath; 54 svn_boolean_t target_missing; 55}; 56 57/* An svn_wc_status_func4_t callback function for finding 58 status structures which are not safely deletable. */ 59static svn_error_t * 60find_undeletables(void *baton, 61 const char *local_abspath, 62 const svn_wc_status3_t *status, 63 apr_pool_t *pool) 64{ 65 if (status->node_status == svn_wc_status_missing) 66 { 67 struct can_delete_baton_t *cdt = baton; 68 69 if (strcmp(cdt->root_abspath, local_abspath) == 0) 70 cdt->target_missing = TRUE; 71 } 72 73 /* Check for error-ful states. */ 74 if (status->node_status == svn_wc_status_obstructed) 75 return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL, 76 _("'%s' is in the way of the resource " 77 "actually under version control"), 78 svn_dirent_local_style(local_abspath, pool)); 79 else if (! status->versioned) 80 return svn_error_createf(SVN_ERR_UNVERSIONED_RESOURCE, NULL, 81 _("'%s' is not under version control"), 82 svn_dirent_local_style(local_abspath, pool)); 83 else if ((status->node_status == svn_wc_status_added 84 || status->node_status == svn_wc_status_replaced) 85 && status->text_status == svn_wc_status_normal 86 && (status->prop_status == svn_wc_status_normal 87 || status->prop_status == svn_wc_status_none)) 88 { 89 /* Unmodified copy. Go ahead, remove it */ 90 } 91 else if (status->node_status != svn_wc_status_normal 92 && status->node_status != svn_wc_status_deleted 93 && status->node_status != svn_wc_status_missing) 94 return svn_error_createf(SVN_ERR_CLIENT_MODIFIED, NULL, 95 _("'%s' has local modifications -- commit or " 96 "revert them first"), 97 svn_dirent_local_style(local_abspath, pool)); 98 99 return SVN_NO_ERROR; 100} 101 102/* Check whether LOCAL_ABSPATH is an external and raise an error if it is. 103 104 A file external should not be deleted since the file external is 105 implemented as a switched file and it would delete the file the 106 file external is switched to, which is not the behavior the user 107 would probably want. 108 109 A directory external should not be deleted since it is the root 110 of a different working copy. */ 111static svn_error_t * 112check_external(const char *local_abspath, 113 svn_client_ctx_t *ctx, 114 apr_pool_t *scratch_pool) 115{ 116 svn_node_kind_t external_kind; 117 const char *defining_abspath; 118 119 SVN_ERR(svn_wc__read_external_info(&external_kind, &defining_abspath, NULL, 120 NULL, NULL, 121 ctx->wc_ctx, local_abspath, 122 local_abspath, TRUE, 123 scratch_pool, scratch_pool)); 124 125 if (external_kind != svn_node_none) 126 return svn_error_createf(SVN_ERR_WC_CANNOT_DELETE_FILE_EXTERNAL, NULL, 127 _("Cannot remove the external at '%s'; " 128 "please edit or delete the svn:externals " 129 "property on '%s'"), 130 svn_dirent_local_style(local_abspath, 131 scratch_pool), 132 svn_dirent_local_style(defining_abspath, 133 scratch_pool)); 134 135 return SVN_NO_ERROR; 136} 137 138/* Verify that the path can be deleted without losing stuff, 139 i.e. ensure that there are no modified or unversioned resources 140 under PATH. This is similar to checking the output of the status 141 command. CTX is used for the client's config options. POOL is 142 used for all temporary allocations. */ 143static svn_error_t * 144can_delete_node(svn_boolean_t *target_missing, 145 const char *local_abspath, 146 svn_client_ctx_t *ctx, 147 apr_pool_t *scratch_pool) 148{ 149 apr_array_header_t *ignores; 150 struct can_delete_baton_t cdt; 151 152 /* Use an infinite-depth status check to see if there's anything in 153 or under PATH which would make it unsafe for deletion. The 154 status callback function find_undeletables() makes the 155 determination, returning an error if it finds anything that shouldn't 156 be deleted. */ 157 158 SVN_ERR(svn_wc_get_default_ignores(&ignores, ctx->config, scratch_pool)); 159 160 cdt.root_abspath = local_abspath; 161 cdt.target_missing = FALSE; 162 163 SVN_ERR(svn_wc_walk_status(ctx->wc_ctx, 164 local_abspath, 165 svn_depth_infinity, 166 FALSE /* get_all */, 167 FALSE /* no_ignore */, 168 FALSE /* ignore_text_mod */, 169 ignores, 170 find_undeletables, &cdt, 171 ctx->cancel_func, 172 ctx->cancel_baton, 173 scratch_pool)); 174 175 if (target_missing) 176 *target_missing = cdt.target_missing; 177 178 return SVN_NO_ERROR; 179} 180 181 182static svn_error_t * 183path_driver_cb_func(void **dir_baton, 184 void *parent_baton, 185 void *callback_baton, 186 const char *path, 187 apr_pool_t *pool) 188{ 189 const svn_delta_editor_t *editor = callback_baton; 190 *dir_baton = NULL; 191 return editor->delete_entry(path, SVN_INVALID_REVNUM, parent_baton, pool); 192} 193 194static svn_error_t * 195single_repos_delete(svn_ra_session_t *ra_session, 196 const char *base_uri, 197 const apr_array_header_t *relpaths, 198 const apr_hash_t *revprop_table, 199 svn_commit_callback2_t commit_callback, 200 void *commit_baton, 201 svn_client_ctx_t *ctx, 202 apr_pool_t *pool) 203{ 204 const svn_delta_editor_t *editor; 205 apr_hash_t *commit_revprops; 206 void *edit_baton; 207 const char *log_msg; 208 int i; 209 svn_error_t *err; 210 211 /* Create new commit items and add them to the array. */ 212 if (SVN_CLIENT__HAS_LOG_MSG_FUNC(ctx)) 213 { 214 svn_client_commit_item3_t *item; 215 const char *tmp_file; 216 apr_array_header_t *commit_items 217 = apr_array_make(pool, relpaths->nelts, sizeof(item)); 218 219 for (i = 0; i < relpaths->nelts; i++) 220 { 221 const char *relpath = APR_ARRAY_IDX(relpaths, i, const char *); 222 223 item = svn_client_commit_item3_create(pool); 224 item->url = svn_path_url_add_component2(base_uri, relpath, pool); 225 item->state_flags = SVN_CLIENT_COMMIT_ITEM_DELETE; 226 APR_ARRAY_PUSH(commit_items, svn_client_commit_item3_t *) = item; 227 } 228 SVN_ERR(svn_client__get_log_msg(&log_msg, &tmp_file, commit_items, 229 ctx, pool)); 230 if (! log_msg) 231 return SVN_NO_ERROR; 232 } 233 else 234 log_msg = ""; 235 236 SVN_ERR(svn_client__ensure_revprop_table(&commit_revprops, revprop_table, 237 log_msg, ctx, pool)); 238 239 /* Fetch RA commit editor */ 240 SVN_ERR(svn_ra__register_editor_shim_callbacks(ra_session, 241 svn_client__get_shim_callbacks(ctx->wc_ctx, 242 NULL, pool))); 243 SVN_ERR(svn_ra_get_commit_editor3(ra_session, &editor, &edit_baton, 244 commit_revprops, 245 commit_callback, 246 commit_baton, 247 NULL, TRUE, /* No lock tokens */ 248 pool)); 249 250 /* Call the path-based editor driver. */ 251 err = svn_delta_path_driver2(editor, edit_baton, relpaths, TRUE, 252 path_driver_cb_func, (void *)editor, pool); 253 254 if (err) 255 { 256 return svn_error_trace( 257 svn_error_compose_create(err, 258 editor->abort_edit(edit_baton, pool))); 259 } 260 261 if (ctx->notify_func2) 262 { 263 svn_wc_notify_t *notify; 264 notify = svn_wc_create_notify_url(base_uri, 265 svn_wc_notify_commit_finalizing, 266 pool); 267 ctx->notify_func2(ctx->notify_baton2, notify, pool); 268 } 269 270 /* Close the edit. */ 271 return svn_error_trace(editor->close_edit(edit_baton, pool)); 272} 273 274 275/* Structure for tracking remote delete targets associated with a 276 specific repository. */ 277struct repos_deletables_t 278{ 279 svn_ra_session_t *ra_session; 280 apr_array_header_t *target_uris; 281}; 282 283 284static svn_error_t * 285delete_urls_multi_repos(const apr_array_header_t *uris, 286 const apr_hash_t *revprop_table, 287 svn_commit_callback2_t commit_callback, 288 void *commit_baton, 289 svn_client_ctx_t *ctx, 290 apr_pool_t *pool) 291{ 292 apr_hash_t *deletables = apr_hash_make(pool); 293 apr_pool_t *iterpool; 294 apr_hash_index_t *hi; 295 int i; 296 297 /* Create a hash mapping repository root URLs -> repos_deletables_t * 298 structures. */ 299 for (i = 0; i < uris->nelts; i++) 300 { 301 const char *uri = APR_ARRAY_IDX(uris, i, const char *); 302 struct repos_deletables_t *repos_deletables = NULL; 303 const char *repos_relpath; 304 svn_node_kind_t kind; 305 306 for (hi = apr_hash_first(pool, deletables); hi; hi = apr_hash_next(hi)) 307 { 308 const char *repos_root = apr_hash_this_key(hi); 309 310 repos_relpath = svn_uri_skip_ancestor(repos_root, uri, pool); 311 if (repos_relpath) 312 { 313 /* Great! We've found another URI underneath this 314 session. We'll pick out the related RA session for 315 use later, store the new target, and move on. */ 316 repos_deletables = apr_hash_this_val(hi); 317 APR_ARRAY_PUSH(repos_deletables->target_uris, const char *) = 318 apr_pstrdup(pool, uri); 319 break; 320 } 321 } 322 323 /* If we haven't created a repos_deletable structure for this 324 delete target, we need to do. That means opening up an RA 325 session and initializing its targets list. */ 326 if (!repos_deletables) 327 { 328 svn_ra_session_t *ra_session = NULL; 329 const char *repos_root; 330 apr_array_header_t *target_uris; 331 332 /* Open an RA session to (ultimately) the root of the 333 repository in which URI is found. */ 334 SVN_ERR(svn_client_open_ra_session2(&ra_session, uri, NULL, 335 ctx, pool, pool)); 336 SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_root, pool)); 337 SVN_ERR(svn_ra_reparent(ra_session, repos_root, pool)); 338 repos_relpath = svn_uri_skip_ancestor(repos_root, uri, pool); 339 340 /* Make a new relpaths list for this repository, and add 341 this URI's relpath to it. */ 342 target_uris = apr_array_make(pool, 1, sizeof(const char *)); 343 APR_ARRAY_PUSH(target_uris, const char *) = apr_pstrdup(pool, uri); 344 345 /* Build our repos_deletables_t item and stash it in the 346 hash. */ 347 repos_deletables = apr_pcalloc(pool, sizeof(*repos_deletables)); 348 repos_deletables->ra_session = ra_session; 349 repos_deletables->target_uris = target_uris; 350 svn_hash_sets(deletables, repos_root, repos_deletables); 351 } 352 353 /* If we get here, we should have been able to calculate a 354 repos_relpath for this URI. Let's make sure. (We return an 355 RA error code otherwise for 1.6 compatibility.) */ 356 if (!repos_relpath || !*repos_relpath) 357 return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL, 358 _("URL '%s' not within a repository"), uri); 359 360 /* Now, test to see if the thing actually exists in HEAD. */ 361 SVN_ERR(svn_ra_check_path(repos_deletables->ra_session, repos_relpath, 362 SVN_INVALID_REVNUM, &kind, pool)); 363 if (kind == svn_node_none) 364 return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL, 365 _("URL '%s' does not exist"), uri); 366 } 367 368 /* Now we iterate over the DELETABLES hash, issuing a commit for 369 each repository with its associated collected targets. */ 370 iterpool = svn_pool_create(pool); 371 for (hi = apr_hash_first(pool, deletables); hi; hi = apr_hash_next(hi)) 372 { 373 struct repos_deletables_t *repos_deletables = apr_hash_this_val(hi); 374 const char *base_uri; 375 apr_array_header_t *target_relpaths; 376 377 svn_pool_clear(iterpool); 378 379 /* We want to anchor the commit on the longest common path 380 across the targets for this one repository. If, however, one 381 of our targets is that longest common path, we need instead 382 anchor the commit on that path's immediate parent. Because 383 we're asking svn_uri_condense_targets() to remove 384 redundancies, this situation should be detectable by their 385 being returned either a) only a single, empty-path, target 386 relpath, or b) no target relpaths at all. */ 387 SVN_ERR(svn_uri_condense_targets(&base_uri, &target_relpaths, 388 repos_deletables->target_uris, 389 TRUE, iterpool, iterpool)); 390 SVN_ERR_ASSERT(!svn_path_is_empty(base_uri)); 391 if (target_relpaths->nelts == 0) 392 { 393 const char *target_relpath; 394 395 svn_uri_split(&base_uri, &target_relpath, base_uri, iterpool); 396 APR_ARRAY_PUSH(target_relpaths, const char *) = target_relpath; 397 } 398 else if ((target_relpaths->nelts == 1) 399 && (svn_path_is_empty(APR_ARRAY_IDX(target_relpaths, 0, 400 const char *)))) 401 { 402 const char *target_relpath; 403 404 svn_uri_split(&base_uri, &target_relpath, base_uri, iterpool); 405 APR_ARRAY_IDX(target_relpaths, 0, const char *) = target_relpath; 406 } 407 408 SVN_ERR(svn_ra_reparent(repos_deletables->ra_session, base_uri, pool)); 409 SVN_ERR(single_repos_delete(repos_deletables->ra_session, base_uri, 410 target_relpaths, 411 revprop_table, commit_callback, 412 commit_baton, ctx, iterpool)); 413 } 414 svn_pool_destroy(iterpool); 415 416 return SVN_NO_ERROR; 417} 418 419svn_error_t * 420svn_client__wc_delete(const char *local_abspath, 421 svn_boolean_t force, 422 svn_boolean_t dry_run, 423 svn_boolean_t keep_local, 424 svn_wc_notify_func2_t notify_func, 425 void *notify_baton, 426 svn_client_ctx_t *ctx, 427 apr_pool_t *pool) 428{ 429 svn_boolean_t target_missing = FALSE; 430 431 SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath)); 432 433 SVN_ERR(check_external(local_abspath, ctx, pool)); 434 435 if (!force && !keep_local) 436 /* Verify that there are no "awkward" files */ 437 SVN_ERR(can_delete_node(&target_missing, local_abspath, ctx, pool)); 438 439 if (!dry_run) 440 /* Mark the entry for commit deletion and perform wc deletion */ 441 return svn_error_trace(svn_wc_delete4(ctx->wc_ctx, local_abspath, 442 keep_local || target_missing 443 /*keep_local */, 444 TRUE /* delete_unversioned */, 445 ctx->cancel_func, ctx->cancel_baton, 446 notify_func, notify_baton, pool)); 447 448 return SVN_NO_ERROR; 449} 450 451svn_error_t * 452svn_client__wc_delete_many(const apr_array_header_t *targets, 453 svn_boolean_t force, 454 svn_boolean_t dry_run, 455 svn_boolean_t keep_local, 456 svn_wc_notify_func2_t notify_func, 457 void *notify_baton, 458 svn_client_ctx_t *ctx, 459 apr_pool_t *pool) 460{ 461 int i; 462 svn_boolean_t has_non_missing = FALSE; 463 464 for (i = 0; i < targets->nelts; i++) 465 { 466 const char *local_abspath = APR_ARRAY_IDX(targets, i, const char *); 467 468 SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath)); 469 470 SVN_ERR(check_external(local_abspath, ctx, pool)); 471 472 if (!force && !keep_local) 473 { 474 svn_boolean_t missing; 475 /* Verify that there are no "awkward" files */ 476 477 SVN_ERR(can_delete_node(&missing, local_abspath, ctx, pool)); 478 479 if (! missing) 480 has_non_missing = TRUE; 481 } 482 else 483 has_non_missing = TRUE; 484 } 485 486 if (!dry_run) 487 { 488 /* Mark the entry for commit deletion and perform wc deletion */ 489 490 /* If none of the targets exists, pass keep local TRUE, to avoid 491 deleting case-different files. Detecting this in the generic case 492 from the delete code is expensive */ 493 return svn_error_trace(svn_wc__delete_many(ctx->wc_ctx, targets, 494 keep_local || !has_non_missing, 495 TRUE /* delete_unversioned_target */, 496 ctx->cancel_func, 497 ctx->cancel_baton, 498 notify_func, notify_baton, 499 pool)); 500 } 501 502 return SVN_NO_ERROR; 503} 504 505svn_error_t * 506svn_client_delete4(const apr_array_header_t *paths, 507 svn_boolean_t force, 508 svn_boolean_t keep_local, 509 const apr_hash_t *revprop_table, 510 svn_commit_callback2_t commit_callback, 511 void *commit_baton, 512 svn_client_ctx_t *ctx, 513 apr_pool_t *pool) 514{ 515 svn_boolean_t is_url; 516 517 if (! paths->nelts) 518 return SVN_NO_ERROR; 519 520 SVN_ERR(svn_client__assert_homogeneous_target_type(paths)); 521 is_url = svn_path_is_url(APR_ARRAY_IDX(paths, 0, const char *)); 522 523 if (is_url) 524 { 525 SVN_ERR(delete_urls_multi_repos(paths, revprop_table, commit_callback, 526 commit_baton, ctx, pool)); 527 } 528 else 529 { 530 const char *local_abspath; 531 apr_hash_t *wcroots; 532 apr_hash_index_t *hi; 533 int i; 534 int j; 535 apr_pool_t *iterpool; 536 svn_boolean_t is_new_target; 537 538 /* Build a map of wcroots and targets within them. */ 539 wcroots = apr_hash_make(pool); 540 iterpool = svn_pool_create(pool); 541 for (i = 0; i < paths->nelts; i++) 542 { 543 const char *wcroot_abspath; 544 apr_array_header_t *targets; 545 546 svn_pool_clear(iterpool); 547 548 /* See if the user wants us to stop. */ 549 if (ctx->cancel_func) 550 SVN_ERR(ctx->cancel_func(ctx->cancel_baton)); 551 552 SVN_ERR(svn_dirent_get_absolute(&local_abspath, 553 APR_ARRAY_IDX(paths, i, 554 const char *), 555 pool)); 556 SVN_ERR(svn_wc__get_wcroot(&wcroot_abspath, ctx->wc_ctx, 557 local_abspath, pool, iterpool)); 558 targets = svn_hash_gets(wcroots, wcroot_abspath); 559 if (targets == NULL) 560 { 561 targets = apr_array_make(pool, 1, sizeof(const char *)); 562 svn_hash_sets(wcroots, wcroot_abspath, targets); 563 } 564 565 /* Make sure targets are unique. */ 566 is_new_target = TRUE; 567 for (j = 0; j < targets->nelts; j++) 568 { 569 if (strcmp(APR_ARRAY_IDX(targets, j, const char *), 570 local_abspath) == 0) 571 { 572 is_new_target = FALSE; 573 break; 574 } 575 } 576 577 if (is_new_target) 578 APR_ARRAY_PUSH(targets, const char *) = local_abspath; 579 } 580 581 /* Delete the targets from each working copy in turn. */ 582 for (hi = apr_hash_first(pool, wcroots); hi; hi = apr_hash_next(hi)) 583 { 584 const char *root_abspath; 585 const apr_array_header_t *targets = apr_hash_this_val(hi); 586 587 svn_pool_clear(iterpool); 588 589 SVN_ERR(svn_dirent_condense_targets(&root_abspath, NULL, targets, 590 FALSE, iterpool, iterpool)); 591 592 SVN_WC__CALL_WITH_WRITE_LOCK( 593 svn_client__wc_delete_many(targets, force, FALSE, keep_local, 594 ctx->notify_func2, ctx->notify_baton2, 595 ctx, iterpool), 596 ctx->wc_ctx, root_abspath, TRUE /* lock_anchor */, 597 iterpool); 598 } 599 svn_pool_destroy(iterpool); 600 } 601 602 return SVN_NO_ERROR; 603} 604