path: root/subversion/libsvn_fs_base/dag.h

/* dag.h : DAG-like interface filesystem, private to libsvn_fs
 *
 * ====================================================================
 *    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.
 * ====================================================================
 */

#ifndef SVN_LIBSVN_FS_DAG_H
#define SVN_LIBSVN_FS_DAG_H

#include "svn_fs.h"

#include "trail.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


/* The interface in this file provides all the essential filesystem
   operations, but exposes the filesystem's DAG structure.  This makes
   it simpler to implement than the public interface, since a client
   of this interface has to understand and cope with shared structure
   directly as it appears in the database.  However, it's still a
   self-consistent set of invariants to maintain, making it
   (hopefully) a useful interface boundary.

   In other words:

   - The dag_node_t interface exposes the internal DAG structure of
     the filesystem, while the svn_fs.h interface does any cloning
     necessary to make the filesystem look like a tree.

   - The dag_node_t interface exposes the existence of copy nodes,
     whereas the svn_fs.h handles them transparently.

   - dag_node_t's must be explicitly cloned, whereas the svn_fs.h
     operations make clones implicitly.

   - Callers of the dag_node_t interface use Berkeley DB transactions
     to ensure consistency between operations, while callers of the
     svn_fs.h interface use Subversion transactions.  */


/* Initializing a filesystem.  */


/* Given a filesystem FS, which contains all the necessary tables,
   create the initial revision 0, and the initial root directory.  */
svn_error_t *svn_fs_base__dag_init_fs(svn_fs_t *fs);



/* Generic DAG node stuff.  */

typedef struct dag_node_t dag_node_t;


/* Fill *NODE with a dag_node_t representing node revision ID in FS,
   allocating in POOL.  */
svn_error_t *svn_fs_base__dag_get_node(dag_node_t **node,
                                       svn_fs_t *fs,
                                       const svn_fs_id_t *id,
                                       trail_t *trail,
                                       apr_pool_t *pool);


/* Return a new dag_node_t object referring to the same node as NODE,
   allocated in POOL.  */
dag_node_t *svn_fs_base__dag_dup(const dag_node_t *node,
                                 apr_pool_t *pool);


/* Return the filesystem containing NODE.  */
svn_fs_t *svn_fs_base__dag_get_fs(dag_node_t *node);


/* Set *REV to NODE's revision number, as part of TRAIL.  If NODE has
   never been committed as part of a revision, set *REV to
   SVN_INVALID_REVNUM.  */
svn_error_t *svn_fs_base__dag_get_revision(svn_revnum_t *rev,
                                           dag_node_t *node,
                                           trail_t *trail,
                                           apr_pool_t *pool);


/* Return the node revision ID of NODE.  The value returned is shared
   with NODE, and will be deallocated when NODE is.  */
const svn_fs_id_t *svn_fs_base__dag_get_id(dag_node_t *node);


/* Return the created path of NODE.  The value returned is shared
   with NODE, and will be deallocated when NODE is.  */
const char *svn_fs_base__dag_get_created_path(dag_node_t *node);


/* Set *ID_P to the node revision ID of NODE's immediate predecessor,
   or NULL if NODE has no predecessor, as part of TRAIL.  The returned
   ID will be allocated in POOL.  */
svn_error_t *svn_fs_base__dag_get_predecessor_id(const svn_fs_id_t **id_p,
                                                 dag_node_t *node,
                                                 trail_t *trail,
                                                 apr_pool_t *pool);


/* Set *COUNT to the number of predecessors NODE has (recursively), or
   -1 if not known, as part of TRAIL.  */
svn_error_t *svn_fs_base__dag_get_predecessor_count(int *count,
                                                    dag_node_t *node,
                                                    trail_t *trail,
                                                    apr_pool_t *pool);


/* Return non-zero IFF NODE is currently mutable under Subversion
   transaction TXN_ID.  */
svn_boolean_t svn_fs_base__dag_check_mutable(dag_node_t *node,
                                             const char *txn_id);

/* Return the node kind of NODE. */
svn_node_kind_t svn_fs_base__dag_node_kind(dag_node_t *node);

/* Set *PROPLIST_P to a PROPLIST hash representing the entire property
   list of NODE, as part of TRAIL.  The hash has const char * names
   (the property names) and svn_string_t * values (the property values).

   If properties do not exist on NODE, *PROPLIST_P will be set to NULL.

   The returned property list is allocated in POOL.  */
svn_error_t *svn_fs_base__dag_get_proplist(apr_hash_t **proplist_p,
                                           dag_node_t *node,
                                           trail_t *trail,
                                           apr_pool_t *pool);

/* Set the property list of NODE to PROPLIST, as part of TRAIL.  The
   node being changed must be mutable.  TXN_ID is the Subversion
   transaction under which this occurs.  */
svn_error_t *svn_fs_base__dag_set_proplist(dag_node_t *node,
                                           const apr_hash_t *proplist,
                                           const char *txn_id,
                                           trail_t *trail,
                                           apr_pool_t *pool);



/* Mergeinfo tracking stuff. */

/* If HAS_MERGEINFO is not null, set *HAS_MERGEINFO to TRUE iff NODE
   records that its property list contains merge tracking information.

   If COUNT is not null, set *COUNT to the number of nodes --
   including NODE itself -- in the subtree rooted at NODE which claim
   to carry merge tracking information.

   Do this as part of TRAIL, and use POOL for necessary allocations.

   NOTE:  No validation against NODE's actual property list is
   performed. */
svn_error_t *svn_fs_base__dag_get_mergeinfo_stats(svn_boolean_t *has_mergeinfo,
                                                  apr_int64_t *count,
                                                  dag_node_t *node,
                                                  trail_t *trail,
                                                  apr_pool_t *pool);

/* If HAS_MERGEINFO is set, record on NODE that its property list
   carries merge tracking information.  Otherwise, record on NODE its
   property list does *not* carry merge tracking information.  NODE
   must be mutable under TXN_ID (the Subversion transaction under
   which this operation occurs).  Set *HAD_MERGEINFO to the previous
   state of this record.

   Update the mergeinfo count on NODE as necessary.

   Do all of this as part of TRAIL, and use POOL for necessary
   allocations.

   NOTE:  No validation against NODE's actual property list is
   performed. */
svn_error_t *svn_fs_base__dag_set_has_mergeinfo(dag_node_t *node,
                                                svn_boolean_t has_mergeinfo,
                                                svn_boolean_t *had_mergeinfo,
                                                const char *txn_id,
                                                trail_t *trail,
                                                apr_pool_t *pool);

/* Record on NODE a change of COUNT_DELTA nodes -- including NODE
   itself -- in the subtree rooted at NODE claim to carry merge
   tracking information.  That is, add COUNT_DELTA to NODE's current
   mergeinfo count (regardless of whether COUNT_DELTA is a positive or
   negative integer).

   NODE must be mutable under TXN_ID (the Subversion transaction under
   which this operation occurs).  Do this as part of TRAIL, and use
   POOL for necessary allocations.

   NOTE:  No validation of these claims is performed. */
svn_error_t *svn_fs_base__dag_adjust_mergeinfo_count(dag_node_t *node,
                                                     apr_int64_t count_delta,
                                                     const char *txn_id,
                                                     trail_t *trail,
                                                     apr_pool_t *pool);


/* Revision and transaction roots.  */


/* Open the root of revision REV of filesystem FS, as part of TRAIL.
   Set *NODE_P to the new node.  Allocate the node in POOL.  */
svn_error_t *svn_fs_base__dag_revision_root(dag_node_t **node_p,
                                            svn_fs_t *fs,
                                            svn_revnum_t rev,
                                            trail_t *trail,
                                            apr_pool_t *pool);


/* Set *NODE_P to the root of transaction TXN_ID in FS, as part
   of TRAIL.  Allocate the node in POOL.

   Note that the root node of TXN_ID is not necessarily mutable.  If no
   changes have been made in the transaction, then it may share its
   root directory with its base revision.  To get a mutable root node
   for a transaction, call svn_fs_base__dag_clone_root.  */
svn_error_t *svn_fs_base__dag_txn_root(dag_node_t **node_p,
                                       svn_fs_t *fs,
                                       const char *txn_id,
                                       trail_t *trail,
                                       apr_pool_t *pool);


/* Set *NODE_P to the base root of transaction TXN_ID in FS, as part
   of TRAIL.  Allocate the node in POOL.  */
svn_error_t *svn_fs_base__dag_txn_base_root(dag_node_t **node_p,
                                            svn_fs_t *fs,
                                            const char *txn_id,
                                            trail_t *trail,
                                            apr_pool_t *pool);


/* Clone the root directory of TXN_ID in FS, and update the
   `transactions' table entry to point to it, unless this has been
   done already.  In either case, set *ROOT_P to a reference to the
   root directory clone.  Do all this as part of TRAIL, and allocate
   *ROOT_P in POOL.  */
svn_error_t *svn_fs_base__dag_clone_root(dag_node_t **root_p,
                                         svn_fs_t *fs,
                                         const char *txn_id,
                                         trail_t *trail,
                                         apr_pool_t *pool);


/* Commit the transaction TXN->id in TXN->FS, as part of TRAIL.  Store the
   new revision number in *NEW_REV.  This entails:
   - marking the tree of mutable nodes at TXN->id's root as immutable,
     and marking all their contents as stable
   - creating a new revision, with TXN->id's root as its root directory
   - promoting TXN->id to a "committed" transaction.

   Beware!  This does not make sure that TXN->id is based on the very
   latest revision in TXN->FS.  If the caller doesn't take care of this,
   you may lose people's work!

   Do any necessary temporary allocation in a subpool of POOL.
   Consume temporary space at most proportional to the maximum depth
   of SVN_TXN's tree of mutable nodes.  */
svn_error_t *svn_fs_base__dag_commit_txn(svn_revnum_t *new_rev,
                                         svn_fs_txn_t *txn,
                                         trail_t *trail,
                                         apr_pool_t *pool);


/* Directories.  */


/* Open the node named NAME in the directory PARENT, as part of TRAIL.
   Set *CHILD_P to the new node, allocated in POOL.  NAME must be a
   single path component; it cannot be a slash-separated directory
   path.  */
svn_error_t *svn_fs_base__dag_open(dag_node_t **child_p,
                                   dag_node_t *parent,
                                   const char *name,
                                   trail_t *trail,
                                   apr_pool_t *pool);


/* Set *ENTRIES_P to a hash table of NODE's entries, as part of TRAIL,
   or NULL if NODE has no entries.  The keys of the table are entry
   names, and the values are svn_fs_dirent_t's.

   The returned table is allocated in POOL.

   NOTE: the 'kind' field of the svn_fs_dirent_t's is set to
   svn_node_unknown by this function -- callers that need in
   interesting value in these slots should fill them in using a new
   TRAIL, since the list of entries can be arbitrarily large.  */
svn_error_t *svn_fs_base__dag_dir_entries(apr_hash_t **entries_p,
                                          dag_node_t *node,
                                          trail_t *trail,
                                          apr_pool_t *pool);


/* Set ENTRY_NAME in NODE to point to ID, as part of TRAIL.  NODE must
   be a mutable directory.  ID can refer to a mutable or immutable
   node.  If ENTRY_NAME does not exist, it will be created.  TXN_ID is
   the Subversion transaction under which this occurs.*/
svn_error_t *svn_fs_base__dag_set_entry(dag_node_t *node,
                                        const char *entry_name,
                                        const svn_fs_id_t *id,
                                        const char *txn_id,
                                        trail_t *trail,
                                        apr_pool_t *pool);


/* Make a new mutable clone of the node named NAME in PARENT, and
   adjust PARENT's directory entry to point to it, as part of TRAIL,
   unless NAME in PARENT already refers to a mutable node.  In either
   case, set *CHILD_P to a reference to the new node, allocated in
   POOL.  PARENT must be mutable.  NAME must be a single path
   component; it cannot be a slash-separated directory path.
   PARENT_PATH must be the canonicalized absolute path of the parent
   directory.

   COPY_ID, if non-NULL, is a key into the `copies' table, and
   indicates that this new node is being created as the result of a
   copy operation, and specifically which operation that was.

   PATH is the canonicalized absolute path at which this node is being
   created.

   TXN_ID is the Subversion transaction under which this occurs.  */
svn_error_t *svn_fs_base__dag_clone_child(dag_node_t **child_p,
                                          dag_node_t *parent,
                                          const char *parent_path,
                                          const char *name,
                                          const char *copy_id,
                                          const char *txn_id,
                                          trail_t *trail,
                                          apr_pool_t *pool);


/* Delete the directory entry named NAME from PARENT, as part of
   TRAIL.  PARENT must be mutable.  NAME must be a single path
   component; it cannot be a slash-separated directory path.  If the
   entry being deleted points to a mutable node revision, also remove
   that node revision and (if it is a directory) all mutable node
   revisions reachable from it.  Also delete the node-origins record
   for each deleted node revision that had no predecessor.

   TXN_ID is the Subversion transaction under which this occurs.

   If return SVN_ERR_FS_NO_SUCH_ENTRY, then there is no entry NAME in
   PARENT.  */
svn_error_t *svn_fs_base__dag_delete(dag_node_t *parent,
                                     const char *name,
                                     const char *txn_id,
                                     trail_t *trail,
                                     apr_pool_t *pool);


/* Delete the node revision assigned to node ID from FS's `nodes'
   table, as part of TRAIL.  Also delete any mutable representations
   and strings associated with that node revision.  Also delete the
   node-origins record for this node revision's node id, if this node
   revision had no predecessor.

   ID may refer to a file or directory, which must be mutable.  TXN_ID
   is the Subversion transaction under which this occurs.

   NOTE: If ID represents a directory, and that directory has mutable
   children, you risk orphaning those children by leaving them
   dangling, disconnected from all DAG trees.  It is assumed that
   callers of this interface know what in the world they are doing.  */
svn_error_t *svn_fs_base__dag_remove_node(svn_fs_t *fs,
                                          const svn_fs_id_t *id,
                                          const char *txn_id,
                                          trail_t *trail,
                                          apr_pool_t *pool);


/* Delete all mutable node revisions reachable from node ID, including
   ID itself, from FS's `nodes' table, as part of TRAIL.  Also delete
   any mutable representations and strings associated with that node
   revision.  Also delete the node-origins record for each deleted
   node revision that had no predecessor.

   ID may refer to a file or directory, which may be mutable or
   immutable.  TXN_ID is the Subversion transaction under which this
   occurs.  */
svn_error_t *svn_fs_base__dag_delete_if_mutable(svn_fs_t *fs,
                                                const svn_fs_id_t *id,
                                                const char *txn_id,
                                                trail_t *trail,
                                                apr_pool_t *pool);


/* Create a new mutable directory named NAME in PARENT, as part of
   TRAIL.  Set *CHILD_P to a reference to the new node, allocated in
   POOL.  The new directory has no contents, and no properties.
   PARENT must be mutable.  NAME must be a single path component; it
   cannot be a slash-separated directory path.  PARENT_PATH must be
   the canonicalized absolute path of the parent directory.  PARENT
   must not currently have an entry named NAME.  Do any temporary
   allocation in POOL.  TXN_ID is the Subversion transaction
   under which this occurs.  */
svn_error_t *svn_fs_base__dag_make_dir(dag_node_t **child_p,
                                       dag_node_t *parent,
                                       const char *parent_path,
                                       const char *name,
                                       const char *txn_id,
                                       trail_t *trail,
                                       apr_pool_t *pool);



/* Files.  */


/* Set *CONTENTS to a readable generic stream which yields the
   contents of FILE, as part of TRAIL.  Allocate the stream in POOL.
   If FILE is not a file, return SVN_ERR_FS_NOT_FILE.  */
svn_error_t *svn_fs_base__dag_get_contents(svn_stream_t **contents,
                                           dag_node_t *file,
                                           trail_t *trail,
                                           apr_pool_t *pool);


/* Return a generic writable stream in *CONTENTS with which to set the
   contents of FILE as part of TRAIL.  Allocate the stream in POOL.
   TXN_ID is the Subversion transaction under which this occurs.  Any
   previous edits on the file will be deleted, and a new edit stream
   will be constructed.  */
svn_error_t *svn_fs_base__dag_get_edit_stream(svn_stream_t **contents,
                                              dag_node_t *file,
                                              const char *txn_id,
                                              trail_t *trail,
                                              apr_pool_t *pool);


/* Signify the completion of edits to FILE made using the stream
   returned by svn_fs_base__dag_get_edit_stream, as part of TRAIL.  TXN_ID
   is the Subversion transaction under which this occurs.

   If CHECKSUM is non-null, it must match the checksum for FILE's
   contents (note: this is not recalculated, the recorded checksum is
   used), else the error SVN_ERR_CHECKSUM_MISMATCH is returned.

   This operation is a no-op if no edits are present.  */
svn_error_t *svn_fs_base__dag_finalize_edits(dag_node_t *file,
                                             const svn_checksum_t *checksum,
                                             const char *txn_id,
                                             trail_t *trail,
                                             apr_pool_t *pool);


/* Set *LENGTH to the length of the contents of FILE, as part of TRAIL. */
svn_error_t *svn_fs_base__dag_file_length(svn_filesize_t *length,
                                          dag_node_t *file,
                                          trail_t *trail,
                                          apr_pool_t *pool);

/* Put the checksum of type CHECKSUM_KIND recorded for FILE into
 * CHECKSUM, as part of TRAIL.
 *
 * If no stored checksum of the requested kind is available, do not
 * calculate the checksum, just put NULL into CHECKSUM.
 */
svn_error_t *svn_fs_base__dag_file_checksum(svn_checksum_t **checksum,
                                            svn_checksum_kind_t checksum_kind,
                                            dag_node_t *file,
                                            trail_t *trail,
                                            apr_pool_t *pool);

/* Create a new mutable file named NAME in PARENT, as part of TRAIL.
   Set *CHILD_P to a reference to the new node, allocated in
   POOL.  The new file's contents are the empty string, and it
   has no properties.  PARENT must be mutable.  NAME must be a single
   path component; it cannot be a slash-separated directory path.
   PARENT_PATH must be the canonicalized absolute path of the parent
   directory.  TXN_ID is the Subversion transaction under which this
   occurs.  */
svn_error_t *svn_fs_base__dag_make_file(dag_node_t **child_p,
                                        dag_node_t *parent,
                                        const char *parent_path,
                                        const char *name,
                                        const char *txn_id,
                                        trail_t *trail,
                                        apr_pool_t *pool);



/* Copies */

/* Make ENTRY in TO_NODE be a copy of FROM_NODE, as part of TRAIL.
   TO_NODE must be mutable.  TXN_ID is the Subversion transaction
   under which this occurs.

   If PRESERVE_HISTORY is true, the new node will record that it was
   copied from FROM_PATH in FROM_REV; therefore, FROM_NODE should be
   the node found at FROM_PATH in FROM_REV, although this is not
   checked.

   If PRESERVE_HISTORY is false, FROM_PATH and FROM_REV are ignored.  */
svn_error_t *svn_fs_base__dag_copy(dag_node_t *to_node,
                                   const char *entry,
                                   dag_node_t *from_node,
                                   svn_boolean_t preserve_history,
                                   svn_revnum_t from_rev,
                                   const char *from_path,
                                   const char *txn_id,
                                   trail_t *trail,
                                   apr_pool_t *pool);



/* Deltification */

/* 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.  If PROPS_ONLY is non-zero, only the node property
   portion of TARGET will be deltified.

   If TXN_ID is non-NULL, it is the transaction ID in which TARGET's
   representation(s) must have been created (otherwise deltification
   is silently not attempted).

   WARNING WARNING WARNING: Do *NOT* call this with a mutable SOURCE
   node.  Things will go *very* sour if you deltify TARGET against a
   node that might just disappear from the filesystem in the (near)
   future.  */
svn_error_t *svn_fs_base__dag_deltify(dag_node_t *target,
                                      dag_node_t *source,
                                      svn_boolean_t props_only,
                                      const char *txn_id,
                                      trail_t *trail,
                                      apr_pool_t *pool);

/* Index NODE's backing data representations by their checksum.  Do
   this as part of TRAIL.  Use POOL for allocations. */
svn_error_t *svn_fs_base__dag_index_checksums(dag_node_t *node,
                                              trail_t *trail,
                                              apr_pool_t *pool);


/* Comparison */

/* Find out what is the same between two nodes.

   If PROPS_CHANGED is non-null, set *PROPS_CHANGED to 1 if the two
   nodes have different property lists, or to 0 if same.

   If CONTENTS_CHANGED is non-null, set *CONTENTS_CHANGED to 1 if the
   two nodes have different contents, or to 0 if same.  For files,
   file contents are compared; for directories, the entries lists are
   compared.  If one is a file and the other is a directory, the one's
   contents will be compared to the other's entries list.  (Not
   terribly useful, I suppose, but that's the caller's business.)

   ### todo: This function only compares rep keys at the moment.  This
   may leave us with a slight chance of a false positive, though I
   don't really see how that would happen in practice.  Nevertheless,
   it should probably be fixed.  */
svn_error_t *svn_fs_base__things_different(svn_boolean_t *props_changed,
                                           svn_boolean_t *contents_changed,
                                           dag_node_t *node1,
                                           dag_node_t *node2,
                                           trail_t *trail,
                                           apr_pool_t *pool);


#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* SVN_LIBSVN_FS_DAG_H */