// -*- mode: c++; c-basic-offset:4 -*-
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
// Copyright (c) 2002,2003,2013 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
// Test the DMR parser
#include "config.h"
#include <stdint.h>
#include <cstring>
#include <fstream>
#include <memory>
#include "crc.h"
#include <GetOpt.h>
#include "BaseType.h"
#include "Array.h"
#include "D4Enum.h"
#include "DMR.h"
#include "D4Group.h"
#include "D4StreamUnMarshaller.h"
#include "chunked_ostream.h"
#include "chunked_istream.h"
#include "util.h"
#include "InternalErr.h"
#include "Error.h"
#include "D4ResponseBuilder.h"
#include "ConstraintEvaluator.h"
#include "D4ParserSax2.h"
#include "D4TestTypeFactory.h"
#include "TestCommon.h"
#include "D4ConstraintEvaluator.h"
#include "D4FunctionEvaluator.h"
#include "ServerFunctionsList.h"
#include "D4TestFunction.h"
#include "D4RValue.h"
#include "util.h"
#include "mime_util.h"
#include "debug.h"
int test_variable_sleep_interval = 0; // Used in Test* classes for testing timeouts.
using namespace libdap;
/**
* Open the named XML file and parse it, assuming that it contains a DMR.
* @param name The name of the DMR XML file (or '-' for stdin)
* @param debug True if the debug mode of the parse should be used
* @param print Once parsed, should the DMR object be printed?
* @return true if the parse worked, false otherwise
*/
DMR *
test_dap4_parser(const string &name, bool debug, bool print)
{
D4TestTypeFactory *factory = new D4TestTypeFactory;
DMR *dataset = new DMR(factory, path_to_filename(name));
try {
D4ParserSax2 parser;
if (name == "-") {
parser.intern(cin, dataset, debug);
}
else {
fstream in(name.c_str(), ios_base::in);
parser.intern(in, dataset, debug);
}
}
catch(...) {
delete factory;
delete dataset;
throw;
}
cout << "Parse successful" << endl;
if (print) {
XMLWriter xml(" ");
dataset->print_dap4(xml, false);
cout << xml.get_doc() << endl;
}
delete factory;
dataset->set_factory(0);
return dataset;
}
/**
* Should the changing values - meant to mimic the DTS - be used?
* @param dmr Set for this DMR
* @param state True to use the DTS-like values, false otherwise
*/
void
set_series_values(DMR *dmr, bool state)
{
if (state == true)
dmr->root()->set_read_p(false);
TestCommon *tc = dynamic_cast<TestCommon*>(dmr->root());
if (tc)
tc->set_series_values(state);
else
cerr << "Could not cast root group to TestCommon (" << dmr->root()->type_name() << ", " << dmr->root()->name() << ")" << endl;
}
/**
* Call the parser and then serialize the resulting DMR after applying the
* constraint. The persistent representation is written to a file. The file
* is name '<name>_data.bin'.
*
* @param dataset
* @param constraint
* @param series_values
* @return The name of the file that hods the response.
*/
string
send_data(DMR *dataset, const string &constraint, const string &function, bool series_values, bool ce_parser_debug)
{
set_series_values(dataset, series_values);
// This will be used by the DMR that holds the results of running the functions.
// It's declared at this scope because we (may) need it for the code beyond the
// function parse/eval code that immediately follows. jhrg 3/12/14
D4TestTypeFactory d4_factory;
auto_ptr<DMR> function_result(new DMR(&d4_factory, "function_results"));
// The Function Parser
if (!function.empty()) {
ServerFunctionsList *sf_list = ServerFunctionsList::TheList();
ServerFunction *scale = new D4TestFunction;
sf_list->add_function(scale);
D4FunctionEvaluator parser(dataset, sf_list);
if (ce_parser_debug) parser.set_trace_parsing(true);
bool parse_ok = parser.parse(function);
if (!parse_ok)
Error("Function Expression failed to parse.");
else {
if (ce_parser_debug) cerr << "Function Parse OK" << endl;
parser.eval(function_result.get());
// Now use the results of running the functions for the remainder of the
// send_data operation.
dataset = function_result.release();
}
}
D4ResponseBuilder rb;
rb.set_dataset_name(dataset->name());
string file_name = dataset->name() + "_data.bin";
ofstream out(file_name.c_str(), ios::out|ios::trunc|ios::binary);
if (!constraint.empty()) {
D4ConstraintEvaluator parser(dataset);
if (ce_parser_debug)
parser.set_trace_parsing(true);
bool parse_ok = parser.parse(constraint);
if (!parse_ok)
throw Error("Constraint Expression failed to parse.");
else if (ce_parser_debug)
cerr << "CE Parse OK" << endl;
}
else {
dataset->root()->set_send_p(true);
}
rb.send_dap(out, *dataset, /*with mime headers*/ true, !constraint.empty());
out.close();
return file_name;
}
void
intern_data(DMR *dataset, /*const string &constraint,*/ bool series_values)
{
set_series_values(dataset, series_values);
// Mark all variables to be sent in their entirety. No CEs are used
// when 'interning' variables' data.
dataset->root()->set_send_p(true);
#if 0
Crc32 checksum;
#endif
dataset->root()->intern_data(/*checksum, *dataset, eval*/);
}
DMR *
read_data_plain(const string &file_name, bool debug)
{
D4BaseTypeFactory *factory = new D4BaseTypeFactory;
DMR *dmr = new DMR(factory, "Test_data");
fstream in(file_name.c_str(), ios::in|ios::binary);
// Gobble up the response's initial set of MIME headers. Normally
// a client would extract information from these headers.
remove_mime_header(in);
chunked_istream cis(in, CHUNK_SIZE);
// parse the DMR, stopping when the boundary is found.
try {
// force chunk read
// get chunk size
int chunk_size = cis.read_next_chunk();
// get chunk
char chunk[chunk_size];
cis.read(chunk, chunk_size);
// parse char * with given size
D4ParserSax2 parser;
// Mirror the behavior in D4Connect where we are permissive with DAP4
// data responses' parsing, as per Hyrax-98 in Jira. jhrg 4/13/16
parser.set_strict(false);
// '-2' to discard the CRLF pair
parser.intern(chunk, chunk_size-2, dmr, debug);
}
catch(Error &e) {
delete factory;
delete dmr;
cerr << "Exception: " << e.get_error_message() << endl;
return 0;
}
catch(std::exception &e) {
delete factory;
delete dmr;
cerr << "Exception: " << e.what() << endl;
return 0;
}
catch(...) {
delete factory;
delete dmr;
cerr << "Exception: unknown error" << endl;
return 0;
}
D4StreamUnMarshaller um(cis, cis.twiddle_bytes());
dmr->root()->deserialize(um, *dmr);
delete factory;
dmr->set_factory(0);
return dmr;
}
static void usage()
{
cerr << "Usage: dmr-test -p|s|t|i <file> [-c <expr>] [-f <function expression>] [-d -x -e]" << endl
<< "p: Parse a file (use \"-\" for stdin; if a ce or a function is passed those are parsed too)" << endl
<< "s: Send: parse and then 'send' a response to a file" << endl
<< "t: Transmit: parse, send and then read the response file" << endl
<< "i: Intern values (ce and function will be ignored by this)" << endl
<< "c: Constraint expression " << endl
<< "f: Function expression" << endl
<< "d: turn on detailed xml parser debugging" << endl
<< "D: turn on detailed ce parser debugging" << endl
<< "x: print the binary object(s) built by the parse, send, trans or intern operations." << endl
<< "e: use sEries values." << endl;
}
int
main(int argc, char *argv[])
{
GetOpt getopt(argc, argv, "p:s:t:i:c:f:xdDeh?");
int option_char;
bool parse = false;
bool debug = false;
bool print = false;
bool send = false;
bool trans = false;
bool intern = false;
bool series_values = false;
bool constrained = false;
bool functional = false;
bool ce_parser_debug = false;
string name = "";
string ce = "";
string function = "";
// process options
while ((option_char = getopt()) != -1)
switch (option_char) {
case 'p':
parse = true;
name = getopt.optarg;
break;
case 's':
send = true;
name = getopt.optarg;
break;
case 't':
trans = true;
name = getopt.optarg;
break;
case 'i':
intern = true;
name = getopt.optarg;
break;
case 'c':
constrained = true;
ce = getopt.optarg;
break;
case 'f':
functional = true;
function = getopt.optarg;
break;
case 'd':
debug = true;
break;
case 'D':
ce_parser_debug = true;
break;
case 'x':
print = true;
break;
case 'e':
series_values = true;
break;
case '?':
case 'h':
usage();
return 0;
default:
cerr << "Error: ";
usage();
return 1;
}
if (! (parse || send || trans || intern)) {
cerr << "Error: ";
usage();
return 1;
}
try {
if (parse) {
DMR *dmr = test_dap4_parser(name, debug, print);
// The CE Parser
if (!ce.empty()) {
try {
D4ConstraintEvaluator parser(dmr);
if (ce_parser_debug) parser.set_trace_parsing(true);
bool parse_ok = parser.parse(ce);
if (!parse_ok)
cout << "CE Parse Failed" << endl;
else
cout << "CE Parse OK" << endl;
}
catch (Error &e) {
cerr << "CE Parse error: " << e.get_error_message() << endl;
}
catch (...) {
cerr << "Ce Parse error: Unknown exception thrown by parser" << endl;
}
}
// The Function Parser
if (!function.empty()) {
try {
ServerFunctionsList *sf_list = ServerFunctionsList::TheList();
ServerFunction *scale = new D4TestFunction;
sf_list->add_function(scale);
D4FunctionEvaluator parser(dmr, sf_list);
if (ce_parser_debug) parser.set_trace_parsing(true);
bool parse_ok = parser.parse(function);
if (!parse_ok)
cout << "Function Parse Failed" << endl;
else
cout << "Function Parse OK" << endl;
}
catch (Error &e) {
cerr << "Function Parse error: " << e.get_error_message() << endl;
}
catch (...) {
cerr << "Function Parse error: Unknown exception thrown by parser" << endl;
}
}
delete dmr;
}
if (send) {
DMR *dmr = test_dap4_parser(name, debug, print);
string file_name = send_data(dmr, ce, function, series_values, ce_parser_debug);
if (print)
cout << "Response file: " << file_name << endl;
delete dmr;
}
if (trans) {
DMR *dmr = test_dap4_parser(name, debug, print);
string file_name = send_data(dmr, ce, function, series_values, ce_parser_debug);
delete dmr;
DMR *client = read_data_plain(file_name, debug);
if (print) {
XMLWriter xml;
// received data never have send_p set; don't set 'constrained'
client->print_dap4(xml, false /* constrained */);
cout << xml.get_doc() << endl;
cout << "The data:" << endl;
}
// if trans is used, the data are printed regardless of print's value
client->root()->print_val(cout, "", false);
cout << endl;
delete client;
}
if (intern) {
DMR *dmr = test_dap4_parser(name, debug, print);
intern_data(dmr, /*ce,*/ series_values);
if (print) {
XMLWriter xml;
dmr->print_dap4(xml, false /*constrained*/);
cout << xml.get_doc() << endl;
cout << "The data:" << endl;
}
// if trans is used, the data are printed regardless of print's value
dmr->root()->print_val(cout, /*space*/"", false);
cout << endl;
delete dmr;
}
}
catch (Error &e) {
cerr << "Error: " << e.get_error_message() << endl;
return 1;
}
return 0;
}