| /* deltify.c --- deltification and undeltification of nodes. |
| * |
| * ==================================================================== |
| * Copyright (c) 2000-2002 CollabNet. All rights reserved. |
| * |
| * This software is licensed as described in the file COPYING, which |
| * you should have received as part of this distribution. The terms |
| * are also available at http://subversion.tigris.org/license-1.html. |
| * If newer versions of this license are posted there, you may use a |
| * newer version instead, at your option. |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals. For exact contribution history, see the revision |
| * history and logs, available at http://subversion.tigris.org/. |
| * ==================================================================== |
| */ |
| |
| #include <string.h> |
| #include <db.h> |
| |
| #include "svn_fs.h" |
| #include "svn_pools.h" |
| #include "svn_path.h" |
| |
| #include "fs.h" |
| #include "nodes-table.h" |
| #include "node-rev.h" |
| #include "reps-strings.h" |
| #include "dag.h" |
| #include "id.h" |
| |
| |
| /* Stable nodes and deltification. */ |
| |
| /* In FS, change TARGET's representation to be a delta against SOURCE, |
| as part of TRAIL. If TARGET or SOURCE does not exist, do nothing |
| and return success. */ |
| static svn_error_t * |
| deltify (svn_fs_id_t *target_id, |
| svn_fs_id_t *source_id, |
| svn_fs_t *fs, |
| int props_only, |
| trail_t *trail) |
| { |
| skel_t |
| *source_nr, /* source node revision */ |
| *target_nr; /* target node revision */ |
| |
| const char |
| *target_pkey, /* target property rep key */ |
| *target_dkey, /* target data rep key */ |
| *source_pkey, /* source property rep key */ |
| *source_dkey; /* source data rep key */ |
| |
| skel_t |
| *target_pkey_skel, /* target property rep key skel */ |
| *target_dkey_skel, /* target data rep key skel */ |
| *source_pkey_skel, /* source property rep key skel */ |
| *source_dkey_skel; /* source data rep key skel */ |
| |
| /* Turn those IDs into skels, so we can get the rep keys. */ |
| SVN_ERR (svn_fs__get_node_revision (&target_nr, fs, target_id, trail)); |
| SVN_ERR (svn_fs__get_node_revision (&source_nr, fs, source_id, trail)); |
| |
| /* Check that target and source exist. It is not an error to |
| attempt to deltify something that does not exist, or deltify |
| against a non-existent base. However, nothing happens. */ |
| if ((target_nr == NULL) || (source_nr == NULL)) |
| return SVN_NO_ERROR; |
| |
| /* We have a target and a source. Get all the rep keys... */ |
| { |
| |
| /* Target property key. */ |
| target_pkey_skel = SVN_FS__NR_PROP_KEY (target_nr); |
| if (target_pkey_skel->len != 0) { |
| target_pkey = apr_pstrndup (trail->pool, |
| target_pkey_skel->data, |
| target_pkey_skel->len); |
| } |
| else |
| target_pkey = NULL; |
| |
| /* Target data key. */ |
| target_dkey_skel = SVN_FS__NR_DATA_KEY (target_nr); |
| if (target_dkey_skel->len != 0) { |
| target_dkey = apr_pstrndup (trail->pool, |
| target_dkey_skel->data, |
| target_dkey_skel->len); |
| } |
| else |
| target_dkey = NULL; |
| |
| /* Source property key. */ |
| source_pkey_skel = SVN_FS__NR_PROP_KEY (source_nr); |
| if (source_pkey_skel->len != 0) { |
| source_pkey = apr_pstrndup (trail->pool, |
| source_pkey_skel->data, |
| source_pkey_skel->len); |
| } |
| else |
| source_pkey = NULL; |
| |
| /* Source data key. */ |
| source_dkey_skel = SVN_FS__NR_DATA_KEY (source_nr); |
| if (source_dkey_skel->len != 0) { |
| source_dkey = apr_pstrndup (trail->pool, |
| source_dkey_skel->data, |
| source_dkey_skel->len); |
| } |
| else |
| source_dkey = NULL; |
| } |
| |
| if ((target_pkey && source_pkey) |
| && (strcmp (target_pkey, source_pkey))) |
| SVN_ERR (svn_fs__rep_deltify (fs, target_pkey, source_pkey, trail)); |
| |
| if ((target_dkey && source_dkey) && (! props_only) |
| && (strcmp (target_dkey, source_dkey))) |
| SVN_ERR (svn_fs__rep_deltify (fs, target_dkey, source_dkey, trail)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| /* In FS, change ID's representation to be a fulltext representation |
| as part of TRAIL. If ID does not exist, do nothing and return |
| success. */ |
| static svn_error_t * |
| undeltify (svn_fs_id_t *id, |
| svn_fs_t *fs, |
| trail_t *trail) |
| { |
| skel_t *node_rev; |
| const char *prop_key = NULL, *data_key = NULL; |
| skel_t *pkey_skel, *dkey_skel; |
| |
| /* Turn ID into a skel so we can get the rep keys. */ |
| SVN_ERR (svn_fs__get_node_revision (&node_rev, fs, id, trail)); |
| |
| /* Check that target exists. If not, no big deal -- just do |
| nothing. */ |
| if (node_rev == NULL) |
| return SVN_NO_ERROR; |
| |
| /* Get the property key. */ |
| pkey_skel = SVN_FS__NR_PROP_KEY (node_rev); |
| if (pkey_skel->len != 0) |
| prop_key = apr_pstrndup (trail->pool, pkey_skel->data, pkey_skel->len); |
| |
| /* Get the data key. */ |
| dkey_skel = SVN_FS__NR_DATA_KEY (node_rev); |
| if (dkey_skel->len != 0) |
| data_key = apr_pstrndup (trail->pool, dkey_skel->data, dkey_skel->len); |
| |
| /* Undeltify the properties. */ |
| if (prop_key) |
| SVN_ERR (svn_fs__rep_undeltify (fs, prop_key, trail)); |
| |
| /* Undeltify the data (entries list for directories, file contents |
| for files). */ |
| if (data_key) |
| SVN_ERR (svn_fs__rep_undeltify (fs, data_key, trail)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /* Deltify TARGET_ID in FS against its immediately successor (also in |
| FS). Pass IS_DIR through to deltify(), and do all of this stuff as |
| part of TRAIL. */ |
| static svn_error_t * |
| deltify_by_id (svn_fs_t *fs, |
| svn_fs_id_t *target_id, |
| int is_dir, |
| trail_t *trail) |
| { |
| svn_fs_id_t *source_id = NULL, *tmp_id; |
| apr_size_t len = svn_fs__id_length (target_id); |
| dag_node_t *node; |
| |
| /* Increment TMP_ID as a regular successor of TARGET_ID, and see if |
| it exists in FS. */ |
| tmp_id = svn_fs__id_copy (target_id, trail->pool); |
| tmp_id[len - 1]++; |
| if (SVN_NO_ERROR == svn_fs__dag_get_node (&node, fs, tmp_id, trail)) |
| { |
| source_id = tmp_id; |
| } |
| else |
| { |
| /* If that doesn't exist, we'll branch TARGET_ID, and see if |
| that exists. */ |
| apr_size_t i; |
| tmp_id = apr_pcalloc (trail->pool, sizeof (*tmp_id) * (len + 3)); |
| for (i = 0; i < len; i++) |
| { |
| tmp_id[i] = target_id[i]; |
| } |
| tmp_id[len] = 1; |
| tmp_id[len + 1] = 1; |
| tmp_id[len + 2] = -1; |
| |
| if (SVN_NO_ERROR == svn_fs__dag_get_node (&node, fs, tmp_id, trail)) |
| { |
| source_id = tmp_id; |
| } |
| } |
| |
| /* If we found a valid source ID, perform the deltification step. */ |
| if (source_id) |
| SVN_ERR (deltify (target_id, source_id, fs, is_dir, trail)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| /* Deltify or undeltify a directory PATH under ROOT in FS (whose |
| node-id is ID). If DO_DELTIFY is non-zero, drive deltify_by_id(), |
| else drive undeltify(). Use RECURSE to determine if this function |
| should recursively deltify or undeltify directories. */ |
| static svn_error_t * |
| deltify_undeltify (svn_fs_t *fs, |
| svn_fs_root_t *root, |
| const char *path, |
| svn_fs_id_t *id, |
| int do_deltify, |
| int recurse, |
| trail_t *trail) |
| { |
| apr_pool_t *subpool = svn_pool_create (trail->pool); |
| svn_stringbuf_t *full_path = svn_stringbuf_create (path, subpool); |
| dag_node_t *node; |
| int is_dir = 0; |
| |
| /* Get the node from its ID, and figure out if it is a directory. */ |
| SVN_ERR (svn_fs__dag_get_node (&node, fs, id, trail)); |
| is_dir = svn_fs__dag_is_directory (node); |
| |
| /* If this is a directory and we have been asked to recurse, then |
| call this function for each of this ID's entries. */ |
| if (is_dir && recurse) |
| { |
| apr_hash_t *entries; |
| apr_hash_index_t *hi; |
| |
| SVN_ERR (svn_fs__dag_dir_entries_hash (&entries, node, trail)); |
| for (hi = apr_hash_first (subpool, entries); hi; hi = apr_hash_next (hi)) |
| { |
| const void *key; |
| void *val; |
| apr_ssize_t klen; |
| svn_fs_dirent_t *entry; |
| |
| /* KEY will be the entry name in source, VAL the dirent */ |
| apr_hash_this (hi, &key, &klen, &val); |
| entry = val; |
| |
| /* Construct the full path of this entry, and recurse. */ |
| svn_stringbuf_set (full_path, path); |
| svn_path_add_component_nts (full_path, entry->name); |
| SVN_ERR (deltify_undeltify (fs, root, full_path->data, entry->id, |
| do_deltify, recurse, trail)); |
| } |
| } |
| |
| /* Do the real work of ... */ |
| if (do_deltify) |
| { |
| /* ... deltification. */ |
| SVN_ERR (deltify_by_id (fs, id, is_dir, trail)); |
| } |
| else |
| { |
| /* ... un-deltification. */ |
| SVN_ERR (undeltify (id, fs, trail)); |
| } |
| |
| /* Destroy per-iteration subpool. */ |
| svn_pool_destroy (subpool); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| struct deltify_args { |
| svn_fs_t *fs; |
| svn_fs_root_t *root; |
| const char *path; |
| svn_fs_id_t *id; |
| int recursive; |
| }; |
| |
| |
| static svn_error_t * |
| txn_body_deltify (void *baton, trail_t *trail) |
| { |
| struct deltify_args *args = baton; |
| int is_dir = 0; |
| dag_node_t *node; |
| |
| /* Use the ID to determine if the target here is a directory. */ |
| SVN_ERR (svn_fs__dag_get_node (&node, args->fs, args->id, trail)); |
| is_dir = svn_fs__dag_is_directory (node); |
| |
| /* Perform the deltification step. */ |
| SVN_ERR (deltify_undeltify (args->fs, args->root, args->path, args->id, |
| 1, args->recursive, trail)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| static svn_error_t * |
| txn_body_undeltify (void *baton, trail_t *trail) |
| { |
| struct deltify_args *args = baton; |
| int is_dir = 0; |
| dag_node_t *node; |
| |
| /* Use the ID to determine if the target here is a directory. */ |
| SVN_ERR (svn_fs__dag_get_node (&node, args->fs, args->id, trail)); |
| is_dir = svn_fs__dag_is_directory (node); |
| |
| /* Perform the un-deltification step. */ |
| SVN_ERR (deltify_undeltify (args->fs, args->root, args->path, args->id, |
| 0, args->recursive, trail)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /*** Public (or semi-public) interfaces. ***/ |
| |
| svn_error_t * |
| svn_fs_deltify (svn_fs_root_t *root, |
| const char *path, |
| int recursive, |
| apr_pool_t *pool) |
| { |
| struct deltify_args args; |
| |
| if (! svn_fs_is_revision_root (root)) |
| return svn_error_create (SVN_ERR_FS_NOT_REVISION_ROOT, 0, NULL, pool, |
| "svn_fs_deltify: root is not a revision root"); |
| |
| args.fs = svn_fs_root_fs (root); |
| args.root = root; |
| args.recursive = recursive; |
| args.path = path; |
| |
| /* Get the ID of the target, which is the node we're changing. */ |
| SVN_ERR (svn_fs_node_id (&(args.id), root, path, pool)); |
| |
| SVN_ERR (svn_fs__retry_txn (args.fs, txn_body_deltify, &args, pool)); |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| |
| svn_error_t * |
| svn_fs_undeltify (svn_fs_root_t *root, |
| const char *path, |
| int recursive, |
| apr_pool_t *pool) |
| { |
| struct deltify_args args; |
| |
| if (! svn_fs_is_revision_root (root)) |
| return svn_error_create (SVN_ERR_FS_NOT_REVISION_ROOT, 0, NULL, pool, |
| "svn_fs_deltify: root is not a revision root"); |
| |
| args.fs = svn_fs_root_fs (root); |
| args.root = root; |
| args.recursive = recursive; |
| args.path = path; |
| |
| /* Get the ID of the target, which is the node we're changing. */ |
| SVN_ERR (svn_fs_node_id (&(args.id), root, path, pool)); |
| |
| SVN_ERR (svn_fs__retry_txn (args.fs, txn_body_undeltify, &args, pool)); |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| svn_error_t * |
| svn_fs__stable_node (svn_fs_t *fs, |
| svn_fs_id_t *id, |
| trail_t *trail) |
| { |
| svn_fs_id_t *predecessor_id = svn_fs__id_predecessor (id, trail->pool); |
| int is_dir = 0; |
| dag_node_t *node; |
| |
| SVN_ERR (svn_fs__dag_get_node (&node, fs, id, trail)); |
| is_dir = svn_fs__dag_is_directory (node); |
| |
| if (predecessor_id != NULL) |
| SVN_ERR (deltify (predecessor_id, id, fs, is_dir ? 1 : 0, trail)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| |
| |
| /* |
| * local variables: |
| * eval: (load-file "../../tools/dev/svn-dev.el") |
| * end: |
| */ |
