contrib/subversion/subversion/libsvn_fs_fs/transaction.h

   1 /* transaction.h --- transaction-related functions of FSFS
   2  *
   3  * ====================================================================
   4  *    Licensed to the Apache Software Foundation (ASF) under one
   5  *    or more contributor license agreements.  See the NOTICE file
   6  *    distributed with this work for additional information
   7  *    regarding copyright ownership.  The ASF licenses this file
   8  *    to you under the Apache License, Version 2.0 (the
   9  *    "License"); you may not use this file except in compliance
  10  *    with the License.  You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  *    Unless required by applicable law or agreed to in writing,
  15  *    software distributed under the License is distributed on an
  16  *    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  *    KIND, either express or implied.  See the License for the
  18  *    specific language governing permissions and limitations
  19  *    under the License.
  20  * ====================================================================
  21  */
  22
  23 #ifndef SVN_LIBSVN_FS__TRANSACTION_H
  24 #define SVN_LIBSVN_FS__TRANSACTION_H
  25
  26 #include "fs.h"
  27
  28 /* Return the transaction ID of TXN.
  29  */
  30 const svn_fs_fs__id_part_t *
  31 svn_fs_fs__txn_get_id(svn_fs_txn_t *txn);
  32
  33 /* Store NODEREV as the node-revision for the node whose id is ID in
  34    FS, after setting its is_fresh_txn_root to FRESH_TXN_ROOT.  Do any
  35    necessary temporary allocation in POOL. */
  36 svn_error_t *
  37 svn_fs_fs__put_node_revision(svn_fs_t *fs,
  38                              const svn_fs_id_t *id,
  39                              node_revision_t *noderev,
  40                              svn_boolean_t fresh_txn_root,
  41                              apr_pool_t *pool);
  42
  43 /* Find the paths which were changed in transaction TXN_ID of
  44    filesystem FS and store them in *CHANGED_PATHS_P.
  45    Get any temporary allocations from POOL. */
  46 svn_error_t *
  47 svn_fs_fs__txn_changes_fetch(apr_hash_t **changed_paths_p,
  48                              svn_fs_t *fs,
  49                              const svn_fs_fs__id_part_t *txn_id,
  50                              apr_pool_t *pool);
  51
  52 /* Find the paths which were changed in revision REV of filesystem FS
  53    and store them in *CHANGED_PATHS_P.  Get any temporary allocations
  54    from POOL. */
  55 svn_error_t *
  56 svn_fs_fs__paths_changed(apr_hash_t **changed_paths_p,
  57                          svn_fs_t *fs,
  58                          svn_revnum_t rev,
  59                          apr_pool_t *pool);
  60
  61 /* Create a new transaction in filesystem FS, based on revision REV,
  62    and store it in *TXN_P.  Allocate all necessary variables from
  63    POOL. */
  64 svn_error_t *
  65 svn_fs_fs__create_txn(svn_fs_txn_t **txn_p,
  66                       svn_fs_t *fs,
  67                       svn_revnum_t rev,
  68                       apr_pool_t *pool);
  69
  70 /* Set the transaction property NAME to the value VALUE in transaction
  71    TXN.  Perform temporary allocations from POOL. */
  72 svn_error_t *
  73 svn_fs_fs__change_txn_prop(svn_fs_txn_t *txn,
  74                            const char *name,
  75                            const svn_string_t *value,
  76                            apr_pool_t *pool);
  77
  78 /* Change transaction properties in transaction TXN based on PROPS.
  79    Perform temporary allocations from POOL. */
  80 svn_error_t *
  81 svn_fs_fs__change_txn_props(svn_fs_txn_t *txn,
  82                             const apr_array_header_t *props,
  83                             apr_pool_t *pool);
  84
  85 /* Store a transaction record in *TXN_P for the transaction identified
  86    by TXN_ID in filesystem FS.  Allocate everything from POOL. */
  87 svn_error_t *
  88 svn_fs_fs__get_txn(transaction_t **txn_p,
  89                    svn_fs_t *fs,
  90                    const svn_fs_fs__id_part_t *txn_id,
  91                    apr_pool_t *pool);
  92
  93 /* Return the next available copy_id in *COPY_ID for the transaction
  94    TXN_ID in filesystem FS.  Allocate space in POOL. */
  95 svn_error_t *
  96 svn_fs_fs__reserve_copy_id(svn_fs_fs__id_part_t *copy_id_p,
  97                            svn_fs_t *fs,
  98                            const svn_fs_fs__id_part_t *txn_id,
  99                            apr_pool_t *pool);
 100
 101 /* Create an entirely new mutable node in the filesystem FS, whose
 102    node-revision is NODEREV.  Set *ID_P to the new node revision's ID.
 103    Use POOL for any temporary allocation.  COPY_ID is the copy_id to
 104    use in the node revision ID.  TXN_ID is the Subversion transaction
 105    under which this occurs. */
 106 svn_error_t *
 107 svn_fs_fs__create_node(const svn_fs_id_t **id_p,
 108                        svn_fs_t *fs,
 109                        node_revision_t *noderev,
 110                        const svn_fs_fs__id_part_t *copy_id,
 111                        const svn_fs_fs__id_part_t *txn_id,
 112                        apr_pool_t *pool);
 113
 114 /* Remove all references to the transaction TXN_ID from filesystem FS.
 115    Temporary allocations are from POOL. */
 116 svn_error_t *
 117 svn_fs_fs__purge_txn(svn_fs_t *fs,
 118                      const char *txn_id,
 119                      apr_pool_t *pool);
 120
 121 /* Abort the existing transaction TXN, performing any temporary
 122    allocations in POOL. */
 123 svn_error_t *
 124 svn_fs_fs__abort_txn(svn_fs_txn_t *txn,
 125                      apr_pool_t *pool);
 126
 127 /* Add or set in filesystem FS, transaction TXN_ID, in directory
 128    PARENT_NODEREV a directory entry for NAME pointing to ID of type
 129    KIND.  Allocations are done in POOL. */
 130 svn_error_t *
 131 svn_fs_fs__set_entry(svn_fs_t *fs,
 132                      const svn_fs_fs__id_part_t *txn_id,
 133                      node_revision_t *parent_noderev,
 134                      const char *name,
 135                      const svn_fs_id_t *id,
 136                      svn_node_kind_t kind,
 137                      apr_pool_t *pool);
 138
 139 /* Add a change to the changes record for filesystem FS in transaction
 140    TXN_ID.  Mark path PATH, having node-id ID, as changed according to
 141    the type in CHANGE_KIND.  If the text representation was changed set
 142    TEXT_MOD to TRUE, and likewise for PROP_MOD as well as MERGEINFO_MOD.
 143    If this change was the result of a copy, set COPYFROM_REV and
 144    COPYFROM_PATH to the revision and path of the copy source, otherwise
 145    they should be set to SVN_INVALID_REVNUM and NULL.  Perform any
 146    temporary allocations from POOL. */
 147 svn_error_t *
 148 svn_fs_fs__add_change(svn_fs_t *fs,
 149                       const svn_fs_fs__id_part_t *txn_id,
 150                       const char *path,
 151                       const svn_fs_id_t *id,
 152                       svn_fs_path_change_kind_t change_kind,
 153                       svn_boolean_t text_mod,
 154                       svn_boolean_t prop_mod,
 155                       svn_boolean_t mergeinfo_mod,
 156                       svn_node_kind_t node_kind,
 157                       svn_revnum_t copyfrom_rev,
 158                       const char *copyfrom_path,
 159                       apr_pool_t *pool);
 160
 161 /* Return a writable stream in *STREAM that allows storing the text
 162    representation of node-revision NODEREV in filesystem FS.
 163    Allocations are from POOL. */
 164 svn_error_t *
 165 svn_fs_fs__set_contents(svn_stream_t **stream,
 166                         svn_fs_t *fs,
 167                         node_revision_t *noderev,
 168                         apr_pool_t *pool);
 169
 170 /* Create a node revision in FS which is an immediate successor of
 171    OLD_ID, whose contents are NEW_NR.  Set *NEW_ID_P to the new node
 172    revision's ID.  Use POOL for any temporary allocation.
 173
 174    COPY_ID, if non-NULL, is a key into the `copies' table, and
 175    indicates that this new node is being created as the result of a
 176    copy operation, and specifically which operation that was.  If
 177    COPY_ID is NULL, then re-use the copy ID from the predecessor node.
 178
 179    TXN_ID is the Subversion transaction under which this occurs.
 180
 181    After this call, the deltification code assumes that the new node's
 182    contents will change frequently, and will avoid representing other
 183    nodes as deltas against this node's contents.  */
 184 svn_error_t *
 185 svn_fs_fs__create_successor(const svn_fs_id_t **new_id_p,
 186                             svn_fs_t *fs,
 187                             const svn_fs_id_t *old_idp,
 188                             node_revision_t *new_noderev,
 189                             const svn_fs_fs__id_part_t *copy_id,
 190                             const svn_fs_fs__id_part_t *txn_id,
 191                             apr_pool_t *pool);
 192
 193 /* Write a new property list PROPLIST for node-revision NODEREV in
 194    filesystem FS.  Perform any temporary allocations in POOL. */
 195 svn_error_t *
 196 svn_fs_fs__set_proplist(svn_fs_t *fs,
 197                         node_revision_t *noderev,
 198                         apr_hash_t *proplist,
 199                         apr_pool_t *pool);
 200
 201 /* Append the L2P and P2L indexes given by their proto index file names
 202  * L2P_PROTO_INDEX and P2L_PROTO_INDEX to the revision / pack FILE.
 203  * The latter contains revision(s) starting at REVISION in FS.
 204  * Use POOL for temporary allocations.  */
 205 svn_error_t *
 206 svn_fs_fs__add_index_data(svn_fs_t *fs,
 207                           apr_file_t *file,
 208                           const char *l2p_proto_index,
 209                           const char *p2l_proto_index,
 210                           svn_revnum_t revision,
 211                           apr_pool_t *pool);
 212
 213 /* Commit the transaction TXN in filesystem FS and return its new
 214    revision number in *REV.  If the transaction is out of date, return
 215    the error SVN_ERR_FS_TXN_OUT_OF_DATE. Use POOL for temporary
 216    allocations. */
 217 svn_error_t *
 218 svn_fs_fs__commit(svn_revnum_t *new_rev_p,
 219                   svn_fs_t *fs,
 220                   svn_fs_txn_t *txn,
 221                   apr_pool_t *pool);
 222
 223 /* Set *NAMES_P to an array of names which are all the active
 224    transactions in filesystem FS.  Allocate the array from POOL. */
 225 svn_error_t *
 226 svn_fs_fs__list_transactions(apr_array_header_t **names_p,
 227                              svn_fs_t *fs,
 228                              apr_pool_t *pool);
 229
 230 /* Open the transaction named NAME in filesystem FS.  Set *TXN_P to
 231  * the transaction. If there is no such transaction, return
 232 ` * SVN_ERR_FS_NO_SUCH_TRANSACTION.  Allocate the new transaction in
 233  * POOL. */
 234 svn_error_t *
 235 svn_fs_fs__open_txn(svn_fs_txn_t **txn_p,
 236                     svn_fs_t *fs,
 237                     const char *name,
 238                     apr_pool_t *pool);
 239
 240 /* Return the property list from transaction TXN and store it in
 241    *PROPLIST.  Allocate the property list from POOL. */
 242 svn_error_t *
 243 svn_fs_fs__txn_proplist(apr_hash_t **table_p,
 244                         svn_fs_txn_t *txn,
 245                         apr_pool_t *pool);
 246
 247 /* Delete the mutable node-revision referenced by ID, along with any
 248    mutable props or directory contents associated with it.  Perform
 249    temporary allocations in POOL. */
 250 svn_error_t *
 251 svn_fs_fs__delete_node_revision(svn_fs_t *fs,
 252                                 const svn_fs_id_t *id,
 253                                 apr_pool_t *pool);
 254
 255 /* Retrieve information about the Subversion transaction SVN_TXN from
 256    the `transactions' table of FS, allocating from POOL.  Set
 257    *ROOT_ID_P to the ID of the transaction's root directory.  Set
 258    *BASE_ROOT_ID_P to the ID of the root directory of the
 259    transaction's base revision.
 260
 261    If there is no such transaction, SVN_ERR_FS_NO_SUCH_TRANSACTION is
 262    the error returned.
 263
 264    Returns SVN_ERR_FS_TRANSACTION_NOT_MUTABLE if TXN_NAME refers to a
 265    transaction that has already been committed.
 266
 267    Allocate *ROOT_ID_P and *BASE_ROOT_ID_P in POOL.  */
 268 svn_error_t *
 269 svn_fs_fs__get_txn_ids(const svn_fs_id_t **root_id_p,
 270                        const svn_fs_id_t **base_root_id_p,
 271                        svn_fs_t *fs,
 272                        const svn_fs_fs__id_part_t *txn_name,
 273                        apr_pool_t *pool);
 274
 275 /* Find the value of the property named PROPNAME in transaction TXN.
 276    Return the contents in *VALUE_P.  The contents will be allocated
 277    from POOL. */
 278 svn_error_t *
 279 svn_fs_fs__txn_prop(svn_string_t **value_p,
 280                     svn_fs_txn_t *txn,
 281                     const char *propname,
 282                     apr_pool_t *pool);
 283
 284 /* Begin a new transaction in filesystem FS, based on existing
 285    revision REV.  The new transaction is returned in *TXN_P.  Allocate
 286    the new transaction structure from POOL. */
 287 svn_error_t *
 288 svn_fs_fs__begin_txn(svn_fs_txn_t **txn_p,
 289                      svn_fs_t *fs,
 290                      svn_revnum_t rev,
 291                      apr_uint32_t flags,
 292                      apr_pool_t *pool);
 293
 294 #endif