BESUncompressManager3.cc

// BESUncompressManager3.cc
 
// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.
 
// Copyright (c) 2012 OPeNDAP, Inc
// Author: James Gallagher <jgallagher@opendap.org>
//         Patrick West <pwest@ucar.edu> and
//         Jose Garcia <jgarcia@ucar.edu>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301
 
#include "config.h"
 
#include <mutex>
 
#include <sstream>
 
using std::istringstream;
using std::endl;
using std::ostream;
using std::string;
 
#include "BESUncompressManager3.h"
#include "BESUncompress3GZ.h"
#include "BESUncompress3BZ2.h"
#include "BESUncompress3Z.h"
 
#include "BESFileLockingCache.h"
 
#include "BESInternalError.h"
#include "BESDebug.h"
 
#include "TheBESKeys.h"
 
BESUncompressManager3 *BESUncompressManager3::d_instance = nullptr;
static std::once_flag d_euc_init_once;

BESUncompressManager3::BESUncompressManager3()
{
    add_method("gz", BESUncompress3GZ::uncompress);
    add_method("bz2", BESUncompress3BZ2::uncompress);
    add_method("Z", BESUncompress3Z::uncompress);
}
 
BESUncompressManager3::~BESUncompressManager3() {}

bool BESUncompressManager3::add_method(const string &name, p_bes_uncompress method)
{
    std::lock_guard<std::recursive_mutex> lock_me(d_cache_lock_mutex);
 
    BESUncompressManager3::UCIter i;
    i = _uncompress_list.find(name);
    if (i == _uncompress_list.end()) {
        _uncompress_list[name] = method;
        return true;
    }
    return false;
}

p_bes_uncompress BESUncompressManager3::find_method(const string &name)
{
    std::lock_guard<std::recursive_mutex> lock_me(d_cache_lock_mutex);
 
    BESUncompressManager3::UCIter i;
    i = _uncompress_list.find(name);
    if (i != _uncompress_list.end()) {
        return (*i).second;
    }
    return 0;
}

bool BESUncompressManager3::uncompress(const string &src, string &cache_file, BESFileLockingCache *cache)
{
    std::lock_guard<std::recursive_mutex> lock_me(d_cache_lock_mutex);
 
    BESDEBUG( "uncompress2", "BESUncompressManager3::uncompress() - src: " << src << endl );

    if (cache == NULL) {
        std::ostringstream oss;
        oss << "BESUncompressManager3::" << __func__ << "() - ";
        oss << "The supplied Cache object is NULL. Decompression Requires An Operational Cache.";
        throw BESInternalError(oss.str(), __FILE__, __LINE__);
    }
 
    // All compressed files have a 'dot extension'.
    string::size_type dot = src.rfind(".");
    if (dot == string::npos) {
        BESDEBUG( "uncompress2", "BESUncompressManager3::uncompress() - no file extension" << endl );
        return false;
    }
 
    string ext = src.substr(dot + 1, src.size() - dot);
 
    // If there's no match for the extension, the file is not compressed and we return false.
    // Otherwise, 'p' points to a function that uncompresses the data.
    p_bes_uncompress p = find_method(ext);
    if (!p) {
        BESDEBUG( "uncompress2", "BESUncompressManager3::uncompress() - not compressed " << endl );
        return false;
    }
 
    // Get the name of the file in the cache (either the code finds this file or
    // it makes it).
    cache_file = cache->get_cache_file_name(src);
 
#if 0
    try {
        BESDEBUG( "uncompress2", "BESUncompressManager3::uncompress() - is cached? " << src << endl );
#endif
 
        int fd;
        if (cache->get_read_lock(cache_file, fd)) {
            BESDEBUG( "uncompress", "BESUncompressManager3::uncompress() - cached hit: " << cache_file << endl );
            return true;
        }
 
        // Now we actually try to uncompress the file, given that there's not a decomp'd version
        // in the cache. First make an empty file and get an exclusive lock on it.
        if (cache->create_and_lock(cache_file, fd)) {
            BESDEBUG( "uncompress", "BESUncompressManager3::uncompress() - caching " << cache_file << endl );
 
            // uncompress. Make sure that the decompression function does not close
            // the file descriptor.
            p(src, fd);
 
            // Change the exclusive lock on the new file to a shared lock. This keeps
            // other processes from purging the new file and ensures that the reading
            // process can use it.
            cache->exclusive_to_shared_lock(fd);
 
            // Now update the total cache size info and purge if needed. The new file's
            // name is passed into the purge method because this process cannot detect its
            // own lock on the file.
            unsigned long long size = cache->update_cache_info(cache_file);
            if (cache->cache_too_big(size))
                cache->update_and_purge(cache_file);
 
            return true;
        }
        else {
            if (cache->get_read_lock(cache_file, fd)) {
                BESDEBUG( "uncompress", "BESUncompressManager3::uncompress() - cached hit: " << cache_file << endl );
                return true;
            }
        }
 
        return false;
#if 0
    }
    catch (...) {
        BESDEBUG( "uncompress", "BESUncompressManager3::uncompress() - caught exception, unlocking cache and re-throw." << endl );
        cache->unlock_cache();
        throw;
    }
 
    return false;   // gcc warns without this
#endif
}

void BESUncompressManager3::dump(ostream &strm) const
{
    std::lock_guard<std::recursive_mutex> lock_me(d_cache_lock_mutex);
 
    strm << BESIndent::LMarg << "BESUncompressManager3::dump - (" << (void *) this << ")" << endl;
    BESIndent::Indent();
    if (_uncompress_list.size()) {
        strm << BESIndent::LMarg << "registered uncompression methods:" << endl;
        BESIndent::Indent();
        BESUncompressManager3::UCIter i = _uncompress_list.begin();
        BESUncompressManager3::UCIter ie = _uncompress_list.end();
        for (; i != ie; i++) {
            strm << BESIndent::LMarg << (*i).first << endl;
        }
        BESIndent::UnIndent();
    }
    else {
        strm << BESIndent::LMarg << "registered uncompress methods: none" << endl;
    }
    BESIndent::UnIndent();
}
 
BESUncompressManager3 *
BESUncompressManager3::TheManager()
{
    std::call_once(d_euc_init_once,BESUncompressManager3::initialize_instance);
    return d_instance;
}
 
void BESUncompressManager3::initialize_instance() {
    d_instance = new BESUncompressManager3;
#ifdef HAVE_ATEXIT
    atexit(delete_instance);
#endif
}
 
void BESUncompressManager3::delete_instance() {
    delete d_instance;
    d_instance = 0;
}