subversion/libsvn_fs/rev-table.c - subversion - Git at Google

 /* rev-table.c : working with the `revisions' table
  *
  * ====================================================================
  * 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 <db.h>
 #include "svn_fs.h"
 #include "fs.h"
 #include "err.h"
 #include "dbt.h"
 #include "skel.h"
 #include "proplist.h"
 #include "validate.h"
 #include "rev-table.h"


 /* Opening/creating the `revisions' table.  */

 int svn_fs__open_revisions_table (DB **revisions_p,
                                   DB_ENV *env,
                                   int create)
 {
   DB *revisions;

   DB_ERR (db_create (&revisions, env, 0));
   DB_ERR (revisions->open (revisions, "revisions", 0, DB_RECNO,
                            create ? (DB_CREATE | DB_EXCL) : 0,
                            0666));

   *revisions_p = revisions;
   return 0;
 }


 /* Storing and retrieving filesystem revisions.  */


 static int
 is_valid_filesystem_revision (skel_t *skel)
 {
   int len = svn_fs__list_length (skel);

   if (len == 3)
     {
       if (svn_fs__matches_atom (skel->children, "revision")
           && skel->children->next != NULL
           && svn_fs__is_valid_proplist (skel->children->next->next))
         {
           skel_t *id = skel->children->next;
           if (id->is_atom
               && 0 == (1 & svn_fs__count_id_components (id->data, id->len)))
             return 1;
         }
     }

   return 0;
 }


 svn_error_t *
 svn_fs__get_rev (skel_t **skel_p,
                  svn_fs_t *fs,
                  svn_revnum_t rev,
                  trail_t *trail)
 {
   int db_err;
   DBT key, value;
   skel_t *skel;

   /* Turn the revision number into a Berkeley DB record number.
      Revisions are numbered starting with zero; Berkeley DB record
      numbers begin with one.  */
   db_recno_t recno = rev + 1;

   db_err = fs->revisions->get (fs->revisions, trail->db_txn,
                                svn_fs__set_dbt (&key, &recno, sizeof (recno)),
                                svn_fs__result_dbt (&value),
                                0);
   svn_fs__track_dbt (&value, trail->pool);

   /* If there's no such revision, return an appropriately specific error.  */
   if (db_err == DB_NOTFOUND)
     return svn_fs__err_dangling_rev (fs, rev);

   /* Handle any other error conditions.  */
   SVN_ERR (DB_WRAP (fs, "reading filesystem revision", db_err));

   /* Parse and check the REVISION skel.  */
   skel = svn_fs__parse_skel (value.data, value.size, trail->pool);
   if (! skel
       || ! is_valid_filesystem_revision (skel))
     return svn_fs__err_corrupt_fs_revision (fs, rev);

   *skel_p = skel;
   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_fs__put_rev (svn_revnum_t *rev,
                  svn_fs_t *fs,
                  skel_t *skel,
                  trail_t *trail)
 {
   int db_err;
   DBT key, value;
   db_recno_t recno = 0;

   /* xbc FIXME: Need a useful revision number here. */
   if (! is_valid_filesystem_revision (skel))
     return svn_fs__err_corrupt_fs_revision (fs, -1);

   db_err = fs->revisions->put (fs->revisions, trail->db_txn,
                                svn_fs__recno_dbt(&key, &recno),
                                svn_fs__skel_to_dbt (&value, skel, trail->pool),
                                DB_APPEND);
   SVN_ERR (DB_WRAP (fs, "storing filesystem revision", db_err));

   /* Turn the record number into a Subversion revision number.
      Revisions are numbered starting with zero; Berkeley DB record
      numbers begin with one.  */
   *rev = recno - 1;
   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_fs__rev_get_root (svn_fs_id_t **root_id_p,
                       svn_fs_t *fs,
                       svn_revnum_t rev,
                       trail_t *trail)
 {
   skel_t *skel;
   svn_fs_id_t *id;

   SVN_ERR (svn_fs__get_rev (&skel, fs, rev, trail));

   id = svn_fs_parse_id (skel->children->next->data,
                         skel->children->next->len,
                         trail->pool);

   /* The skel validator doesn't check the ID format. */
   if (id == NULL)
     return svn_fs__err_corrupt_fs_revision (fs, -1);

   *root_id_p = id;
   return SVN_NO_ERROR;
 }


 /* Getting the youngest revision.  */


 svn_error_t *
 svn_fs__youngest_rev (svn_revnum_t *youngest_p,
                       svn_fs_t *fs,
                       trail_t *trail)
 {
   int db_err;
   DBC *cursor = 0;
   DBT key, value;
   db_recno_t recno;

   SVN_ERR (svn_fs__check_fs (fs));

   /* Create a database cursor.  */
   SVN_ERR (DB_WRAP (fs, "getting youngest revision (creating cursor)",
                     fs->revisions->cursor (fs->revisions, trail->db_txn,
                                            &cursor, 0)));

   /* Find the last entry in the `revisions' table.  */
   db_err = cursor->c_get (cursor,
                           svn_fs__recno_dbt (&key, &recno),
                           svn_fs__nodata_dbt (&value),
                           DB_LAST);

   if (db_err)
     {
       /* Free the cursor.  Ignore any error value --- the error above
          is more interesting.  */
       cursor->c_close (cursor);

       if (db_err == DB_NOTFOUND)
         /* The revision 0 should always be present, at least.  */
         return
           svn_error_createf
           (SVN_ERR_FS_CORRUPT, 0, 0, fs->pool,
            "revision 0 missing from `revisions' table, in filesystem `%s'",
            fs->path);

       SVN_ERR (DB_WRAP (fs, "getting youngest revision (finding last entry)",
                         db_err));
     }

   /* You can't commit a transaction with open cursors, because:
      1) key/value pairs don't get deleted until the cursors referring
      to them are closed, so closing a cursor can fail for various
      reasons, and txn_commit shouldn't fail that way, and
      2) using a cursor after committing its transaction can cause
      undetectable database corruption.  */
   SVN_ERR (DB_WRAP (fs, "getting youngest revision (closing cursor)",
                     cursor->c_close (cursor)));

   /* Turn the record number into a Subversion revision number.
      Revisions are numbered starting with zero; Berkeley DB record
      numbers begin with one.  */
   *youngest_p = recno - 1;
   return SVN_NO_ERROR;
 }


 struct youngest_rev_args {
   svn_revnum_t youngest;
   svn_fs_t *fs;
 };


 static svn_error_t *
 txn_body_youngest_rev (void *baton,
                        trail_t *trail)
 {
   struct youngest_rev_args *args = baton;
   SVN_ERR (svn_fs__youngest_rev (&(args->youngest), args->fs, trail));
   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_fs_youngest_rev (svn_revnum_t *youngest_p,
                      svn_fs_t *fs,
                      apr_pool_t *pool)
 {
   struct youngest_rev_args args;

   SVN_ERR (svn_fs__check_fs (fs));

   args.fs = fs;
   SVN_ERR (svn_fs__retry_txn (fs, txn_body_youngest_rev, &args, pool));

   *youngest_p = args.youngest;
   return SVN_NO_ERROR;
 }


 /* Generic revision operations.  */


 struct revision_prop_args {
   svn_string_t **value_p;
   svn_fs_t *fs;
   svn_revnum_t rev;
   const char *propname;
 };


 static svn_error_t *
 txn_body_revision_prop (void *baton,
                         trail_t *trail)
 {
   struct revision_prop_args *args = baton;

   skel_t *skel;
   skel_t *proplist;

   SVN_ERR (svn_fs__get_rev (&skel, args->fs, args->rev, trail));

   /* PROPLIST is the third element of revision skel.  */
   proplist = skel->children->next->next;

   /* Return the results of the generic property getting function. */
   return svn_fs__get_prop (args->value_p,
                            proplist,
                            args->propname,
                            trail->pool);
 }


 svn_error_t *
 svn_fs_revision_prop (svn_string_t **value_p,
                       svn_fs_t *fs,
                       svn_revnum_t rev,
                       const char *propname,
                       apr_pool_t *pool)
 {
   struct revision_prop_args args;
   svn_string_t *value;

   SVN_ERR (svn_fs__check_fs (fs));

   args.value_p = &value;
   args.fs = fs;
   args.rev = rev;
   args.propname = propname;
   SVN_ERR (svn_fs__retry_txn (fs, txn_body_revision_prop, &args, pool));

   *value_p = value;
   return SVN_NO_ERROR;
 }


 struct revision_proplist_args {
   apr_hash_t **table_p;
   svn_fs_t *fs;
   svn_revnum_t rev;
 };


 static svn_error_t *
 txn_body_revision_proplist (void *baton, trail_t *trail)
 {
   struct revision_proplist_args *args = baton;
   skel_t *skel;
   skel_t *proplist;

   SVN_ERR (svn_fs__get_rev (&skel, args->fs, args->rev, trail));

   /* PROPLIST is the third element of revision skel.  */
   proplist = skel->children->next->next;

   /* Return the results of the generic property hash getting function. */
   return svn_fs__make_prop_hash (args->table_p,
                                  proplist,
                                  trail->pool);
 }


 svn_error_t *
 svn_fs_revision_proplist (apr_hash_t **table_p,
                           svn_fs_t *fs,
                           svn_revnum_t rev,
                           apr_pool_t *pool)
 {
   struct revision_proplist_args args;
   apr_hash_t *table;

   SVN_ERR (svn_fs__check_fs (fs));

   args.table_p = &table;
   args.fs = fs;
   args.rev = rev;
   SVN_ERR (svn_fs__retry_txn (fs, txn_body_revision_proplist, &args, pool));

   *table_p = table;
   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_fs__set_rev_prop (svn_fs_t *fs,
                       svn_revnum_t rev,
                       const char *name,
                       const svn_string_t *value,
                       trail_t *trail)
 {
   skel_t *skel;
   skel_t *proplist;

   SVN_ERR (svn_fs__get_rev (&skel, fs, rev, trail));

   /* PROPLIST is the third element of revision skel.  */
   proplist = skel->children->next->next;

   /* Call the generic property setting function. */
   SVN_ERR (svn_fs__set_prop (proplist, name, value, trail->pool));
   {
     int db_err;
     DBT query, result;
     db_recno_t recno = rev + 1;

     /* Update the filesystem revision with the new skel that reflects
        our property edits. */
     db_err = fs->revisions->put
       (fs->revisions, trail->db_txn,
        svn_fs__set_dbt (&query, &recno, sizeof (recno)),
        svn_fs__skel_to_dbt (&result, skel, trail->pool), 0);
     SVN_ERR (DB_WRAP (fs, "updating filesystem revision", db_err));
   }

   return SVN_NO_ERROR;
 }


 struct change_rev_prop_args {
   svn_fs_t *fs;
   svn_revnum_t rev;
   const char *name;
   const svn_string_t *value;
 };


 static svn_error_t *
 txn_body_change_rev_prop (void *baton, trail_t *trail)
 {
   struct change_rev_prop_args *args = baton;

   SVN_ERR (svn_fs__set_rev_prop (args->fs, args->rev,
                                  args->name, args->value, trail));

   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_fs_change_rev_prop (svn_fs_t *fs,
                         svn_revnum_t rev,
                         const char *name,
                         const svn_string_t *value,
                         apr_pool_t *pool)
 {
   struct change_rev_prop_args args;

   SVN_ERR (svn_fs__check_fs (fs));

   args.fs = fs;
   args.rev = rev;
   args.name = name;
   args.value = value;
   SVN_ERR (svn_fs__retry_txn (fs, txn_body_change_rev_prop, &args, pool));

   return SVN_NO_ERROR;
 }


 /*
  * local variables:
  * eval: (load-file "../../tools/dev/svn-dev.el")
  * end:
  */
	/* rev-table.c : working with the `revisions' table
	*
	* ====================================================================
	* 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 <db.h>
	#include "svn_fs.h"
	#include "fs.h"
	#include "err.h"
	#include "dbt.h"
	#include "skel.h"
	#include "proplist.h"
	#include "validate.h"
	#include "rev-table.h"


	/* Opening/creating the `revisions' table. */

	int svn_fs__open_revisions_table (DB **revisions_p,
	DB_ENV *env,
	int create)
	{
	DB *revisions;

	DB_ERR (db_create (&revisions, env, 0));
	DB_ERR (revisions->open (revisions, "revisions", 0, DB_RECNO,
	create ? (DB_CREATE \| DB_EXCL) : 0,
	0666));

	*revisions_p = revisions;
	return 0;
	}



	/* Storing and retrieving filesystem revisions. */


	static int
	is_valid_filesystem_revision (skel_t *skel)
	{
	int len = svn_fs__list_length (skel);

	if (len == 3)
	{
	if (svn_fs__matches_atom (skel->children, "revision")
	&& skel->children->next != NULL
	&& svn_fs__is_valid_proplist (skel->children->next->next))
	{
	skel_t *id = skel->children->next;
	if (id->is_atom
	&& 0 == (1 & svn_fs__count_id_components (id->data, id->len)))
	return 1;
	}
	}

	return 0;
	}


	svn_error_t *
	svn_fs__get_rev (skel_t **skel_p,
	svn_fs_t *fs,
	svn_revnum_t rev,
	trail_t *trail)
	{
	int db_err;
	DBT key, value;
	skel_t *skel;

	/* Turn the revision number into a Berkeley DB record number.
	Revisions are numbered starting with zero; Berkeley DB record
	numbers begin with one. */
	db_recno_t recno = rev + 1;

	db_err = fs->revisions->get (fs->revisions, trail->db_txn,
	svn_fs__set_dbt (&key, &recno, sizeof (recno)),
	svn_fs__result_dbt (&value),
	0);
	svn_fs__track_dbt (&value, trail->pool);

	/* If there's no such revision, return an appropriately specific error. */
	if (db_err == DB_NOTFOUND)
	return svn_fs__err_dangling_rev (fs, rev);

	/* Handle any other error conditions. */
	SVN_ERR (DB_WRAP (fs, "reading filesystem revision", db_err));

	/* Parse and check the REVISION skel. */
	skel = svn_fs__parse_skel (value.data, value.size, trail->pool);
	if (! skel
	\|\| ! is_valid_filesystem_revision (skel))
	return svn_fs__err_corrupt_fs_revision (fs, rev);

	*skel_p = skel;
	return SVN_NO_ERROR;
	}


	svn_error_t *
	svn_fs__put_rev (svn_revnum_t *rev,
	svn_fs_t *fs,
	skel_t *skel,
	trail_t *trail)
	{
	int db_err;
	DBT key, value;
	db_recno_t recno = 0;

	/* xbc FIXME: Need a useful revision number here. */
	if (! is_valid_filesystem_revision (skel))
	return svn_fs__err_corrupt_fs_revision (fs, -1);

	db_err = fs->revisions->put (fs->revisions, trail->db_txn,
	svn_fs__recno_dbt(&key, &recno),
	svn_fs__skel_to_dbt (&value, skel, trail->pool),
	DB_APPEND);
	SVN_ERR (DB_WRAP (fs, "storing filesystem revision", db_err));

	/* Turn the record number into a Subversion revision number.
	Revisions are numbered starting with zero; Berkeley DB record
	numbers begin with one. */
	*rev = recno - 1;
	return SVN_NO_ERROR;
	}


	svn_error_t *
	svn_fs__rev_get_root (svn_fs_id_t **root_id_p,
	svn_fs_t *fs,
	svn_revnum_t rev,
	trail_t *trail)
	{
	skel_t *skel;
	svn_fs_id_t *id;

	SVN_ERR (svn_fs__get_rev (&skel, fs, rev, trail));

	id = svn_fs_parse_id (skel->children->next->data,
	skel->children->next->len,
	trail->pool);

	/* The skel validator doesn't check the ID format. */
	if (id == NULL)
	return svn_fs__err_corrupt_fs_revision (fs, -1);

	*root_id_p = id;
	return SVN_NO_ERROR;
	}




	/* Getting the youngest revision. */


	svn_error_t *
	svn_fs__youngest_rev (svn_revnum_t *youngest_p,
	svn_fs_t *fs,
	trail_t *trail)
	{
	int db_err;
	DBC *cursor = 0;
	DBT key, value;
	db_recno_t recno;

	SVN_ERR (svn_fs__check_fs (fs));

	/* Create a database cursor. */
	SVN_ERR (DB_WRAP (fs, "getting youngest revision (creating cursor)",
	fs->revisions->cursor (fs->revisions, trail->db_txn,
	&cursor, 0)));

	/* Find the last entry in the `revisions' table. */
	db_err = cursor->c_get (cursor,
	svn_fs__recno_dbt (&key, &recno),
	svn_fs__nodata_dbt (&value),
	DB_LAST);

	if (db_err)
	{
	/* Free the cursor. Ignore any error value --- the error above
	is more interesting. */
	cursor->c_close (cursor);

	if (db_err == DB_NOTFOUND)
	/* The revision 0 should always be present, at least. */
	return
	svn_error_createf
	(SVN_ERR_FS_CORRUPT, 0, 0, fs->pool,
	"revision 0 missing from `revisions' table, in filesystem `%s'",
	fs->path);

	SVN_ERR (DB_WRAP (fs, "getting youngest revision (finding last entry)",
	db_err));
	}

	/* You can't commit a transaction with open cursors, because:
	1) key/value pairs don't get deleted until the cursors referring
	to them are closed, so closing a cursor can fail for various
	reasons, and txn_commit shouldn't fail that way, and
	2) using a cursor after committing its transaction can cause
	undetectable database corruption. */
	SVN_ERR (DB_WRAP (fs, "getting youngest revision (closing cursor)",
	cursor->c_close (cursor)));

	/* Turn the record number into a Subversion revision number.
	Revisions are numbered starting with zero; Berkeley DB record
	numbers begin with one. */
	*youngest_p = recno - 1;
	return SVN_NO_ERROR;
	}


	struct youngest_rev_args {
	svn_revnum_t youngest;
	svn_fs_t *fs;
	};


	static svn_error_t *
	txn_body_youngest_rev (void *baton,
	trail_t *trail)
	{
	struct youngest_rev_args *args = baton;
	SVN_ERR (svn_fs__youngest_rev (&(args->youngest), args->fs, trail));
	return SVN_NO_ERROR;
	}


	svn_error_t *
	svn_fs_youngest_rev (svn_revnum_t *youngest_p,
	svn_fs_t *fs,
	apr_pool_t *pool)
	{
	struct youngest_rev_args args;

	SVN_ERR (svn_fs__check_fs (fs));

	args.fs = fs;
	SVN_ERR (svn_fs__retry_txn (fs, txn_body_youngest_rev, &args, pool));

	*youngest_p = args.youngest;
	return SVN_NO_ERROR;
	}



	/* Generic revision operations. */


	struct revision_prop_args {
	svn_string_t **value_p;
	svn_fs_t *fs;
	svn_revnum_t rev;
	const char *propname;
	};


	static svn_error_t *
	txn_body_revision_prop (void *baton,
	trail_t *trail)
	{
	struct revision_prop_args *args = baton;

	skel_t *skel;
	skel_t *proplist;

	SVN_ERR (svn_fs__get_rev (&skel, args->fs, args->rev, trail));

	/* PROPLIST is the third element of revision skel. */
	proplist = skel->children->next->next;

	/* Return the results of the generic property getting function. */
	return svn_fs__get_prop (args->value_p,
	proplist,
	args->propname,
	trail->pool);
	}


	svn_error_t *
	svn_fs_revision_prop (svn_string_t **value_p,
	svn_fs_t *fs,
	svn_revnum_t rev,
	const char *propname,
	apr_pool_t *pool)
	{
	struct revision_prop_args args;
	svn_string_t *value;

	SVN_ERR (svn_fs__check_fs (fs));

	args.value_p = &value;
	args.fs = fs;
	args.rev = rev;
	args.propname = propname;
	SVN_ERR (svn_fs__retry_txn (fs, txn_body_revision_prop, &args, pool));

	*value_p = value;
	return SVN_NO_ERROR;
	}


	struct revision_proplist_args {
	apr_hash_t **table_p;
	svn_fs_t *fs;
	svn_revnum_t rev;
	};


	static svn_error_t *
	txn_body_revision_proplist (void baton, trail_t trail)
	{
	struct revision_proplist_args *args = baton;
	skel_t *skel;
	skel_t *proplist;

	SVN_ERR (svn_fs__get_rev (&skel, args->fs, args->rev, trail));

	/* PROPLIST is the third element of revision skel. */
	proplist = skel->children->next->next;

	/* Return the results of the generic property hash getting function. */
	return svn_fs__make_prop_hash (args->table_p,
	proplist,
	trail->pool);
	}


	svn_error_t *
	svn_fs_revision_proplist (apr_hash_t **table_p,
	svn_fs_t *fs,
	svn_revnum_t rev,
	apr_pool_t *pool)
	{
	struct revision_proplist_args args;
	apr_hash_t *table;

	SVN_ERR (svn_fs__check_fs (fs));

	args.table_p = &table;
	args.fs = fs;
	args.rev = rev;
	SVN_ERR (svn_fs__retry_txn (fs, txn_body_revision_proplist, &args, pool));

	*table_p = table;
	return SVN_NO_ERROR;
	}


	svn_error_t *
	svn_fs__set_rev_prop (svn_fs_t *fs,
	svn_revnum_t rev,
	const char *name,
	const svn_string_t *value,
	trail_t *trail)
	{
	skel_t *skel;
	skel_t *proplist;

	SVN_ERR (svn_fs__get_rev (&skel, fs, rev, trail));

	/* PROPLIST is the third element of revision skel. */
	proplist = skel->children->next->next;

	/* Call the generic property setting function. */
	SVN_ERR (svn_fs__set_prop (proplist, name, value, trail->pool));
	{
	int db_err;
	DBT query, result;
	db_recno_t recno = rev + 1;

	/* Update the filesystem revision with the new skel that reflects
	our property edits. */
	db_err = fs->revisions->put
	(fs->revisions, trail->db_txn,
	svn_fs__set_dbt (&query, &recno, sizeof (recno)),
	svn_fs__skel_to_dbt (&result, skel, trail->pool), 0);
	SVN_ERR (DB_WRAP (fs, "updating filesystem revision", db_err));
	}

	return SVN_NO_ERROR;
	}


	struct change_rev_prop_args {
	svn_fs_t *fs;
	svn_revnum_t rev;
	const char *name;
	const svn_string_t *value;
	};


	static svn_error_t *
	txn_body_change_rev_prop (void baton, trail_t trail)
	{
	struct change_rev_prop_args *args = baton;

	SVN_ERR (svn_fs__set_rev_prop (args->fs, args->rev,
	args->name, args->value, trail));

	return SVN_NO_ERROR;
	}


	svn_error_t *
	svn_fs_change_rev_prop (svn_fs_t *fs,
	svn_revnum_t rev,
	const char *name,
	const svn_string_t *value,
	apr_pool_t *pool)
	{
	struct change_rev_prop_args args;

	SVN_ERR (svn_fs__check_fs (fs));

	args.fs = fs;
	args.rev = rev;
	args.name = name;
	args.value = value;
	SVN_ERR (svn_fs__retry_txn (fs, txn_body_change_rev_prop, &args, pool));

	return SVN_NO_ERROR;
	}



	/*
	* local variables:
	* eval: (load-file "../../tools/dev/svn-dev.el")
	* end:
	*/