FitsRequestHandler.cc

Go to the documentation of this file.

// FitsRequestHandler.cc

// This file is part of fits_handler, a data handler for the OPeNDAP data
// server.

// Copyright (c) 2004,2005 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 Atmostpheric 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 <DAS.h>
#include <DDS.h>
#include <DMR.h>
#include <D4BaseTypeFactory.h>
#include <Ancillary.h>
#include <InternalErr.h>
#include <mime_util.h>

#include <BESResponseHandler.h>
#include <BESDapError.h>

#include <BESDapNames.h>
#include <BESResponseNames.h>
#include <BESDASResponse.h>
#include <BESDDSResponse.h>
#include <BESDataDDSResponse.h>
#include <BESDMRResponse.h>

#include <BESVersionInfo.h>
#include <BESConstraintFuncs.h>
#include <BESServiceRegistry.h>
#include <BESUtil.h>

#include <fitsio.h>

#include "FitsRequestHandler.h"
#include "fits_read_attributes.h"
#include "fits_read_descriptors.h"

#define FITS_NAME "fits"

FitsRequestHandler::FitsRequestHandler(const string &name) :
                BESRequestHandler(name)
{
        add_handler(DAS_RESPONSE, FitsRequestHandler::fits_build_das);
        add_handler(DDS_RESPONSE, FitsRequestHandler::fits_build_dds);
        add_handler(DATA_RESPONSE, FitsRequestHandler::fits_build_data);

        add_handler(DMR_RESPONSE, FitsRequestHandler::fits_build_dmr);
        add_handler(DAP4DATA_RESPONSE, FitsRequestHandler::fits_build_dmr);

        add_handler(VERS_RESPONSE, FitsRequestHandler::fits_build_vers);
        add_handler(HELP_RESPONSE, FitsRequestHandler::fits_build_help);
}

FitsRequestHandler::~FitsRequestHandler()
{
}

bool FitsRequestHandler::fits_build_das(BESDataHandlerInterface &dhi)
{
        BESResponseObject *response = dhi.response_handler->get_response_object();
        BESDASResponse *bdas = dynamic_cast<BESDASResponse *>(response);
        if (!bdas) throw BESInternalError("cast error", __FILE__, __LINE__);

        try {
                bdas->set_container(dhi.container->get_symbolic_name());
                DAS *das = bdas->get_das();
                string accessed = dhi.container->access();
                string fits_error;
                if (!fits_handler::fits_read_attributes(*das, accessed, fits_error)) {
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);
                }
                Ancillary::read_ancillary_das(*das, accessed);
                bdas->clear_container();
        }
        catch( InternalErr &e ) {
                throw BESDapError(e.get_error_message(), true, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( Error &e ) {
                throw BESDapError(e.get_error_message(), false, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( ... ) {
                throw BESDapError("Unknown exception caught building FITS das response", true, unknown_error, __FILE__, __LINE__);
        }
        return true;
}

bool FitsRequestHandler::fits_build_dds(BESDataHandlerInterface &dhi)
{
        BESResponseObject *response = dhi.response_handler->get_response_object();
        BESDDSResponse *bdds = dynamic_cast<BESDDSResponse *>(response);
        if (!bdds) throw BESInternalError("cast error", __FILE__, __LINE__);

        try {
                bdds->set_container(dhi.container->get_symbolic_name());
                DDS *dds = bdds->get_dds();
                string accessed = dhi.container->access();
                string fits_error;

                if (!fits_handler::fits_read_descriptors(*dds, accessed, fits_error)) {
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);
                }

                Ancillary::read_ancillary_dds(*dds, accessed);
                DAS *das = new DAS;
                BESDASResponse bdas(das);
                bdas.set_container(dhi.container->get_symbolic_name());
                if (!fits_handler::fits_read_attributes(*das, accessed, fits_error)) {
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);
                }
                Ancillary::read_ancillary_das(*das, accessed);

                dds->transfer_attributes(das);

                bdds->set_constraint(dhi);

                bdds->clear_container();
        }
        catch( InternalErr &e ) {
                throw BESDapError(e.get_error_message(), true, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( Error &e ) {
                throw BESDapError(e.get_error_message(), false, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( ... ) {
                string err = "Unknown exception caught building FITS dds response";
                throw BESDapError(err, true, unknown_error, __FILE__, __LINE__);
        }

        return true;
}

bool FitsRequestHandler::fits_build_data(BESDataHandlerInterface &dhi)
{
        BESResponseObject *response = dhi.response_handler->get_response_object();
        BESDataDDSResponse *bdds = dynamic_cast<BESDataDDSResponse *>(response);
        if (!bdds) throw BESInternalError("cast error", __FILE__, __LINE__);

        try {
                bdds->set_container(dhi.container->get_symbolic_name());
                DataDDS *dds = bdds->get_dds();
                string accessed = dhi.container->access();
                string fits_error;
                if (!fits_handler::fits_read_descriptors(*dds, accessed, fits_error)) {
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);
                }
                Ancillary::read_ancillary_dds(*dds, accessed);

                DAS *das = new DAS;
                BESDASResponse bdas(das);
                bdas.set_container(dhi.container->get_symbolic_name());
                if (!fits_handler::fits_read_attributes(*das, accessed, fits_error)) {
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);
                }
                Ancillary::read_ancillary_das(*das, accessed);

                dds->transfer_attributes(das);

                bdds->set_constraint(dhi);

                bdds->clear_container();
        }
        catch( InternalErr &e ) {
                throw BESDapError(e.get_error_message(), true, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( Error &e ) {
                throw BESDapError(e.get_error_message(), false, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( ... ) {
                string err = "Unknown exception caught building FITS data response";
                throw BESDapError(err, true, unknown_error, __FILE__, __LINE__);
        }

        return true;
}

bool FitsRequestHandler::fits_build_dmr(BESDataHandlerInterface &dhi)
{
        string data_path = dhi.container->access();

        BaseTypeFactory factory;
        DDS dds(&factory, name_path(data_path), "3.2");
        dds.filename(data_path);

        try {
                string fits_error;

                if (!fits_handler::fits_read_descriptors(dds, data_path, fits_error))
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);

                DAS das;
                if (!fits_handler::fits_read_attributes(das, data_path, fits_error))
                        throw BESDapError(fits_error, false, unknown_error, __FILE__, __LINE__);
                Ancillary::read_ancillary_das(das, data_path);

                dds.transfer_attributes(&das);
        }
        catch( InternalErr &e ) {
                throw BESDapError(e.get_error_message(), true, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( Error &e ) {
                throw BESDapError(e.get_error_message(), false, e.get_error_code(), __FILE__, __LINE__);
        }
        catch( ... ) {
                throw BESDapError("Unknown exception caught building FITS DMR response", true, unknown_error, __FILE__, __LINE__);
        }


        // Extract the DMR Response object - this holds the DMR used by the
        // other parts of the framework.
        BESResponseObject *response = dhi.response_handler->get_response_object();
        BESDMRResponse &bdmr = dynamic_cast<BESDMRResponse &>(*response);

        // Extract the DMR Response object - this holds the DMR used by the
        // other parts of the framework.
        DMR *dmr = bdmr.get_dmr();
        dmr->set_factory(new D4BaseTypeFactory);
        dmr->build_using_dds(dds);

        bdmr.set_dap4_constraint(dhi);
        bdmr.set_dap4_function(dhi);

        return true;
}

bool FitsRequestHandler::fits_build_vers(BESDataHandlerInterface &dhi)
{
        BESResponseObject *response = dhi.response_handler->get_response_object();
        BESVersionInfo *info = dynamic_cast<BESVersionInfo *>(response);
        if (!info) throw BESInternalError("cast error", __FILE__, __LINE__);

#if 0
    info->add_module(PACKAGE_NAME, PACKAGE_VERSION);
#endif
    info->add_module(MODULE_NAME, MODULE_VERSION);

        return true;
}

bool FitsRequestHandler::fits_build_help(BESDataHandlerInterface &dhi)
{
        BESResponseObject *response = dhi.response_handler->get_response_object();
        BESInfo *info = dynamic_cast<BESInfo *>(response);
        if (!info) throw BESInternalError("cast error", __FILE__, __LINE__);

        map<string, string> attrs;
    attrs["name"] = MODULE_NAME ;
    attrs["version"] = MODULE_VERSION ;
#if 0
    attrs["name"] = PACKAGE_NAME;
    attrs["version"] = PACKAGE_VERSION;
#endif
        list<string> services;
        BESServiceRegistry::TheRegistry()->services_handled(FITS_NAME, services);
        if (services.size() > 0) {
                string handles = BESUtil::implode(services, ',');
                attrs["handles"] = handles;
        }
        info->begin_tag("module", &attrs);
        info->end_tag("module");

        return true;
}

void FitsRequestHandler::dump(ostream &strm) const
{
        strm << BESIndent::LMarg << "FitsRequestHandler::dump - (" << (void *) this << ")" << endl;
        BESIndent::Indent();
        BESRequestHandler::dump(strm);
        BESIndent::UnIndent();
}