hash_db.cpp

Go to the documentation of this file.

/*
 * hash_db.cpp
 *
 * Copyright (C) 2006,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of a simple datahash database.
 * See hash_db.h
 */

// includes --------------------------------------------------------------------
#include "hash_db.h"            // always include our own header first!

#include "util/file.h"          // for advisory locking
#include "perf/perf.h"          // performance timers

#include "datahash/datahash_text.h"     // textfile support for datahashes
#include "datahash/datahash_util.h"     // datahash utility methods


namespace hash_db {

// virtual d'tor implementation
Database::~Database(void) throw() { }


static const char * s_fileHeader =
        "#\n"
        "# hash_db::Database persistence file.\n"
        "#\n"
        "# This is a simple text-only file for persisting hashes transactionally.\n"
        "# Be careful about editing--the database objects use advisory locks on\n"
        "# this file so that only one process can access it at a time.\n"
        "#\n";


////////////////////////////////////////////////////////////////////////////////
//
//      private static methods
//
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
//      DbImpl -- class that implements the hash_db::Database interface
//
////////////////////////////////////////////////////////////////////////////////

class DbImpl : public Database {
public:
        ~DbImpl(void) throw() { }

        // public class methods ------------------------------------------------
        bool initialize(IN const char * path);

        // hash_db::Database class interface methods ---------------------------
        void getIds(OUT SetString& ids);
        bool addObject(IN const char * id,
                                IN smart_ptr<Datahash> obj);
        smart_ptr<Datahash> getObject(IN const char * id);
        bool deleteObject(IN const char * id);
        bool commit(void);

private:
        // private helper methods ----------------------------------------------

        // private data members ------------------------------------------------
        std::string                     m_path; // path to database file
        smart_ptr<Datahash>             m_root; // root data hash
        AdvisoryLock                    m_lock;
};



bool
DbImpl::initialize
(
IN const char * path
)
{
        perf::Timer timer("hash_db::initialize");
        ASSERT(path, "null path");

        // find or create lockfile
        std::string lockfile = path;
        lockfile += ".lock";
        createEmptyFileIfDoesNotExist(lockfile.c_str());

        // attempt to lock, abort entire process if we fail
#ifndef WIN32
        if (!m_lock.attemptLock(lockfile.c_str(), LOCK_EX | LOCK_NB)) {
                DPRINTF("Failed to get advisory lock on database file: '%s'",
                    path);
                return false;
        }
#endif  // WIN32

        // save path
        m_path = path;
        createEmptyFileIfDoesNotExist(path);

        // okay, read from hash
        m_root = readHashFromTextFile(path);
        if (!m_root) {
                DPRINTF("Failed to read hash from text file: corrupt?\n");
                return false;
        }

        // good to go
        return true;
}



void
DbImpl::getIds
(
OUT SetString& ids
)
{
        ASSERT(m_root, "null");

        ids.clear();    // initialize

        Datahash::iterator_t i;
        m_root->getIterator(i);
        std::string k;
        hash_value_t hv;
        while (m_root->getNextElement(i, k, hv)) {
                const char * name = k.c_str();

                ASSERT_THROW(eHashDataType_Hash == hv.type,
                    "All root children should be complex (hash type)");

                ids.insert(name);
        }
}



bool
DbImpl::addObject
(
IN const char * id,
IN smart_ptr<Datahash> obj
)
{
        ASSERT(id, "null id");
        ASSERT(obj, "null object hash");

        SetString ids;
        this->getIds(ids);

        if (ids.end() != ids.find(id)) {
                DPRINTF("Not adding object: id already exists: '%s'", id);
                return false;
        }

        m_root->insert(id, obj);
        return true;
}



smart_ptr<Datahash>
DbImpl::getObject
(
IN const char * id
)
{
        ASSERT(m_root, "null");
        ASSERT(id, "null");

        if (!m_root->count(id)) {
                DPRINTF("Cannot get object--no such id '%s'", id);
                return 0;
        }

        smart_ptr<Datahash> obj = getSubhash(m_root, id);
        ASSERT(obj, "null retrieval?");

        return obj;
}



bool
DbImpl::deleteObject
(
IN const char * id
)
{
        ASSERT(m_root, "null");
        ASSERT(id, "null id to delete");

        if (!m_root->count(id)) {
                DPRINTF("Cannot delete object--no such id '%s'", id);
                return false;
        }

        m_root->remove(id);

        return true;
}



bool
DbImpl::commit(void)
{
        perf::Timer timer("hash_db::commit");
        ASSERT(m_root, "null");

        // note: the API we are calling is already atomic
        writeHashToTextFile(m_root, m_path.c_str(), s_fileHeader);

        return true;
}




//////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Database>
Database::create
(
IN const char * path
)
{
        ASSERT(path, "null db path");

#ifdef WIN32
        ASSERT_THROW(false,
                "Hash databases are not supported under Windows -- no advisory locking");
#endif  // WIN32

        smart_ptr<DbImpl> local = new DbImpl;
        ASSERT(local, "out of memory");

        if (!local->initialize(path)) {
                DPRINTF("Failed to initialize hash_db!");
                return NULL;
        }

        return local;
}



};      // hash_db namespace