| /* |
| * notify.c: feedback handlers for cmdline client. |
| * |
| * ==================================================================== |
| * 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. ***/ |
| |
| #define APR_WANT_STDIO |
| #define APR_WANT_STRFUNC |
| #include <apr_want.h> |
| |
| #include "svn_cmdline.h" |
| #include "svn_pools.h" |
| #include "svn_dirent_uri.h" |
| #include "svn_path.h" |
| #include "svn_sorts.h" |
| #include "svn_hash.h" |
| #include "cl.h" |
| #include "private/svn_subr_private.h" |
| #include "private/svn_sorts_private.h" |
| #include "private/svn_dep_compat.h" |
| |
| #include "svn_private_config.h" |
| |
| |
| /* Baton for notify and friends. */ |
| struct notify_baton |
| { |
| svn_boolean_t received_some_change; |
| svn_boolean_t is_checkout; |
| svn_boolean_t is_export; |
| svn_boolean_t is_wc_to_repos_copy; |
| svn_boolean_t sent_first_txdelta; |
| int in_external; |
| svn_revnum_t progress_revision; |
| svn_boolean_t had_print_error; /* Used to not keep printing error messages |
| when we've already had one print error. */ |
| |
| svn_cl__conflict_stats_t *conflict_stats; |
| |
| /* The cwd, for use in decomposing absolute paths. */ |
| const char *path_prefix; |
| }; |
| |
| /* Conflict stats for operations such as update and merge. */ |
| struct svn_cl__conflict_stats_t |
| { |
| apr_pool_t *stats_pool; |
| apr_hash_t *text_conflicts, *prop_conflicts, *tree_conflicts; |
| int text_conflicts_resolved, prop_conflicts_resolved, tree_conflicts_resolved; |
| int skipped_paths; |
| }; |
| |
| svn_cl__conflict_stats_t * |
| svn_cl__conflict_stats_create(apr_pool_t *pool) |
| { |
| svn_cl__conflict_stats_t *conflict_stats |
| = apr_palloc(pool, sizeof(*conflict_stats)); |
| |
| conflict_stats->stats_pool = pool; |
| conflict_stats->text_conflicts = apr_hash_make(pool); |
| conflict_stats->prop_conflicts = apr_hash_make(pool); |
| conflict_stats->tree_conflicts = apr_hash_make(pool); |
| conflict_stats->text_conflicts_resolved = 0; |
| conflict_stats->prop_conflicts_resolved = 0; |
| conflict_stats->tree_conflicts_resolved = 0; |
| conflict_stats->skipped_paths = 0; |
| return conflict_stats; |
| } |
| |
| /* Add the PATH (as a key, with a meaningless value) into the HASH in NB. */ |
| static void |
| store_path(struct notify_baton *nb, apr_hash_t *hash, const char *path) |
| { |
| svn_hash_sets(hash, apr_pstrdup(nb->conflict_stats->stats_pool, path), ""); |
| } |
| |
| void |
| svn_cl__conflict_stats_resolved(svn_cl__conflict_stats_t *conflict_stats, |
| const char *path_local, |
| svn_wc_conflict_kind_t conflict_kind) |
| { |
| switch (conflict_kind) |
| { |
| case svn_wc_conflict_kind_text: |
| if (svn_hash_gets(conflict_stats->text_conflicts, path_local)) |
| { |
| svn_hash_sets(conflict_stats->text_conflicts, path_local, NULL); |
| conflict_stats->text_conflicts_resolved++; |
| } |
| break; |
| case svn_wc_conflict_kind_property: |
| if (svn_hash_gets(conflict_stats->prop_conflicts, path_local)) |
| { |
| svn_hash_sets(conflict_stats->prop_conflicts, path_local, NULL); |
| conflict_stats->prop_conflicts_resolved++; |
| } |
| break; |
| case svn_wc_conflict_kind_tree: |
| if (svn_hash_gets(conflict_stats->tree_conflicts, path_local)) |
| { |
| svn_hash_sets(conflict_stats->tree_conflicts, path_local, NULL); |
| conflict_stats->tree_conflicts_resolved++; |
| } |
| break; |
| } |
| } |
| |
| static const char * |
| remaining_str(apr_pool_t *pool, int n_remaining) |
| { |
| return apr_psprintf(pool, Q_("%d remaining", |
| "%d remaining", |
| n_remaining), |
| n_remaining); |
| } |
| |
| static const char * |
| resolved_str(apr_pool_t *pool, int n_resolved) |
| { |
| return apr_psprintf(pool, Q_("and %d already resolved", |
| "and %d already resolved", |
| n_resolved), |
| n_resolved); |
| } |
| |
| svn_error_t * |
| svn_cl__conflict_stats_get_paths(apr_array_header_t **conflicted_paths, |
| svn_cl__conflict_stats_t *conflict_stats, |
| apr_pool_t *result_pool, |
| apr_pool_t *scratch_pool) |
| { |
| |
| int n_text = apr_hash_count(conflict_stats->text_conflicts); |
| int n_prop = apr_hash_count(conflict_stats->prop_conflicts); |
| int n_tree = apr_hash_count(conflict_stats->tree_conflicts); |
| apr_hash_t *all_conflicts; |
| |
| *conflicted_paths = NULL; |
| if (n_text == 0 && n_prop == 0 && n_tree == 0) |
| return SVN_NO_ERROR; |
| |
| /* Use a hash table to ensure paths with multiple conflicts are |
| * returned just once. */ |
| all_conflicts = apr_hash_make(result_pool); |
| if (n_text > 0) |
| { |
| apr_array_header_t *k_text; |
| int i; |
| |
| SVN_ERR(svn_hash_keys(&k_text, conflict_stats->text_conflicts, |
| scratch_pool)); |
| for (i = 0; i < k_text->nelts; i++) |
| { |
| const char *path = APR_ARRAY_IDX(k_text, i, const char *); |
| |
| svn_hash_sets(all_conflicts, path, ""); |
| } |
| } |
| |
| if (n_prop > 0) |
| { |
| apr_array_header_t *k_prop; |
| int i; |
| |
| SVN_ERR(svn_hash_keys(&k_prop, conflict_stats->prop_conflicts, |
| scratch_pool)); |
| for (i = 0; i < k_prop->nelts; i++) |
| { |
| const char *path = APR_ARRAY_IDX(k_prop, i, const char *); |
| |
| svn_hash_sets(all_conflicts, path, ""); |
| } |
| } |
| |
| if (n_tree > 0) |
| { |
| apr_array_header_t *k_tree; |
| int i; |
| |
| SVN_ERR(svn_hash_keys(&k_tree, conflict_stats->tree_conflicts, |
| scratch_pool)); |
| for (i = 0; i < k_tree->nelts; i++) |
| { |
| const char *path = APR_ARRAY_IDX(k_tree, i, const char *); |
| |
| svn_hash_sets(all_conflicts, path, ""); |
| } |
| } |
| |
| SVN_ERR(svn_hash_keys(conflicted_paths, all_conflicts, result_pool)); |
| svn_sort__array(*conflicted_paths, svn_sort_compare_paths); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_cl__print_conflict_stats(svn_cl__conflict_stats_t *conflict_stats, |
| apr_pool_t *scratch_pool) |
| { |
| int n_text = apr_hash_count(conflict_stats->text_conflicts); |
| int n_prop = apr_hash_count(conflict_stats->prop_conflicts); |
| int n_tree = apr_hash_count(conflict_stats->tree_conflicts); |
| int n_text_r = conflict_stats->text_conflicts_resolved; |
| int n_prop_r = conflict_stats->prop_conflicts_resolved; |
| int n_tree_r = conflict_stats->tree_conflicts_resolved; |
| |
| if (n_text > 0 || n_text_r > 0 |
| || n_prop > 0 || n_prop_r > 0 |
| || n_tree > 0 || n_tree_r > 0 |
| || conflict_stats->skipped_paths > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _("Summary of conflicts:\n"))); |
| |
| if (n_text_r == 0 && n_prop_r == 0 && n_tree_r == 0) |
| { |
| if (n_text > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Text conflicts: %d\n"), |
| n_text)); |
| if (n_prop > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Property conflicts: %d\n"), |
| n_prop)); |
| if (n_tree > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Tree conflicts: %d\n"), |
| n_tree)); |
| } |
| else |
| { |
| if (n_text > 0 || n_text_r > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Text conflicts: %s (%s)\n"), |
| remaining_str(scratch_pool, n_text), |
| resolved_str(scratch_pool, n_text_r))); |
| if (n_prop > 0 || n_prop_r > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Property conflicts: %s (%s)\n"), |
| remaining_str(scratch_pool, n_prop), |
| resolved_str(scratch_pool, n_prop_r))); |
| if (n_tree > 0 || n_tree_r > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Tree conflicts: %s (%s)\n"), |
| remaining_str(scratch_pool, n_tree), |
| resolved_str(scratch_pool, n_tree_r))); |
| } |
| if (conflict_stats->skipped_paths > 0) |
| SVN_ERR(svn_cmdline_printf(scratch_pool, |
| _(" Skipped paths: %d\n"), |
| conflict_stats->skipped_paths)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_cl__notifier_print_conflict_stats(void *baton, apr_pool_t *scratch_pool) |
| { |
| struct notify_baton *nb = baton; |
| |
| SVN_ERR(svn_cl__print_conflict_stats(nb->conflict_stats, scratch_pool)); |
| return SVN_NO_ERROR; |
| } |
| |
| /* The body for notify() function with standard error handling semantic. |
| * Handling of errors implemented at caller side. */ |
| static svn_error_t * |
| notify_body(struct notify_baton *nb, |
| const svn_wc_notify_t *n, |
| apr_pool_t *pool) |
| { |
| char statchar_buf[5] = " "; |
| const char *path_local; |
| |
| if (n->url) |
| path_local = n->url; |
| else |
| { |
| /* Skip the path prefix in N, if supplied, or else the path prefix |
| in NB (which was set to the current working directory). */ |
| if (n->path_prefix) |
| path_local = svn_cl__local_style_skip_ancestor(n->path_prefix, n->path, |
| pool); |
| else |
| path_local = svn_cl__local_style_skip_ancestor(nb->path_prefix, n->path, |
| pool); |
| } |
| |
| switch (n->action) |
| { |
| case svn_wc_notify_skip: |
| nb->conflict_stats->skipped_paths++; |
| if (n->content_state == svn_wc_notify_state_missing) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Skipped missing target: '%s'\n"), |
| path_local)); |
| } |
| else if (n->content_state == svn_wc_notify_state_source_missing) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("Skipped target: '%s' -- copy-source is missing\n"), |
| path_local)); |
| } |
| else if (n->content_state == svn_wc_notify_state_obstructed) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("Skipped '%s' -- obstructed by unversioned node\n"), |
| path_local)); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf(pool, _("Skipped '%s'\n"), path_local)); |
| } |
| break; |
| case svn_wc_notify_update_skip_obstruction: |
| nb->conflict_stats->skipped_paths++; |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("Skipped '%s' -- An obstructing working copy was found\n"), |
| path_local)); |
| break; |
| case svn_wc_notify_update_skip_working_only: |
| nb->conflict_stats->skipped_paths++; |
| SVN_ERR(svn_cmdline_printf( |
| pool, _("Skipped '%s' -- Has no versioned parent\n"), |
| path_local)); |
| break; |
| case svn_wc_notify_update_skip_access_denied: |
| nb->conflict_stats->skipped_paths++; |
| SVN_ERR(svn_cmdline_printf( |
| pool, _("Skipped '%s' -- Access denied\n"), |
| path_local)); |
| break; |
| case svn_wc_notify_skip_conflicted: |
| nb->conflict_stats->skipped_paths++; |
| SVN_ERR(svn_cmdline_printf( |
| pool, _("Skipped '%s' -- Node remains in conflict\n"), |
| path_local)); |
| break; |
| case svn_wc_notify_update_delete: |
| case svn_wc_notify_exclude: |
| nb->received_some_change = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, "D %s\n", path_local)); |
| break; |
| case svn_wc_notify_update_broken_lock: |
| SVN_ERR(svn_cmdline_printf(pool, "B %s\n", path_local)); |
| break; |
| |
| case svn_wc_notify_update_external_removed: |
| nb->received_some_change = TRUE; |
| if (n->err && n->err->message) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, _("Removed external '%s': %s\n"), |
| path_local, n->err->message)); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf(pool, _("Removed external '%s'\n"), |
| path_local)); |
| } |
| break; |
| |
| case svn_wc_notify_left_local_modifications: |
| SVN_ERR(svn_cmdline_printf(pool, _("Left local modifications as '%s'\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_update_replace: |
| nb->received_some_change = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, "R %s\n", path_local)); |
| break; |
| |
| case svn_wc_notify_update_add: |
| nb->received_some_change = TRUE; |
| if (n->content_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->text_conflicts, path_local); |
| SVN_ERR(svn_cmdline_printf(pool, "C %s\n", path_local)); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf(pool, "A %s\n", path_local)); |
| } |
| break; |
| |
| case svn_wc_notify_exists: |
| nb->received_some_change = TRUE; |
| if (n->content_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->text_conflicts, path_local); |
| statchar_buf[0] = 'C'; |
| } |
| else |
| statchar_buf[0] = 'E'; |
| |
| if (n->prop_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->prop_conflicts, path_local); |
| statchar_buf[1] = 'C'; |
| } |
| else if (n->prop_state == svn_wc_notify_state_merged) |
| statchar_buf[1] = 'G'; |
| |
| SVN_ERR(svn_cmdline_printf(pool, "%s %s\n", statchar_buf, path_local)); |
| break; |
| |
| case svn_wc_notify_restore: |
| SVN_ERR(svn_cmdline_printf(pool, _("Restored '%s'\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_revert: |
| SVN_ERR(svn_cmdline_printf(pool, _("Reverted '%s'\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_failed_revert: |
| SVN_ERR(svn_cmdline_printf(pool, _("Failed to revert '%s' -- " |
| "try updating instead.\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_resolved: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Resolved conflicted state of '%s'\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_resolved_text: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Merge conflicts in '%s' marked as " |
| "resolved.\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_resolved_prop: |
| SVN_ERR_ASSERT(n->prop_name && strlen(n->prop_name) > 0); |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Conflict in property '%s' at '%s' marked " |
| "as resolved.\n"), |
| n->prop_name, path_local)); |
| break; |
| |
| case svn_wc_notify_resolved_tree: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Tree conflict at '%s' marked as " |
| "resolved.\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_begin_search_tree_conflict_details: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Searching tree conflict details for '%s' " |
| "in repository:\n"), |
| path_local)); |
| nb->progress_revision = 0; |
| break; |
| |
| case svn_wc_notify_tree_conflict_details_progress: |
| /* First printf is to obliterate any previous progress printf, |
| assuming no more than 10 digit revisions. Avoid i18n so the |
| text length is known. We only need to do this if the new |
| revision is 4 digits less than the previous revision but that |
| requires counting digits. Dividing by 1000 works well |
| enough: it triggers when needed, it sometimes triggers when |
| not needed, but in typical cases it doesn't trigger as the |
| revisions don't vary much. */ |
| if (n->revision < nb->progress_revision / 1000) |
| SVN_ERR(svn_cmdline_printf(pool, "\rChecking r ")); |
| SVN_ERR(svn_cmdline_printf(pool, "\rChecking r%ld...", n->revision)); |
| nb->progress_revision = n->revision; |
| break; |
| |
| case svn_wc_notify_end_search_tree_conflict_details: |
| SVN_ERR(svn_cmdline_printf(pool, _(" done\n"))); |
| nb->progress_revision = 0; |
| break; |
| |
| case svn_wc_notify_add: |
| /* We *should* only get the MIME_TYPE if PATH is a file. If we |
| do get it, and the mime-type is not textual, note that this |
| is a binary addition. */ |
| if (n->mime_type && (svn_mime_type_is_binary(n->mime_type))) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, "A (bin) %s\n", |
| path_local)); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf(pool, "A %s\n", |
| path_local)); |
| } |
| break; |
| |
| case svn_wc_notify_delete: |
| nb->received_some_change = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, "D %s\n", |
| path_local)); |
| break; |
| |
| case svn_wc_notify_patch: |
| { |
| nb->received_some_change = TRUE; |
| if (n->content_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->text_conflicts, path_local); |
| statchar_buf[0] = 'C'; |
| } |
| else if (n->kind == svn_node_file) |
| { |
| if (n->content_state == svn_wc_notify_state_merged) |
| statchar_buf[0] = 'G'; |
| else if (n->content_state == svn_wc_notify_state_changed) |
| statchar_buf[0] = 'U'; |
| } |
| |
| if (n->prop_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->prop_conflicts, path_local); |
| statchar_buf[1] = 'C'; |
| } |
| else if (n->prop_state == svn_wc_notify_state_merged) |
| statchar_buf[1] = 'G'; |
| else if (n->prop_state == svn_wc_notify_state_changed) |
| statchar_buf[1] = 'U'; |
| |
| if (statchar_buf[0] != ' ' || statchar_buf[1] != ' ') |
| { |
| SVN_ERR(svn_cmdline_printf(pool, "%s %s\n", |
| statchar_buf, path_local)); |
| } |
| } |
| break; |
| |
| case svn_wc_notify_patch_applied_hunk: |
| nb->received_some_change = TRUE; |
| if (n->hunk_original_start != n->hunk_matched_line) |
| { |
| apr_uint64_t off; |
| const char *s; |
| const char *minus; |
| |
| if (n->hunk_matched_line > n->hunk_original_start) |
| { |
| /* If we are patching from the start of an empty file, |
| it is nicer to show offset 0 */ |
| if (n->hunk_original_start == 0 && n->hunk_matched_line == 1) |
| off = 0; /* No offset, just adding */ |
| else |
| off = n->hunk_matched_line - n->hunk_original_start; |
| |
| minus = ""; |
| } |
| else |
| { |
| off = n->hunk_original_start - n->hunk_matched_line; |
| minus = "-"; |
| } |
| |
| /* ### We're creating the localized strings without |
| * ### APR_INT64_T_FMT since it isn't translator-friendly */ |
| if (n->hunk_fuzz) |
| { |
| |
| if (n->prop_name) |
| { |
| s = _("> applied hunk ## -%lu,%lu +%lu,%lu ## " |
| "with offset %s"); |
| |
| SVN_ERR(svn_cmdline_printf(pool, |
| apr_pstrcat(pool, s, |
| "%"APR_UINT64_T_FMT |
| " and fuzz %lu (%s)\n", |
| SVN_VA_NULL), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| minus, off, n->hunk_fuzz, |
| n->prop_name)); |
| } |
| else |
| { |
| s = _("> applied hunk @@ -%lu,%lu +%lu,%lu @@ " |
| "with offset %s"); |
| |
| SVN_ERR(svn_cmdline_printf(pool, |
| apr_pstrcat(pool, s, |
| "%"APR_UINT64_T_FMT |
| " and fuzz %lu\n", |
| SVN_VA_NULL), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| minus, off, n->hunk_fuzz)); |
| } |
| } |
| else |
| { |
| |
| if (n->prop_name) |
| { |
| s = _("> applied hunk ## -%lu,%lu +%lu,%lu ## " |
| "with offset %s"); |
| SVN_ERR(svn_cmdline_printf(pool, |
| apr_pstrcat(pool, s, |
| "%"APR_UINT64_T_FMT" (%s)\n", |
| SVN_VA_NULL), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| minus, off, n->prop_name)); |
| } |
| else |
| { |
| s = _("> applied hunk @@ -%lu,%lu +%lu,%lu @@ " |
| "with offset %s"); |
| SVN_ERR(svn_cmdline_printf(pool, |
| apr_pstrcat(pool, s, |
| "%"APR_UINT64_T_FMT"\n", |
| SVN_VA_NULL), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| minus, off)); |
| } |
| } |
| } |
| else if (n->hunk_fuzz) |
| { |
| if (n->prop_name) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("> applied hunk ## -%lu,%lu +%lu,%lu ## " |
| "with fuzz %lu (%s)\n"), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| n->hunk_fuzz, |
| n->prop_name)); |
| else |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("> applied hunk @@ -%lu,%lu +%lu,%lu @@ " |
| "with fuzz %lu\n"), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| n->hunk_fuzz)); |
| |
| } |
| break; |
| |
| case svn_wc_notify_patch_rejected_hunk: |
| nb->received_some_change = TRUE; |
| |
| if (n->prop_name) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("> rejected hunk " |
| "## -%lu,%lu +%lu,%lu ## (%s)\n"), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| n->prop_name)); |
| else |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("> rejected hunk " |
| "@@ -%lu,%lu +%lu,%lu @@\n"), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length)); |
| break; |
| |
| case svn_wc_notify_patch_hunk_already_applied: |
| nb->received_some_change = TRUE; |
| if (n->prop_name) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("> hunk " |
| "## -%lu,%lu +%lu,%lu ## " |
| "already applied (%s)\n"), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length, |
| n->prop_name)); |
| else |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("> hunk " |
| "@@ -%lu,%lu +%lu,%lu @@ " |
| "already applied\n"), |
| n->hunk_original_start, |
| n->hunk_original_length, |
| n->hunk_modified_start, |
| n->hunk_modified_length)); |
| break; |
| |
| case svn_wc_notify_update_update: |
| case svn_wc_notify_merge_record_info: |
| { |
| if (n->content_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->text_conflicts, path_local); |
| statchar_buf[0] = 'C'; |
| } |
| else if (n->kind == svn_node_file) |
| { |
| if (n->content_state == svn_wc_notify_state_merged) |
| statchar_buf[0] = 'G'; |
| else if (n->content_state == svn_wc_notify_state_changed) |
| statchar_buf[0] = 'U'; |
| } |
| |
| if (n->prop_state == svn_wc_notify_state_conflicted) |
| { |
| store_path(nb, nb->conflict_stats->prop_conflicts, path_local); |
| statchar_buf[1] = 'C'; |
| } |
| else if (n->prop_state == svn_wc_notify_state_merged) |
| statchar_buf[1] = 'G'; |
| else if (n->prop_state == svn_wc_notify_state_changed) |
| statchar_buf[1] = 'U'; |
| |
| if (n->lock_state == svn_wc_notify_lock_state_unlocked) |
| statchar_buf[2] = 'B'; |
| |
| if (statchar_buf[0] != ' ' || statchar_buf[1] != ' ') |
| nb->received_some_change = TRUE; |
| |
| if (statchar_buf[0] != ' ' || statchar_buf[1] != ' ' |
| || statchar_buf[2] != ' ') |
| { |
| SVN_ERR(svn_cmdline_printf(pool, "%s %s\n", |
| statchar_buf, path_local)); |
| } |
| } |
| break; |
| |
| case svn_wc_notify_update_external: |
| /* Remember that we're now "inside" an externals definition. */ |
| ++nb->in_external; |
| |
| /* Currently this is used for checkouts and switches too. If we |
| want different output, we'll have to add new actions. */ |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("\nFetching external item into '%s':\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_failed_external: |
| /* If we are currently inside the handling of an externals |
| definition, then we can simply present n->err as a warning |
| and feel confident that after this, we aren't handling that |
| externals definition any longer. */ |
| if (nb->in_external) |
| { |
| svn_handle_warning2(stderr, n->err, "svn: "); |
| --nb->in_external; |
| SVN_ERR(svn_cmdline_printf(pool, "\n")); |
| } |
| /* Otherwise, we'll just print two warnings. Why? Because |
| svn_handle_warning2() only shows the single "best message", |
| but we have two pretty important ones: that the external at |
| '/some/path' didn't pan out, and then the more specific |
| reason why (from n->err). */ |
| else |
| { |
| svn_error_t *warn_err = |
| svn_error_createf(SVN_ERR_CL_ERROR_PROCESSING_EXTERNALS, NULL, |
| _("Error handling externals definition for '%s':"), |
| path_local); |
| svn_handle_warning2(stderr, warn_err, "svn: "); |
| svn_error_clear(warn_err); |
| svn_handle_warning2(stderr, n->err, "svn: "); |
| } |
| break; |
| |
| case svn_wc_notify_update_started: |
| if (! (nb->in_external || |
| nb->is_checkout || |
| nb->is_export)) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, _("Updating '%s':\n"), |
| path_local)); |
| } |
| break; |
| |
| case svn_wc_notify_update_completed: |
| { |
| if (SVN_IS_VALID_REVNUM(n->revision)) |
| { |
| if (nb->is_export) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("Exported external at revision %ld.\n") |
| : _("Exported revision %ld.\n"), |
| n->revision)); |
| } |
| else if (nb->is_checkout) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("Checked out external at revision %ld.\n") |
| : _("Checked out revision %ld.\n"), |
| n->revision)); |
| } |
| else |
| { |
| if (nb->received_some_change) |
| { |
| nb->received_some_change = FALSE; |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("Updated external to revision %ld.\n") |
| : _("Updated to revision %ld.\n"), |
| n->revision)); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("External at revision %ld.\n") |
| : _("At revision %ld.\n"), |
| n->revision)); |
| } |
| } |
| } |
| else /* no revision */ |
| { |
| if (nb->is_export) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("External export complete.\n") |
| : _("Export complete.\n"))); |
| } |
| else if (nb->is_checkout) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("External checkout complete.\n") |
| : _("Checkout complete.\n"))); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, nb->in_external |
| ? _("External update complete.\n") |
| : _("Update complete.\n"))); |
| } |
| } |
| } |
| |
| if (nb->in_external) |
| { |
| --nb->in_external; |
| SVN_ERR(svn_cmdline_printf(pool, "\n")); |
| } |
| break; |
| |
| case svn_wc_notify_status_external: |
| SVN_ERR(svn_cmdline_printf( |
| pool, _("\nPerforming status on external item at '%s':\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_info_external: |
| SVN_ERR(svn_cmdline_printf( |
| pool, _("\nPerforming info on external item at '%s':\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_status_completed: |
| if (SVN_IS_VALID_REVNUM(n->revision)) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Status against revision: %6ld\n"), |
| n->revision)); |
| break; |
| |
| case svn_wc_notify_commit_modified: |
| /* xgettext: Align the %s's on this and the following 4 messages */ |
| SVN_ERR(svn_cmdline_printf(pool, |
| nb->is_wc_to_repos_copy |
| ? _("Sending copy of %s\n") |
| : _("Sending %s\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_commit_added: |
| case svn_wc_notify_commit_copied: |
| if (n->mime_type && svn_mime_type_is_binary(n->mime_type)) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, |
| nb->is_wc_to_repos_copy |
| ? _("Adding copy of (bin) %s\n") |
| : _("Adding (bin) %s\n"), |
| path_local)); |
| } |
| else |
| { |
| SVN_ERR(svn_cmdline_printf(pool, |
| nb->is_wc_to_repos_copy |
| ? _("Adding copy of %s\n") |
| : _("Adding %s\n"), |
| path_local)); |
| } |
| break; |
| |
| case svn_wc_notify_commit_deleted: |
| SVN_ERR(svn_cmdline_printf(pool, |
| nb->is_wc_to_repos_copy |
| ? _("Deleting copy of %s\n") |
| : _("Deleting %s\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_commit_replaced: |
| case svn_wc_notify_commit_copied_replaced: |
| SVN_ERR(svn_cmdline_printf(pool, |
| nb->is_wc_to_repos_copy |
| ? _("Replacing copy of %s\n") |
| : _("Replacing %s\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_commit_postfix_txdelta: |
| if (! nb->sent_first_txdelta) |
| { |
| nb->sent_first_txdelta = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Transmitting file data "))); |
| } |
| |
| SVN_ERR(svn_cmdline_printf(pool, ".")); |
| break; |
| |
| case svn_wc_notify_locked: |
| SVN_ERR(svn_cmdline_printf(pool, _("'%s' locked by user '%s'.\n"), |
| path_local, n->lock->owner)); |
| break; |
| |
| case svn_wc_notify_unlocked: |
| SVN_ERR(svn_cmdline_printf(pool, _("'%s' unlocked.\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_failed_lock: |
| case svn_wc_notify_failed_unlock: |
| svn_handle_warning2(stderr, n->err, "svn: "); |
| break; |
| |
| case svn_wc_notify_changelist_set: |
| SVN_ERR(svn_cmdline_printf(pool, "A [%s] %s\n", |
| n->changelist_name, path_local)); |
| break; |
| |
| case svn_wc_notify_changelist_clear: |
| case svn_wc_notify_changelist_moved: |
| SVN_ERR(svn_cmdline_printf(pool, |
| "D [%s] %s\n", |
| n->changelist_name, path_local)); |
| break; |
| |
| case svn_wc_notify_merge_begin: |
| if (n->merge_range == NULL) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Merging differences between " |
| "repository URLs into '%s':\n"), |
| path_local)); |
| else if (n->merge_range->start == n->merge_range->end - 1 |
| || n->merge_range->start == n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf(pool, _("--- Merging r%ld into '%s':\n"), |
| n->merge_range->end, path_local)); |
| else if (n->merge_range->start - 1 == n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Reverse-merging r%ld into '%s':\n"), |
| n->merge_range->start, path_local)); |
| else if (n->merge_range->start < n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Merging r%ld through r%ld into " |
| "'%s':\n"), |
| n->merge_range->start + 1, |
| n->merge_range->end, path_local)); |
| else /* n->merge_range->start > n->merge_range->end - 1 */ |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Reverse-merging r%ld through r%ld " |
| "into '%s':\n"), |
| n->merge_range->start, |
| n->merge_range->end + 1, path_local)); |
| break; |
| |
| case svn_wc_notify_merge_record_info_begin: |
| if (!n->merge_range) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Recording mergeinfo for merge " |
| "between repository URLs into '%s':\n"), |
| path_local)); |
| } |
| else |
| { |
| if (n->merge_range->start == n->merge_range->end - 1 |
| || n->merge_range->start == n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("--- Recording mergeinfo for merge of r%ld into '%s':\n"), |
| n->merge_range->end, path_local)); |
| else if (n->merge_range->start - 1 == n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("--- Recording mergeinfo for reverse merge of r%ld into '%s':\n"), |
| n->merge_range->start, path_local)); |
| else if (n->merge_range->start < n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("--- Recording mergeinfo for merge of r%ld through r%ld into '%s':\n"), |
| n->merge_range->start + 1, n->merge_range->end, path_local)); |
| else /* n->merge_range->start > n->merge_range->end - 1 */ |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("--- Recording mergeinfo for reverse merge of r%ld through r%ld into '%s':\n"), |
| n->merge_range->start, n->merge_range->end + 1, path_local)); |
| } |
| break; |
| |
| case svn_wc_notify_merge_elide_info: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Eliding mergeinfo from '%s':\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_foreign_merge_begin: |
| if (n->merge_range == NULL) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Merging differences between " |
| "foreign repository URLs into '%s':\n"), |
| path_local)); |
| else if (n->merge_range->start == n->merge_range->end - 1 |
| || n->merge_range->start == n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Merging (from foreign repository) " |
| "r%ld into '%s':\n"), |
| n->merge_range->end, path_local)); |
| else if (n->merge_range->start - 1 == n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Reverse-merging (from foreign " |
| "repository) r%ld into '%s':\n"), |
| n->merge_range->start, path_local)); |
| else if (n->merge_range->start < n->merge_range->end) |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Merging (from foreign repository) " |
| "r%ld through r%ld into '%s':\n"), |
| n->merge_range->start + 1, |
| n->merge_range->end, path_local)); |
| else /* n->merge_range->start > n->merge_range->end - 1 */ |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("--- Reverse-merging (from foreign " |
| "repository) r%ld through r%ld into " |
| "'%s':\n"), |
| n->merge_range->start, |
| n->merge_range->end + 1, path_local)); |
| break; |
| |
| case svn_wc_notify_tree_conflict: |
| store_path(nb, nb->conflict_stats->tree_conflicts, path_local); |
| SVN_ERR(svn_cmdline_printf(pool, " C %s\n", path_local)); |
| break; |
| |
| case svn_wc_notify_update_shadowed_add: |
| nb->received_some_change = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, " A %s\n", path_local)); |
| break; |
| |
| case svn_wc_notify_update_shadowed_update: |
| nb->received_some_change = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, " U %s\n", path_local)); |
| break; |
| |
| case svn_wc_notify_update_shadowed_delete: |
| nb->received_some_change = TRUE; |
| SVN_ERR(svn_cmdline_printf(pool, " D %s\n", path_local)); |
| break; |
| |
| case svn_wc_notify_property_modified: |
| case svn_wc_notify_property_added: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("property '%s' set on '%s'\n"), |
| n->prop_name, path_local)); |
| break; |
| |
| case svn_wc_notify_property_deleted: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("property '%s' deleted from '%s'.\n"), |
| n->prop_name, path_local)); |
| break; |
| |
| case svn_wc_notify_property_deleted_nonexistent: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Attempting to delete nonexistent " |
| "property '%s' on '%s'\n"), n->prop_name, |
| path_local)); |
| break; |
| |
| case svn_wc_notify_revprop_set: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("property '%s' set on repository revision %ld\n"), |
| n->prop_name, n->revision)); |
| break; |
| |
| case svn_wc_notify_revprop_deleted: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("property '%s' deleted from repository revision %ld\n"), |
| n->prop_name, n->revision)); |
| break; |
| |
| case svn_wc_notify_upgraded_path: |
| SVN_ERR(svn_cmdline_printf(pool, _("Upgraded '%s'\n"), path_local)); |
| break; |
| |
| case svn_wc_notify_url_redirect: |
| SVN_ERR(svn_cmdline_printf(pool, _("Redirecting to URL '%s':\n"), |
| n->url)); |
| break; |
| |
| case svn_wc_notify_path_nonexistent: |
| SVN_ERR(svn_cmdline_printf(pool, "%s\n", |
| apr_psprintf(pool, _("'%s' is not under version control"), |
| path_local))); |
| break; |
| |
| case svn_wc_notify_conflict_resolver_starting: |
| /* Once all operations invoke the interactive conflict resolution after |
| * they've completed, we can run svn_cl__notifier_print_conflict_stats() |
| * here. */ |
| break; |
| |
| case svn_wc_notify_conflict_resolver_done: |
| break; |
| |
| case svn_wc_notify_foreign_copy_begin: |
| if (n->merge_range == NULL) |
| { |
| SVN_ERR(svn_cmdline_printf( |
| pool, |
| _("--- Copying from foreign repository URL '%s':\n"), |
| n->url)); |
| } |
| break; |
| |
| case svn_wc_notify_move_broken: |
| SVN_ERR(svn_cmdline_printf(pool, |
| _("Breaking move with source path '%s'\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_cleanup_external: |
| SVN_ERR(svn_cmdline_printf |
| (pool, _("Performing cleanup on external item at '%s'.\n"), |
| path_local)); |
| break; |
| |
| case svn_wc_notify_commit_finalizing: |
| if (nb->sent_first_txdelta) |
| { |
| SVN_ERR(svn_cmdline_printf(pool, _("done\n"))); |
| } |
| SVN_ERR(svn_cmdline_printf(pool, _("Committing transaction...\n"))); |
| break; |
| |
| default: |
| break; |
| } |
| |
| SVN_ERR(svn_cmdline_fflush(stdout)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| /* This implements `svn_wc_notify_func2_t'. |
| * NOTE: This function can't fail, so we just ignore any print errors. */ |
| static void |
| notify(void *baton, const svn_wc_notify_t *n, apr_pool_t *pool) |
| { |
| struct notify_baton *nb = baton; |
| svn_error_t *err; |
| |
| err = notify_body(nb, n, pool); |
| |
| /* If we had no errors before, print this error to stderr. Else, don't print |
| anything. The user already knows there were some output errors, |
| so there is no point in flooding her with an error per notification. */ |
| if (err && !nb->had_print_error) |
| { |
| nb->had_print_error = TRUE; |
| /* Issue #3014: |
| * Don't print anything on broken pipes. The pipe was likely |
| * closed by the process at the other end. We expect that |
| * process to perform error reporting as necessary. |
| * |
| * ### This assumes that there is only one error in a chain for |
| * ### SVN_ERR_IO_PIPE_WRITE_ERROR. See svn_cmdline_fputs(). */ |
| if (err->apr_err != SVN_ERR_IO_PIPE_WRITE_ERROR) |
| svn_handle_error2(err, stderr, FALSE, "svn: "); |
| } |
| svn_error_clear(err); |
| } |
| |
| svn_error_t * |
| svn_cl__get_notifier(svn_wc_notify_func2_t *notify_func_p, |
| void **notify_baton_p, |
| svn_cl__conflict_stats_t *conflict_stats, |
| apr_pool_t *pool) |
| { |
| struct notify_baton *nb = apr_pcalloc(pool, sizeof(*nb)); |
| |
| nb->received_some_change = FALSE; |
| nb->sent_first_txdelta = FALSE; |
| nb->is_checkout = FALSE; |
| nb->is_export = FALSE; |
| nb->is_wc_to_repos_copy = FALSE; |
| nb->in_external = 0; |
| nb->progress_revision = 0; |
| nb->had_print_error = FALSE; |
| nb->conflict_stats = conflict_stats; |
| SVN_ERR(svn_dirent_get_absolute(&nb->path_prefix, "", pool)); |
| |
| *notify_func_p = notify; |
| *notify_baton_p = nb; |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_cl__notifier_mark_checkout(void *baton) |
| { |
| struct notify_baton *nb = baton; |
| |
| nb->is_checkout = TRUE; |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_cl__notifier_mark_export(void *baton) |
| { |
| struct notify_baton *nb = baton; |
| |
| nb->is_export = TRUE; |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_cl__notifier_mark_wc_to_repos_copy(void *baton) |
| { |
| struct notify_baton *nb = baton; |
| |
| nb->is_wc_to_repos_copy = TRUE; |
| return SVN_NO_ERROR; |
| } |
| |
| void |
| svn_cl__check_externals_failed_notify_wrapper(void *baton, |
| const svn_wc_notify_t *n, |
| apr_pool_t *pool) |
| { |
| struct svn_cl__check_externals_failed_notify_baton *nwb = baton; |
| |
| if (n->action == svn_wc_notify_failed_external) |
| nwb->had_externals_error = TRUE; |
| |
| if (nwb->wrapped_func) |
| nwb->wrapped_func(nwb->wrapped_baton, n, pool); |
| } |
