BESContainerStorageFile.cc

// BESContainerStorageFile.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 <cerrno>
#include <sstream>
#include <fstream>
#include <iostream>
#include <cstring>
#include <list>
 
using std::stringstream;
using std::ifstream;
using std::endl;
using std::ostream;
using std::string;
using std::list;
 
#include "BESContainerStorageFile.h"
#include "BESFileContainer.h"
#include "TheBESKeys.h"
#include "BESInternalError.h"
#include "BESSyntaxUserError.h"
#include "BESInfo.h"
#include "BESServiceRegistry.h"

BESContainerStorageFile::BESContainerStorageFile(const string &n) :
    BESContainerStorage(n)
{
    // TODO: Need to store the kind of container each line represents. Does
    // it represent a file? A database entry? What? For now, they all
    // represent a BESFileContainer.
 
    string key = "BES.Container.Persistence.File." + n;
    bool found = false;
    TheBESKeys::TheKeys()->get_value(key, _file, found);
    if (_file == "") {
        string s = key + " not defined in BES configuration file";
        throw BESSyntaxUserError(s, __FILE__, __LINE__);
    }
 
    ifstream persistence_file(_file.c_str());
    int myerrno = errno;
    if (!persistence_file) {
        char *err = strerror(myerrno);
        string s = "Unable to open persistence file " + _file + ": ";
        if (err)
            s += err;
        else
            s += "Unknown error";
 
        throw BESInternalError(s, __FILE__, __LINE__);
    }
 
    try {
        char cline[80];
 
        while (!persistence_file.eof()) {
            stringstream strm;
            persistence_file.getline(cline, 80);
            if (!persistence_file.eof()) {
                strm << cline;
                BESContainerStorageFile::container *c = new BESContainerStorageFile::container;
                strm >> c->_symbolic_name;
                strm >> c->_real_name;
                strm >> c->_container_type;
                string dummy;
                strm >> dummy;
                if (c->_symbolic_name == "" || c->_real_name == "" || c->_container_type == "") {
                    delete c;
                    persistence_file.close();
                    string s = "Incomplete container persistence line in file " + _file;
                    throw BESInternalError(s, __FILE__, __LINE__);
                }
                if (dummy != "") {
                    persistence_file.close();
                    delete c;
                    string s = "Too many fields in persistence file " + _file;
                    throw BESInternalError(s, __FILE__, __LINE__);
                }
                _container_list[c->_symbolic_name] = c;
            }
        }
        persistence_file.close();
    }
    catch (...) {
        persistence_file.close();
        throw;
    }
}
 
BESContainerStorageFile::~BESContainerStorageFile()
{
    BESContainerStorageFile::Container_citer i = _container_list.begin();
    BESContainerStorageFile::Container_citer ie = _container_list.end();
    for (; i != ie; i++) {
        BESContainerStorageFile::container *c = (*i).second;
        delete c;
    }
}

BESContainer *
BESContainerStorageFile::look_for(const string &sym_name)
{
    BESFileContainer *ret_container = 0;
    BESContainerStorageFile::Container_citer i;
    i = _container_list.find(sym_name);
    if (i != _container_list.end()) {
        BESContainerStorageFile::container *c = (*i).second;
        ret_container = new BESFileContainer(c->_symbolic_name, c->_real_name, c->_container_type);
    }
 
    return ret_container;
}

void BESContainerStorageFile::add_container(const string &, const string &, const string &)
{
    string err = "Unable to add a container to a file, not yet implemented";
    throw BESInternalError(err, __FILE__, __LINE__);
}
 
void BESContainerStorageFile::add_container(BESContainer *)
{
    string err = "Unable to add a container to a file, not yet implemented";
    throw BESInternalError(err, __FILE__, __LINE__);
}

bool BESContainerStorageFile::del_container(const string &s_name)
{
    bool ret = false;
    BESContainerStorageFile::Container_iter i;
    i = _container_list.find(s_name);
    if (i != _container_list.end()) {
        BESContainerStorageFile::container *c = (*i).second;
        _container_list.erase(i);
        if (c) {
            delete c;
        }
        ret = true;
    }
    return ret;
}

bool BESContainerStorageFile::del_containers()
{
    while (_container_list.size() != 0) {
        Container_iter ci = _container_list.begin();
        BESContainerStorageFile::container *c = (*ci).second;
        _container_list.erase(ci);
        if (c) {
            delete c;
        }
    }
    return true;
}

bool BESContainerStorageFile::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);
        delete c;
        c = 0; // added jhrg 1.4.12
    }
    return isit;
}

void BESContainerStorageFile::show_containers(BESInfo &info)
{
    BESContainerStorageFile::Container_citer i;
    i = _container_list.begin();
    for (i = _container_list.begin(); i != _container_list.end(); i++) {
        BESContainerStorageFile::container *c = (*i).second;
        string sym = c->_symbolic_name;
        string real = c->_real_name;
        string type = c->_container_type;
        show_container(sym, real, type, info);
    }
}

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