BESContainerStorageVolatile.cc

// BESContainerStorageVolatile.cc
 
// This file is part of bes, A C++ back-end server implementation framework
// for the OPeNDAP Data Access Protocol.
 
// Copyright (c) 2004-2009 University Corporation for Atmospheric Research
// Author: 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
 
// (c) COPYRIGHT University Corporation for Atmospheric Research 2004-2005
// Please read the full copyright statement in the file COPYRIGHT_UCAR.
//
// Authors:
//      pwest       Patrick West <pwest@ucar.edu>
//      jgarcia     Jose Garcia <jgarcia@ucar.edu>
 
#include "config.h"
 
#include "BESContainerStorageVolatile.h"
#include "BESFileContainer.h"
#include "BESInternalError.h"
#include "BESSyntaxUserError.h"
#include "BESInfo.h"
#include "TheBESKeys.h"
#include "BESUtil.h"
#include "BESServiceRegistry.h"
#include "BESDebug.h"
 
// FIXME This is a lie, but it will help with debugging/design for the RemoteResources
// FIXME design/fix. Remove this once that's done. jhrg 8/7/20
#define MODULE "ngap"
#define prolog std::string("BESContainerStorageVolatile::").append(__func__).append("() - ")
 
using std::endl;
using std::string;
using std::list;
using std::ostream;

BESContainerStorageVolatile::BESContainerStorageVolatile(const string &n) :
    BESContainerStorage(n), _root_dir(""), _follow_sym_links(false)
{
    string key = "BES.Data.RootDirectory";
    bool found = false;
    TheBESKeys::TheKeys()->get_value(key, _root_dir, found);
    if (_root_dir == "") {
        string s = key + " not defined in BES configuration file";
        throw BESSyntaxUserError(s, __FILE__, __LINE__);
    }
 
    found = false;
    key = (string) "BES.FollowSymLinks";
    string s_str;
    TheBESKeys::TheKeys()->get_value(key, s_str, found);
    s_str = BESUtil::lowercase(s_str);
    if (found && (s_str == "yes" || s_str == "on" || s_str == "true")) {
        _follow_sym_links = true;
    }
}
 
BESContainerStorageVolatile::~BESContainerStorageVolatile()
{
    del_containers();
}

BESContainer *
BESContainerStorageVolatile::look_for(const string &sym_name)
{
    BESContainer *ret_container = 0;
 
    BESContainerStorageVolatile::Container_citer i;
    i = _container_list.find(sym_name);
    if (i != _container_list.end()) {
        BESContainer *c = (*i).second;
        ret_container = c->ptr_duplicate();
    }
 
    return ret_container;
}

void BESContainerStorageVolatile::add_container(const string &sym_name, const string &real_name, const string &type)
{
    // The type must be specified so that we can find the request handler
    // that knows how to handle the container.
    // Changed sym_name to real_name to make the message clearer. jhrg 11/14/19
    if (type.empty())
        throw BESInternalError(string("Unable to add container '").append(real_name).append("', the type of data must be specified."), __FILE__, __LINE__);
 
    // if the container already exists then throw an error
    BESContainerStorageVolatile::Container_citer i = _container_list.find(sym_name);
    if (i != _container_list.end()) {
        throw BESInternalError(string("A container with the name '").append(sym_name).append("' already exists"), __FILE__, __LINE__);
    }
 
    // make sure that the path to the container exists. If follow_sym_links
    // is false and there is a symbolic link in the path then an error will
    // be thrown. If the path does not exist, an error will be thrown.
    BESUtil::check_path(real_name, _root_dir, _follow_sym_links);
 
    // add the root directory to the real_name passed
    // Removed the 'false' since that is the default value. jhrg 3/3/25
    string fully_qualified_real_name = BESUtil::assemblePath(_root_dir, real_name);
 
    BESDEBUG("container","BESContainerStorageVolatile::add_container() - "
            << " _root_dir: " << _root_dir
            << " real_name: " << real_name
            << " symbolic name: " << sym_name
            << " fully_qualified_real_name: " << fully_qualified_real_name
            << " type: " << type
            << endl);
 
    // Create the file container with the new information
    BESContainer *c = new BESFileContainer(sym_name, fully_qualified_real_name, type);
    c->set_relative_name(real_name);
 
    // add it to the container list
    _container_list[sym_name] = c;
}

void BESContainerStorageVolatile::add_container(BESContainer *c)
{
    if (!c) {
        throw BESInternalError("Unable to add container, container passed is null", __FILE__, __LINE__);
    }
    if (c->get_container_type().empty()) {
        throw BESInternalError("Unable to add container, the type of data must be specified.", __FILE__, __LINE__);
    }
 
    string sym_name = c->get_symbolic_name();
 
    BESContainerStorageVolatile::Container_citer i = _container_list.find(sym_name);
    if (i != _container_list.end()) {
        throw BESInternalError(string("A container with the name '").append(sym_name).append("' already exists"), __FILE__, __LINE__);
    }
 
    _container_list[sym_name] = c;
}

bool BESContainerStorageVolatile::del_container(const string &s_name)
{
    BESDEBUG(MODULE, prolog << "BEGIN: " << s_name <<  endl);
    bool ret = false;
    BESContainerStorageVolatile::Container_iter i = _container_list.find(s_name);
    if (i != _container_list.end()) {
        BESContainer *c = (*i).second;
        _container_list.erase(i);
        if (c) {
            BESDEBUG(MODULE, prolog << "delete the container: "<< (void *) c <<  endl);
            delete c;
        }
        ret = true;
    }
    BESDEBUG(MODULE, prolog << "END" <<  endl);
    return ret;
}

bool BESContainerStorageVolatile::del_containers()
{
    BESDEBUG(MODULE, prolog << "BEGIN" <<  endl);
    while (_container_list.size() != 0) {
        Container_iter ci = _container_list.begin();
        BESContainer *c = (*ci).second;
        _container_list.erase(ci);
        if (c) {
            BESDEBUG(MODULE, prolog << "delete the container: "<< (void *) c <<  endl);
            delete c;
        }
    }
    BESDEBUG(MODULE, prolog << "END" <<  endl);
    return true;
}

bool BESContainerStorageVolatile::isData(const string &inQuestion, list<string> &provides)
{
    bool isit = false;
    BESContainer *c = look_for(inQuestion);
    if (c) {
        isit = true;
        string node_type = c->get_container_type();
        BESServiceRegistry::TheRegistry()->services_handled(node_type, provides);
    }
    return isit;
}

void BESContainerStorageVolatile::show_containers(BESInfo &info)
{
    info.add_tag("name", get_name());
    string::size_type root_len = _root_dir.size();
    BESContainerStorageVolatile::Container_iter i = _container_list.begin();
    BESContainerStorageVolatile::Container_iter e = _container_list.end();
    for (; i != e; i++) {
        BESContainer *c = (*i).second;
        string sym = c->get_symbolic_name();
        string real = c->get_real_name();
        if (real.size() > root_len) {
            if (real.compare(0, root_len, _root_dir) == 0) {
                real = real.substr(root_len, real.size() - root_len);
            }
        }
        string type = c->get_container_type();
        show_container(sym, real, type, info);
    }
}

void BESContainerStorageVolatile::dump(ostream &strm) const
{
    strm << BESIndent::LMarg << "BESContainerStorageVolatile::dump - (" << (void *) this << ")" << endl;
    BESIndent::Indent();
    strm << BESIndent::LMarg << "name: " << get_name() << endl;
    if (_container_list.size()) {
        strm << BESIndent::LMarg << "containers:" << endl;
        BESIndent::Indent();
        BESContainerStorageVolatile::Container_citer i = _container_list.begin();
        BESContainerStorageVolatile::Container_citer ie = _container_list.end();
        for (; i != ie; i++) {
            BESContainer *c = (*i).second;
            c->dump(strm);
        }
        BESIndent::UnIndent();
    }
    else {
        strm << BESIndent::LMarg << "containers: none" << endl;
    }
    BESIndent::UnIndent();
}