diff options
Diffstat (limited to 'subversion/libsvn_wc/tree_conflicts.c')
| -rw-r--r-- | subversion/libsvn_wc/tree_conflicts.c | 513 |
1 files changed, 513 insertions, 0 deletions
diff --git a/subversion/libsvn_wc/tree_conflicts.c b/subversion/libsvn_wc/tree_conflicts.c new file mode 100644 index 0000000..4445c96 --- /dev/null +++ b/subversion/libsvn_wc/tree_conflicts.c @@ -0,0 +1,513 @@ +/* + * tree_conflicts.c: Storage of tree conflict descriptions in the WC. + * + * ==================================================================== + * 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. + * ==================================================================== + */ + +#include "svn_dirent_uri.h" +#include "svn_path.h" +#include "svn_types.h" +#include "svn_pools.h" + +#include "tree_conflicts.h" +#include "conflicts.h" +#include "wc.h" + +#include "private/svn_skel.h" +#include "private/svn_wc_private.h" +#include "private/svn_token.h" + +#include "svn_private_config.h" + +/* ### this should move to a more general location... */ +/* A map for svn_node_kind_t values. */ +/* FIXME: this mapping defines a different representation of + svn_node_unknown than the one defined in token-map.h */ +static const svn_token_map_t node_kind_map[] = +{ + { "none", svn_node_none }, + { "file", svn_node_file }, + { "dir", svn_node_dir }, + { "", svn_node_unknown }, + { NULL } +}; + +/* A map for svn_wc_operation_t values. */ +const svn_token_map_t svn_wc__operation_map[] = +{ + { "none", svn_wc_operation_none }, + { "update", svn_wc_operation_update }, + { "switch", svn_wc_operation_switch }, + { "merge", svn_wc_operation_merge }, + { NULL } +}; + +/* A map for svn_wc_conflict_action_t values. */ +const svn_token_map_t svn_wc__conflict_action_map[] = +{ + { "edited", svn_wc_conflict_action_edit }, + { "deleted", svn_wc_conflict_action_delete }, + { "added", svn_wc_conflict_action_add }, + { "replaced", svn_wc_conflict_action_replace }, + { NULL } +}; + +/* A map for svn_wc_conflict_reason_t values. */ +const svn_token_map_t svn_wc__conflict_reason_map[] = +{ + { "edited", svn_wc_conflict_reason_edited }, + { "deleted", svn_wc_conflict_reason_deleted }, + { "missing", svn_wc_conflict_reason_missing }, + { "obstructed", svn_wc_conflict_reason_obstructed }, + { "added", svn_wc_conflict_reason_added }, + { "replaced", svn_wc_conflict_reason_replaced }, + { "unversioned", svn_wc_conflict_reason_unversioned }, + { "moved-away", svn_wc_conflict_reason_moved_away }, + { "moved-here", svn_wc_conflict_reason_moved_here }, + { NULL } +}; + + +/* */ +static svn_boolean_t +is_valid_version_info_skel(const svn_skel_t *skel) +{ + return (svn_skel__list_length(skel) == 5 + && svn_skel__matches_atom(skel->children, "version") + && skel->children->next->is_atom + && skel->children->next->next->is_atom + && skel->children->next->next->next->is_atom + && skel->children->next->next->next->next->is_atom); +} + + +/* */ +static svn_boolean_t +is_valid_conflict_skel(const svn_skel_t *skel) +{ + int i; + + if (svn_skel__list_length(skel) != 8 + || !svn_skel__matches_atom(skel->children, "conflict")) + return FALSE; + + /* 5 atoms ... */ + skel = skel->children->next; + for (i = 5; i--; skel = skel->next) + if (!skel->is_atom) + return FALSE; + + /* ... and 2 version info skels. */ + return (is_valid_version_info_skel(skel) + && is_valid_version_info_skel(skel->next)); +} + + +/* Parse the enumeration value in VALUE into a plain + * 'int', using MAP to convert from strings to enumeration values. + * In MAP, a null .str field marks the end of the map. + */ +static svn_error_t * +read_enum_field(int *result, + const svn_token_map_t *map, + const svn_skel_t *skel) +{ + int value = svn_token__from_mem(map, skel->data, skel->len); + + if (value == SVN_TOKEN_UNKNOWN) + return svn_error_create(SVN_ERR_WC_CORRUPT, NULL, + _("Unknown enumeration value in tree conflict " + "description")); + + *result = value; + + return SVN_NO_ERROR; +} + + +/* Parse the conflict info fields from SKEL into *VERSION_INFO. */ +static svn_error_t * +read_node_version_info(const svn_wc_conflict_version_t **version_info, + const svn_skel_t *skel, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + int n; + const char *repos_root; + const char *repos_relpath; + svn_revnum_t peg_rev; + svn_node_kind_t kind; + + if (!is_valid_version_info_skel(skel)) + return svn_error_create(SVN_ERR_WC_CORRUPT, NULL, + _("Invalid version info in tree conflict " + "description")); + + repos_root = apr_pstrmemdup(scratch_pool, + skel->children->next->data, + skel->children->next->len); + if (*repos_root == '\0') + { + *version_info = NULL; + return SVN_NO_ERROR; + } + + /* Apply the Subversion 1.7+ url canonicalization rules to a pre 1.7 url */ + repos_root = svn_uri_canonicalize(repos_root, result_pool); + + peg_rev = SVN_STR_TO_REV(apr_pstrmemdup(scratch_pool, + skel->children->next->next->data, + skel->children->next->next->len)); + + repos_relpath = apr_pstrmemdup(result_pool, + skel->children->next->next->next->data, + skel->children->next->next->next->len); + + SVN_ERR(read_enum_field(&n, node_kind_map, + skel->children->next->next->next->next)); + kind = (svn_node_kind_t)n; + + *version_info = svn_wc_conflict_version_create2(repos_root, + NULL, + repos_relpath, + peg_rev, + kind, + result_pool); + + return SVN_NO_ERROR; +} + + +svn_error_t * +svn_wc__deserialize_conflict(const svn_wc_conflict_description2_t **conflict, + const svn_skel_t *skel, + const char *dir_path, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + const char *victim_basename; + const char *victim_abspath; + svn_node_kind_t node_kind; + svn_wc_operation_t operation; + svn_wc_conflict_action_t action; + svn_wc_conflict_reason_t reason; + const svn_wc_conflict_version_t *src_left_version; + const svn_wc_conflict_version_t *src_right_version; + int n; + svn_wc_conflict_description2_t *new_conflict; + + if (!is_valid_conflict_skel(skel)) + return svn_error_createf(SVN_ERR_WC_CORRUPT, NULL, + _("Invalid conflict info '%s' in tree conflict " + "description"), + skel ? svn_skel__unparse(skel, scratch_pool)->data + : "(null)"); + + /* victim basename */ + victim_basename = apr_pstrmemdup(scratch_pool, + skel->children->next->data, + skel->children->next->len); + if (victim_basename[0] == '\0') + return svn_error_create(SVN_ERR_WC_CORRUPT, NULL, + _("Empty 'victim' field in tree conflict " + "description")); + + /* node_kind */ + SVN_ERR(read_enum_field(&n, node_kind_map, skel->children->next->next)); + node_kind = (svn_node_kind_t)n; + if (node_kind != svn_node_file && node_kind != svn_node_dir) + return svn_error_create(SVN_ERR_WC_CORRUPT, NULL, + _("Invalid 'node_kind' field in tree conflict description")); + + /* operation */ + SVN_ERR(read_enum_field(&n, svn_wc__operation_map, + skel->children->next->next->next)); + operation = (svn_wc_operation_t)n; + + SVN_ERR(svn_dirent_get_absolute(&victim_abspath, + svn_dirent_join(dir_path, victim_basename, scratch_pool), + scratch_pool)); + + /* action */ + SVN_ERR(read_enum_field(&n, svn_wc__conflict_action_map, + skel->children->next->next->next->next)); + action = n; + + /* reason */ + SVN_ERR(read_enum_field(&n, svn_wc__conflict_reason_map, + skel->children->next->next->next->next->next)); + reason = n; + + /* Let's just make it a bit easier on ourself here... */ + skel = skel->children->next->next->next->next->next->next; + + /* src_left_version */ + SVN_ERR(read_node_version_info(&src_left_version, skel, + result_pool, scratch_pool)); + + /* src_right_version */ + SVN_ERR(read_node_version_info(&src_right_version, skel->next, + result_pool, scratch_pool)); + + new_conflict = svn_wc_conflict_description_create_tree2(victim_abspath, + node_kind, operation, src_left_version, src_right_version, + result_pool); + new_conflict->action = action; + new_conflict->reason = reason; + + *conflict = new_conflict; + + return SVN_NO_ERROR; +} + + +/* Prepend to SKEL the string corresponding to enumeration value N, as found + * in MAP. */ +static void +skel_prepend_enum(svn_skel_t *skel, + const svn_token_map_t *map, + int n, + apr_pool_t *result_pool) +{ + svn_skel__prepend(svn_skel__str_atom(svn_token__to_word(map, n), + result_pool), skel); +} + + +/* Prepend to PARENT_SKEL the several fields that represent VERSION_INFO, */ +static svn_error_t * +prepend_version_info_skel(svn_skel_t *parent_skel, + const svn_wc_conflict_version_t *version_info, + apr_pool_t *pool) +{ + svn_skel_t *skel = svn_skel__make_empty_list(pool); + + /* node_kind */ + skel_prepend_enum(skel, node_kind_map, version_info->node_kind, pool); + + /* path_in_repos */ + svn_skel__prepend(svn_skel__str_atom(version_info->path_in_repos + ? version_info->path_in_repos + : "", pool), skel); + + /* peg_rev */ + svn_skel__prepend(svn_skel__str_atom(apr_psprintf(pool, "%ld", + version_info->peg_rev), + pool), skel); + + /* repos_url */ + svn_skel__prepend(svn_skel__str_atom(version_info->repos_url + ? version_info->repos_url + : "", pool), skel); + + svn_skel__prepend(svn_skel__str_atom("version", pool), skel); + + SVN_ERR_ASSERT(is_valid_version_info_skel(skel)); + + svn_skel__prepend(skel, parent_skel); + + return SVN_NO_ERROR; +} + + +svn_error_t * +svn_wc__serialize_conflict(svn_skel_t **skel, + const svn_wc_conflict_description2_t *conflict, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + /* A conflict version struct with all fields null/invalid. */ + static const svn_wc_conflict_version_t null_version = { + NULL, SVN_INVALID_REVNUM, NULL, svn_node_unknown }; + svn_skel_t *c_skel = svn_skel__make_empty_list(result_pool); + const char *victim_basename; + + /* src_right_version */ + if (conflict->src_right_version) + SVN_ERR(prepend_version_info_skel(c_skel, conflict->src_right_version, + result_pool)); + else + SVN_ERR(prepend_version_info_skel(c_skel, &null_version, result_pool)); + + /* src_left_version */ + if (conflict->src_left_version) + SVN_ERR(prepend_version_info_skel(c_skel, conflict->src_left_version, + result_pool)); + else + SVN_ERR(prepend_version_info_skel(c_skel, &null_version, result_pool)); + + /* reason */ + skel_prepend_enum(c_skel, svn_wc__conflict_reason_map, conflict->reason, + result_pool); + + /* action */ + skel_prepend_enum(c_skel, svn_wc__conflict_action_map, conflict->action, + result_pool); + + /* operation */ + skel_prepend_enum(c_skel, svn_wc__operation_map, conflict->operation, + result_pool); + + /* node_kind */ + SVN_ERR_ASSERT(conflict->node_kind == svn_node_dir + || conflict->node_kind == svn_node_file); + skel_prepend_enum(c_skel, node_kind_map, conflict->node_kind, result_pool); + + /* Victim path (escaping separator chars). */ + victim_basename = svn_dirent_basename(conflict->local_abspath, result_pool); + SVN_ERR_ASSERT(victim_basename[0]); + svn_skel__prepend(svn_skel__str_atom(victim_basename, result_pool), c_skel); + + svn_skel__prepend(svn_skel__str_atom("conflict", result_pool), c_skel); + + SVN_ERR_ASSERT(is_valid_conflict_skel(c_skel)); + + *skel = c_skel; + + return SVN_NO_ERROR; +} + + +svn_error_t * +svn_wc__del_tree_conflict(svn_wc_context_t *wc_ctx, + const char *victim_abspath, + apr_pool_t *scratch_pool) +{ + SVN_ERR_ASSERT(svn_dirent_is_absolute(victim_abspath)); + + SVN_ERR(svn_wc__db_op_mark_resolved(wc_ctx->db, victim_abspath, + FALSE, FALSE, TRUE, NULL, + scratch_pool)); + + return SVN_NO_ERROR; + } + +svn_error_t * +svn_wc__add_tree_conflict(svn_wc_context_t *wc_ctx, + const svn_wc_conflict_description2_t *conflict, + apr_pool_t *scratch_pool) +{ + svn_boolean_t existing_conflict; + svn_skel_t *conflict_skel; + svn_error_t *err; + + SVN_ERR_ASSERT(conflict != NULL); + SVN_ERR_ASSERT(conflict->operation == svn_wc_operation_merge + || (conflict->reason != svn_wc_conflict_reason_moved_away + && conflict->reason != svn_wc_conflict_reason_moved_here) + ); + + /* Re-adding an existing tree conflict victim is an error. */ + err = svn_wc__internal_conflicted_p(NULL, NULL, &existing_conflict, + wc_ctx->db, conflict->local_abspath, + scratch_pool); + if (err) + { + if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND) + return svn_error_trace(err); + + svn_error_clear(err); + } + else if (existing_conflict) + return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL, + _("Attempt to add tree conflict that already " + "exists at '%s'"), + svn_dirent_local_style(conflict->local_abspath, + scratch_pool)); + else if (!conflict) + return SVN_NO_ERROR; + + conflict_skel = svn_wc__conflict_skel_create(scratch_pool); + + SVN_ERR(svn_wc__conflict_skel_add_tree_conflict(conflict_skel, wc_ctx->db, + conflict->local_abspath, + conflict->reason, + conflict->action, + NULL, + scratch_pool, scratch_pool)); + + switch(conflict->operation) + { + case svn_wc_operation_update: + default: + SVN_ERR(svn_wc__conflict_skel_set_op_update(conflict_skel, + conflict->src_left_version, + conflict->src_right_version, + scratch_pool, scratch_pool)); + break; + case svn_wc_operation_switch: + SVN_ERR(svn_wc__conflict_skel_set_op_switch(conflict_skel, + conflict->src_left_version, + conflict->src_right_version, + scratch_pool, scratch_pool)); + break; + case svn_wc_operation_merge: + SVN_ERR(svn_wc__conflict_skel_set_op_merge(conflict_skel, + conflict->src_left_version, + conflict->src_right_version, + scratch_pool, scratch_pool)); + break; + } + + return svn_error_trace( + svn_wc__db_op_mark_conflict(wc_ctx->db, conflict->local_abspath, + conflict_skel, NULL, scratch_pool)); +} + + +svn_error_t * +svn_wc__get_tree_conflict(const svn_wc_conflict_description2_t **tree_conflict, + svn_wc_context_t *wc_ctx, + const char *local_abspath, + apr_pool_t *result_pool, + apr_pool_t *scratch_pool) +{ + const apr_array_header_t *conflicts; + int i; + SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath)); + + SVN_ERR(svn_wc__read_conflicts(&conflicts, + wc_ctx->db, local_abspath, FALSE, + scratch_pool, scratch_pool)); + + if (!conflicts || conflicts->nelts == 0) + { + *tree_conflict = NULL; + return SVN_NO_ERROR; + } + + for (i = 0; i < conflicts->nelts; i++) + { + const svn_wc_conflict_description2_t *desc; + + desc = APR_ARRAY_IDX(conflicts, i, svn_wc_conflict_description2_t *); + + if (desc->kind == svn_wc_conflict_kind_tree) + { + *tree_conflict = svn_wc__conflict_description2_dup(desc, + result_pool); + return SVN_NO_ERROR; + } + } + + *tree_conflict = NULL; + return SVN_NO_ERROR; +} + |
