DmrppMetadataStore.cc

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of HYrax, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2018 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// 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 OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#include "config.h"
 
#include <iostream>
#include <string>
#include <sstream>
#include <memory>
#include <typeinfo>
 
#include <libdap/DMR.h>
#include <libdap/XMLWriter.h>
 
#include "BESDebug.h"
 
#include "BESInternalFatalError.h"
 
#include "DmrppParserSax2.h"
#include "DmrppTypeFactory.h"
#include "DmrppMetadataStore.h"
 
#include "DMRpp.h"
 
#define DEBUG_KEY "dmrpp_store"
#define MAINTAIN_STORE_SIZE_EVEN_WHEN_UNLIMITED 0
 
#ifdef HAVE_ATEXIT
#define AT_EXIT(x) atexit((x))
#else
#define AT_EXIT(x)
#endif
 
#undef SYMETRIC_ADD_RESPONSES
 
using namespace std;
using namespace libdap;
using namespace bes;
 
using namespace dmrpp;
 
DmrppMetadataStore *DmrppMetadataStore::d_instance = 0;
bool DmrppMetadataStore::d_enabled = true;
 
 
 // FIXME This code will not work correctly in a multi-thread situation. See http::EffectiveUrlCache();
DmrppMetadataStore *
DmrppMetadataStore::get_instance(const string &cache_dir, const string &prefix, unsigned long long size)
{
    if (d_enabled && d_instance == 0) {
        d_instance = new DmrppMetadataStore(cache_dir, prefix, size); // never returns null_ptr
        d_enabled = d_instance->cache_enabled();
        if (!d_enabled) {
            delete d_instance;
            d_instance = 0;
 
            BESDEBUG(DEBUG_KEY, "DmrppMetadataStore::"<<__func__ << "() - " << "Cache is DISABLED"<< endl);
        }
        else {
            AT_EXIT(delete_instance);
 
            BESDEBUG(DEBUG_KEY, "DmrppMetadataStore::"<<__func__ << "() - " << "Cache is ENABLED"<< endl);
        }
    }
 
    BESDEBUG(DEBUG_KEY, "DmrppMetadataStore::get_instance(dir,prefix,size) - d_instance: " << d_instance << endl);
 
    return d_instance;
}
 
DmrppMetadataStore *
DmrppMetadataStore::get_instance()
{
    if (d_enabled && d_instance == 0) {
        d_instance = new DmrppMetadataStore();
        d_enabled = d_instance->cache_enabled();
        if (!d_enabled) {
            delete d_instance;
            d_instance = NULL;
            BESDEBUG(DEBUG_KEY, "DmrppMetadataStore::"<<__func__ << "() - " << "Cache is DISABLED"<< endl);
        }
        else {
            AT_EXIT(delete_instance);
 
            BESDEBUG(DEBUG_KEY, "DmrppMetadataStore::"<<__func__ << "() - " << "Cache is ENABLED"<< endl);
        }
    }
 
    BESDEBUG(DEBUG_KEY, "DmrppMetadataStore::get_instance() - d_instance: " << (void *) d_instance << endl);
 
    return d_instance;
}
 
void DmrppMetadataStore::StreamDMRpp::operator()(ostream &os)
{
    // Even though StreamDMRpp is-a StreamDAP and the latter has a d_dds
    // field, we cannot use it for this version of the output operator.
    // jhrg 5/17/18
    if (d_dmr && typeid(*d_dmr) == typeid(dmrpp::DMRpp)) {
        // FIXME This is where we will add the href that points toward the data file in S3. jhrg 5/17/18
        DMRpp *dmrpp = static_cast<dmrpp::DMRpp*>(d_dmr);
        dmrpp->set_print_chunks(true);
        XMLWriter xml;
        dmrpp->print_dap4(xml);
 
        os << xml.get_doc();
    }
    else {
        throw BESInternalFatalError("StreamDMRpp output operator call with non-DMRpp instance.", __FILE__, __LINE__);
    }
}
 
bool
DmrppMetadataStore::add_responses(DMR *dmr, const string &name)
{
    bool stored_dmr = GlobalMetadataStore::add_responses(dmr, name);
 
    bool stored_dmrpp = false;
    if (typeid(*dmr) == typeid(dmrpp::DMRpp)) {
        d_ledger_entry = string("add DMR++ ").append(name);
 
        StreamDMRpp write_the_dmrpp_response(dmr);
        stored_dmrpp = store_dap_response(write_the_dmrpp_response, get_hash(name + "dmrpp_r"), name, "DMRpp");
 
        write_ledger(); // write the index line
    }
    else {
        stored_dmrpp = true;    // if dmr is not a DMRpp, not writing the object is 'success.'
    }
 
    return(stored_dmr && stored_dmrpp);
}
 
bool
DmrppMetadataStore::add_dmrpp_response(libdap::DMR *dmrpp, const std::string &name)
{
    bool stored_dmrpp = false;
    if (typeid(*dmrpp) == typeid(dmrpp::DMRpp)) {
        d_ledger_entry = string("add DMR++ ").append(name);
 
        StreamDMRpp write_the_dmrpp_response(dmrpp);
        stored_dmrpp = store_dap_response(write_the_dmrpp_response, get_hash(name + "dmrpp_r"), name, "DMRpp");
 
        write_ledger(); // write the index line
    }
    else {
        stored_dmrpp = true;    // if dmr is not a DMRpp, not writing the object is 'success.'
    }
 
    return(stored_dmrpp);
}
 
DMR *
DmrppMetadataStore::get_dmr_object(const string &name)
{
    // Get the DMR response, but then parse that so the resulting binary
    // object is built with DMR++ types so that the chunk information can be
    // stored in them.
    stringstream oss;
    write_dmr_response(name, oss);    // throws BESInternalError if not found
 
    DmrppTypeFactory dmrpp_btf;
    unique_ptr<DMRpp> dmrpp(new DMRpp(&dmrpp_btf, "mds"));
 
    DmrppParserSax2 parser;
    parser.intern(oss.str(), dmrpp.get());
 
    dmrpp->set_factory(0);
 
    return dmrpp.release();
}
 
DMRpp *
DmrppMetadataStore::get_dmrpp_object(const string &name)
{
    stringstream oss;
    write_dmrpp_response(name, oss);    // throws BESInternalError if not found
 
    DmrppTypeFactory dmrpp_btf;
    unique_ptr<DMRpp> dmrpp(new DMRpp(&dmrpp_btf, "mds"));
 
    DmrppParserSax2 parser;
    parser.intern(oss.str(), dmrpp.get());
 
    dmrpp->set_factory(0);
 
    return dmrpp.release();
}