31 #ifdef HAVE_UUID_UUID_H
32 #include <uuid/uuid.h>
33 #elif defined(HAVE_UUID_H)
36 #error "Could not find UUID library header"
57 #define CLEAR_LOCAL_DATA
58 #undef USE_LOCAL_TIMEOUT_SCHEME
62 #include <Structure.h>
63 #include <ConstraintEvaluator.h>
64 #include <DDXParserSAX2.h>
65 #include <Ancillary.h>
66 #include <XDRStreamMarshaller.h>
67 #include <XDRFileUnMarshaller.h>
71 #include <XMLWriter.h>
72 #include <D4AsyncUtil.h>
73 #include <D4StreamMarshaller.h>
74 #include <chunked_ostream.h>
75 #include <chunked_istream.h>
76 #include <D4ConstraintEvaluator.h>
77 #include <D4FunctionEvaluator.h>
78 #include <D4BaseTypeFactory.h>
80 #include <ServerFunctionsList.h>
82 #include <mime_util.h>
85 #if USE_LOCAL_TIMEOUT_SCHEME
87 #include <SignalHandler.h>
88 #include <EventHandler.h>
89 #include <AlarmHandler.h>
93 #include "TheBESKeys.h"
94 #include "BESDapResponseBuilder.h"
95 #include "BESContextManager.h"
96 #include "BESDapFunctionResponseCache.h"
97 #include "BESStoredDapResultCache.h"
99 #include "BESResponseObject.h"
100 #include "BESDDSResponse.h"
101 #include "BESDataDDSResponse.h"
102 #include "BESDataHandlerInterface.h"
103 #include "BESInternalFatalError.h"
104 #include "BESDataNames.h"
107 #include "BESDebug.h"
108 #include "BESStopWatch.h"
109 #include "DapFunctionUtils.h"
114 const string CRLF =
"\r\n";
115 const string BES_KEY_TIMEOUT_CANCEL =
"BES.CancelTimeoutOnSend";
124 string cancel_timeout_on_send =
"";
126 if (found && !cancel_timeout_on_send.empty()) {
128 downcase(cancel_timeout_on_send);
129 if (cancel_timeout_on_send ==
"yes" || cancel_timeout_on_send ==
"true")
130 d_cancel_timeout_on_send =
true;
134 BESDapResponseBuilder::~BESDapResponseBuilder()
136 #if USE_LOCAL_TIMEOUT_SCHEME
140 delete dynamic_cast<AlarmHandler*>(SignalHandler::instance()->remove_handler(SIGALRM));
167 d_dap2ce = www2id(_ce,
"%",
"%20");
190 d_dap4ce = www2id(_ce,
"%",
"%20");
198 return d_dap4function;
214 d_dap4function = www2id(_func,
"%",
"%20");
217 std::string BESDapResponseBuilder::get_store_result()
const
219 return d_store_result;
222 void BESDapResponseBuilder::set_store_result(std::string _sr)
224 d_store_result = _sr;
225 BESDEBUG(
"dap",
"BESDapResponseBuilder::set_store_result() - store_result: " << _sr << endl);
228 std::string BESDapResponseBuilder::get_async_accepted()
const
230 return d_async_accepted;
233 void BESDapResponseBuilder::set_async_accepted(std::string _aa)
235 d_async_accepted = _aa;
236 BESDEBUG(
"dap",
"BESDapResponseBuilder::set_async_accepted() - async_accepted: " << _aa << endl);
264 d_dataset = www2id(ds,
"%",
"%20");
292 #if USE_LOCAL_TIMEOUT_SCHEME
307 #if USE_LOCAL_TIMEOUT_SCHEME
330 if (d_cancel_timeout_on_send)
344 #if USE_LOCAL_TIMEOUT_SCHEME
346 SignalHandler *sh = SignalHandler::instance();
347 EventHandler *old_eh = sh->register_handler(SIGALRM,
new AlarmHandler());
361 #if USE_LOCAL_TIMEOUT_SCHEME
364 SignalHandler *sh = SignalHandler::instance();
365 EventHandler *old_eh = sh->register_handler(SIGALRM,
new AlarmHandler());
387 static string::size_type find_closing_paren(
const string &ce, string::size_type pos)
394 pos = ce.find_first_of(
"()", pos + 1);
395 if (pos == string::npos)
396 throw Error(malformed_expr,
"Expected to find a matching closing parenthesis in " + ce);
416 BESDEBUG(
"dap",
"BESDapResponseBuilder::split_ce() - source expression: " << expr << endl);
424 string btp_function_ce =
"";
425 string::size_type pos = 0;
429 string::size_type first_paren = ce.find(
"(", pos);
430 string::size_type closing_paren = string::npos;
431 if (first_paren != string::npos) closing_paren = find_closing_paren(ce, first_paren);
433 while (first_paren != string::npos && closing_paren != string::npos) {
435 string name = ce.substr(pos, first_paren - pos);
439 if (eval.find_function(name, &f)) {
441 if (!btp_function_ce.empty()) btp_function_ce +=
",";
442 btp_function_ce += ce.substr(pos, closing_paren + 1 - pos);
443 ce.erase(pos, closing_paren + 1 - pos);
444 if (ce[pos] ==
',') ce.erase(pos, 1);
447 pos = closing_paren + 1;
449 if (pos < ce.length() && ce.at(pos) ==
',') ++pos;
452 first_paren = ce.find(
"(", pos);
453 closing_paren = ce.find(
")", pos);
457 d_btp_func_ce = btp_function_ce;
459 BESDEBUG(
"dap",
"BESDapResponseBuilder::split_ce() - Modified constraint: " << d_dap2ce << endl);
460 BESDEBUG(
"dap",
"BESDapResponseBuilder::split_ce() - BTP Function part: " << btp_function_ce << endl);
461 BESDEBUG(
"dap",
"BESDapResponseBuilder::split_ce() - END" << endl);
471 throw_if_dap2_response_too_big(DDS *dds)
473 if (dds->get_response_limit() != 0 && ((dds->get_request_size(
true)) > dds->get_response_limit())) {
474 string msg =
"The Request for " + long_to_string(dds->get_request_size(
true) / 1024)
475 +
"KB is too large; requests on this server are limited to "
476 + long_to_string(dds->get_response_limit() /1024) +
"KB.";
495 void BESDapResponseBuilder::send_das(ostream &out, DAS &das,
bool with_mime_headers)
const
497 if (with_mime_headers) set_mime_text(out, dods_das, x_plain, last_modified_time(d_dataset),
"2.0");
521 void BESDapResponseBuilder::send_das(ostream &out, DDS **dds, ConstraintEvaluator &eval,
bool constrained,
522 bool with_mime_headers)
524 #if USE_LOCAL_TIMEOUT_SCHEME
526 establish_timeout(out);
527 dds.set_timeout(d_timeout);
530 if (with_mime_headers) set_mime_text(out, dods_das, x_plain, last_modified_time(d_dataset),
"2.0");
532 conditional_timeout_cancel();
534 (*dds)->print_das(out);
545 if (!d_btp_func_ce.empty()) {
546 ConstraintEvaluator func_eval;
550 if (responseCache && responseCache->can_be_cached(*dds, get_btp_func_ce())) {
554 func_eval.parse_constraint(get_btp_func_ce(), **dds);
555 fdds = func_eval.eval_function_clauses(**dds);
558 delete *dds; *dds = 0;
561 if (with_mime_headers)
562 set_mime_text(out, dods_das, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
564 conditional_timeout_cancel();
566 (*dds)->print_das(out);
569 eval.parse_constraint(d_dap2ce, **dds);
571 if (with_mime_headers)
572 set_mime_text(out, dods_das, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
574 conditional_timeout_cancel();
576 (*dds)->print_das(out);
602 bool with_mime_headers)
605 if (with_mime_headers)
606 set_mime_text(out, dods_dds, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
608 conditional_timeout_cancel();
615 #if USE_LOCAL_TIMEOUT_SCHEME
617 establish_timeout(out);
618 dds.set_timeout(d_timeout);
627 if (!d_btp_func_ce.empty()) {
628 ConstraintEvaluator func_eval;
633 if (responseCache && responseCache->can_be_cached(*dds, get_btp_func_ce())) {
637 func_eval.parse_constraint(get_btp_func_ce(), **dds);
638 fdds = func_eval.eval_function_clauses(**dds);
641 delete *dds; *dds = 0;
649 (*dds)->mark_all(
false);
661 promote_function_output_structures(*dds);
663 eval.parse_constraint(d_dap2ce, **dds);
665 if (with_mime_headers)
666 set_mime_text(out, dods_dds, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
669 conditional_timeout_cancel();
671 (*dds)->print_constrained(out);
674 eval.parse_constraint(d_dap2ce, **dds);
676 if (with_mime_headers)
677 set_mime_text(out, dods_dds, x_plain, last_modified_time(d_dataset),(*dds)->get_dap_version());
679 conditional_timeout_cancel();
681 (*dds)->print_constrained(out);
687 #ifdef DAP2_STORED_RESULTS
702 bool BESDapResponseBuilder::store_dap2_result(ostream &out, DDS &dds, ConstraintEvaluator &eval)
704 if (get_store_result().empty())
return false;
706 string serviceUrl = get_store_result();
717 string *stylesheet_ref = 0, ss_ref_value;
719 if (found && ss_ref_value.length() > 0) {
720 stylesheet_ref = &ss_ref_value;
724 if (resultCache == NULL) {
731 string msg =
"The Stored Result request cannot be serviced. ";
732 msg +=
"Unable to acquire StoredResultCache instance. ";
733 msg +=
"This is most likely because the StoredResultCache is not (correctly) configured.";
735 BESDEBUG(
"dap",
"[WARNING] " << msg << endl);
737 d4au.writeD4AsyncResponseRejected(xmlWrtr, UNAVAILABLE, msg, stylesheet_ref);
738 out << xmlWrtr.get_doc();
741 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap2_result() - Sent AsyncRequestRejected" << endl);
743 else if (get_async_accepted().length() != 0) {
748 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap2_result() - serviceUrl="<< serviceUrl << endl);
751 string storedResultId =
"";
752 storedResultId = resultCache->store_dap2_result(dds, get_ce(),
this, &eval);
755 "BESDapResponseBuilder::store_dap2_result() - storedResultId='"<< storedResultId <<
"'" << endl);
758 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap2_result() - targetURL='"<< targetURL <<
"'" << endl);
761 d4au.writeD4AsyncAccepted(xmlWrtr, 0, 0, targetURL, stylesheet_ref);
762 out << xmlWrtr.get_doc();
765 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap2_result() - sent DAP4 AsyncAccepted response" << endl);
772 d4au.writeD4AsyncRequired(xmlWrtr, 0, 0, stylesheet_ref);
773 out << xmlWrtr.get_doc();
776 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap2_result() - sent DAP4 AsyncRequired response" << endl);
790 if (BESISDEBUG(TIMING_LOG)) sw.
start(
"BESDapResponseBuilder::serialize_dap2_data_dds",
"");
792 BESDEBUG(
"dap",
"BESDapResponseBuilder::serialize_dap2_data_dds() - BEGIN" << endl);
794 (*dds)->print_constrained(out);
798 XDRStreamMarshaller m(out);
802 conditional_timeout_cancel();
805 for (DDS::Vars_iter i = (*dds)->var_begin(); i != (*dds)->var_end(); i++) {
806 if ((*i)->send_p()) {
807 (*i)->serialize(eval, **dds, m, ce_eval);
808 #ifdef CLEAR_LOCAL_DATA
809 (*i)->clear_local_data();
814 BESDEBUG(
"dap",
"BESDapResponseBuilder::serialize_dap2_data_dds() - END" << endl);
817 #ifdef DAP2_STORED_RESULTS
826 void BESDapResponseBuilder::serialize_dap2_data_ddx(ostream &out, DDS **dds, ConstraintEvaluator &eval,
827 const string &boundary,
const string &start,
bool ce_eval)
829 BESDEBUG(
"dap", __PRETTY_FUNCTION__ <<
" BEGIN" << endl);
832 libdap::set_mime_ddx_boundary(out, boundary, start, dods_ddx, x_plain);
838 uuid_unparse(uu, &uuid[0]);
840 if (getdomainname(domain, 255) != 0 || strlen(domain) == 0) strncpy(domain,
"opendap.org", 255);
842 string cid = string(&uuid[0]) +
"@" + string(&domain[0]);
846 (*dds)->print_xml_writer(out,
true, cid);
849 set_mime_data_boundary(out, boundary, cid, dods_data_ddx , x_plain);
851 XDRStreamMarshaller m(out);
853 conditional_timeout_cancel();
857 for (DDS::Vars_iter i = (*dds)->var_begin(); i != (*dds)->var_end(); i++) {
858 if ((*i)->send_p()) {
859 (*i)->serialize(eval, **dds, m, ce_eval);
860 #ifdef CLEAR_LOCAL_DATA
861 (*i)->clear_local_data();
866 BESDEBUG(
"dap", __PRETTY_FUNCTION__ <<
" END" << endl);
888 #if USE_LOCAL_TIMEOUT_SCHEME
909 BESDEBUG(
"dap",
"BESDapResponseBuilder::process_dap2_dds() - BEGIN"<< endl);
918 set_dataset_name(dds->filename());
919 set_ce(dhi.
data[POST_CONSTRAINT]);
920 set_async_accepted(dhi.
data[ASYNC]);
921 set_store_result(dhi.
data[STORE_RESULT]);
923 ConstraintEvaluator &eval = bdds->
get_ce();
931 if (!d_btp_func_ce.empty()) {
934 ConstraintEvaluator func_eval;
936 if (responseCache && responseCache->can_be_cached(dds, get_btp_func_ce())) {
940 func_eval.parse_constraint(get_btp_func_ce(), *dds);
941 fdds = func_eval.eval_function_clauses(*dds);
948 dds->mark_all(
false);
950 promote_function_output_structures(dds);
953 eval.parse_constraint(d_dap2ce, *dds);
978 BESDEBUG(
"dap",
"BESDapResponseBuilder::intern_dap2_data() - BEGIN"<< endl);
983 if (!bdds)
throw BESInternalFatalError(
"Expected a BESDataDDSResponse instance", __FILE__, __LINE__);
985 DDS *dds = bdds->get_dds();
987 set_dataset_name(dds->filename());
988 set_ce(dhi.
data[POST_CONSTRAINT]);
989 set_async_accepted(dhi.
data[ASYNC]);
990 set_store_result(dhi.
data[STORE_RESULT]);
992 ConstraintEvaluator &eval = bdds->get_ce();
1000 if (!get_btp_func_ce().empty()) {
1002 "BESDapResponseBuilder::intern_dap2_data() - Found function(s) in CE: " << get_btp_func_ce() << endl);
1006 ConstraintEvaluator func_eval;
1008 if (responseCache && responseCache->can_be_cached(dds, get_btp_func_ce())) {
1012 func_eval.parse_constraint(get_btp_func_ce(), *dds);
1013 fdds = func_eval.eval_function_clauses(*dds);
1025 dds->mark_all(
false);
1036 promote_function_output_structures(dds);
1040 eval.parse_constraint(get_ce(), *dds);
1042 dds->tag_nested_sequences();
1044 throw_if_dap2_response_too_big(dds);
1048 for (DDS::Vars_iter i = dds->var_begin(), e = dds->var_end(); i != e; ++i) {
1049 if ((*i)->send_p()) {
1050 (*i)->intern_data(eval, *dds);
1054 BESDEBUG(
"dap",
"BESDapResponseBuilder::intern_dap2_data() - END"<< endl);
1073 bool with_mime_headers)
1075 BESDEBUG(
"dap",
"BESDapResponseBuilder::send_dap2_data() - BEGIN"<< endl);
1077 #if USE_LOCAL_TIMEOUT_SCHEME
1079 establish_timeout(data_stream);
1080 dds.set_timeout(d_timeout);
1089 if (!get_btp_func_ce().empty()) {
1091 "BESDapResponseBuilder::send_dap2_data() - Found function(s) in CE: " << get_btp_func_ce() << endl);
1095 ConstraintEvaluator func_eval;
1097 if (response_cache && response_cache->can_be_cached(*dds, get_btp_func_ce())) {
1101 func_eval.parse_constraint(get_btp_func_ce(), **dds);
1102 fdds = func_eval.eval_function_clauses(**dds);
1105 delete *dds; *dds = 0;
1108 (*dds)->mark_all(
false);
1110 promote_function_output_structures(*dds);
1113 eval.parse_constraint(get_ce(), **dds);
1115 (*dds)->tag_nested_sequences();
1117 throw_if_dap2_response_too_big(*dds);
1119 if (with_mime_headers)
1120 set_mime_binary(data_stream, dods_data, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
1122 #if STORE_DAP2_RESULT_FEATURE
1124 if (!store_dap2_result(data_stream, **dds, eval)) {
1125 serialize_dap2_data_dds(data_stream, dds, eval,
true );
1128 serialize_dap2_data_dds(data_stream, dds, eval,
true );
1133 BESDEBUG(
"dap",
"BESDapResponseBuilder::send_dap2_data() - Simple constraint" << endl);
1135 eval.parse_constraint(get_ce(), **dds);
1137 (*dds)->tag_nested_sequences();
1139 throw_if_dap2_response_too_big(*dds);
1141 if (with_mime_headers)
1142 set_mime_binary(data_stream, dods_data, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
1144 #if STORE_DAP2_RESULT_FEATURE
1146 if (!store_dap2_result(data_stream, **dds, eval)) {
1147 serialize_dap2_data_dds(data_stream, dds, eval);
1150 serialize_dap2_data_dds(data_stream, dds, eval);
1154 data_stream << flush;
1156 BESDEBUG(
"dap",
"BESDapResponseBuilder::send_dap2_data() - END"<< endl);
1176 if (d_dap2ce.empty()) {
1177 if (with_mime_headers)
1178 set_mime_text(out, dods_ddx, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
1180 (*dds)->print_xml_writer(out,
false ,
"");
1186 #if USE_LOCAL_TIMEOUT_SCHEME
1188 establish_timeout(out);
1189 dds.set_timeout(d_timeout);
1198 if (!d_btp_func_ce.empty()) {
1201 ConstraintEvaluator func_eval;
1203 if (response_cache && response_cache->can_be_cached(*dds, get_btp_func_ce())) {
1207 func_eval.parse_constraint(get_btp_func_ce(), **dds);
1208 fdds = func_eval.eval_function_clauses(**dds);
1211 delete *dds; *dds = 0;
1214 (*dds)->mark_all(
false);
1216 promote_function_output_structures(*dds);
1218 eval.parse_constraint(d_dap2ce, **dds);
1220 if (with_mime_headers)
1221 set_mime_text(out, dods_ddx, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
1223 conditional_timeout_cancel();
1225 (*dds)->print_xml_writer(out,
true,
"");
1228 eval.parse_constraint(d_dap2ce, **dds);
1230 if (with_mime_headers)
1231 set_mime_text(out, dods_ddx, x_plain, last_modified_time(d_dataset), (*dds)->get_dap_version());
1233 conditional_timeout_cancel();
1237 (*dds)->print_xml_writer(out,
true,
"");
1243 void BESDapResponseBuilder::send_dmr(ostream &out, DMR &dmr,
bool with_mime_headers)
1248 if (!d_dap4ce.empty()) {
1250 BESDEBUG(
"dap",
"BESDapResponseBuilder::send_dmr() - Parsing DAP4 constraint: '"<< d_dap4ce <<
"'"<< endl);
1252 D4ConstraintEvaluator parser(&dmr);
1253 bool parse_ok = parser.parse(d_dap4ce);
1254 if (!parse_ok)
throw Error(malformed_expr,
"Constraint Expression (" + d_dap4ce +
") failed to parse.");
1260 dmr.root()->set_send_p(
true);
1263 if (with_mime_headers) set_mime_text(out, dap4_dmr, x_plain, last_modified_time(d_dataset), dmr.dap_version());
1265 conditional_timeout_cancel();
1269 dmr.print_dap4(xml, !d_dap4ce.empty() );
1270 out << xml.get_doc() << flush;
1273 void BESDapResponseBuilder::send_dap4_data_using_ce(ostream &out, DMR &dmr,
bool with_mime_headers)
1275 if (!d_dap4ce.empty()) {
1276 D4ConstraintEvaluator parser(&dmr);
1277 bool parse_ok = parser.parse(d_dap4ce);
1278 if (!parse_ok)
throw Error(malformed_expr,
"Constraint Expression (" + d_dap4ce +
") failed to parse.");
1284 dmr.root()->set_send_p(
true);
1287 if (dmr.response_limit() != 0 && (dmr.request_size(
true) > dmr.response_limit())) {
1288 string msg =
"The Request for " + long_to_string(dmr.request_size(
true))
1289 +
"KB is too large; requests for this server are limited to " + long_to_string(dmr.response_limit())
1294 if (!store_dap4_result(out, dmr)) {
1295 serialize_dap4_data(out, dmr, with_mime_headers);
1299 void BESDapResponseBuilder::send_dap4_data(ostream &out, DMR &dmr,
bool with_mime_headers)
1304 if (!d_dap4function.empty()) {
1305 D4BaseTypeFactory d4_factory;
1306 DMR function_result(&d4_factory,
"function_results");
1310 if (!ServerFunctionsList::TheList())
1312 "The function expression could not be evaluated because there are no server functions defined on this server");
1314 D4FunctionEvaluator parser(&dmr, ServerFunctionsList::TheList());
1315 bool parse_ok = parser.parse(d_dap4function);
1316 if (!parse_ok)
throw Error(
"Function Expression (" + d_dap4function +
") failed to parse.");
1318 parser.eval(&function_result);
1322 send_dap4_data_using_ce(out, function_result, with_mime_headers);
1325 send_dap4_data_using_ce(out, dmr, with_mime_headers);
1334 BESDEBUG(
"dap",
"BESDapResponseBuilder::serialize_dap4_data() - BEGIN" << endl);
1336 if (with_mime_headers) set_mime_binary(out, dap4_data, x_plain, last_modified_time(d_dataset), dmr.dap_version());
1340 dmr.print_dap4(xml, !d_dap4ce.empty());
1345 chunked_ostream cos(out, max((
unsigned int) CHUNK_SIZE, xml.get_doc_size() + 2));
1347 conditional_timeout_cancel();
1350 cos << xml.get_doc() << CRLF << flush;
1353 D4StreamMarshaller m(cos);
1354 dmr.root()->serialize(m, dmr, !d_dap4ce.empty());
1355 #ifdef CLEAR_LOCAL_DATA
1356 dmr.root()->clear_local_data();
1360 BESDEBUG(
"dap",
"BESDapResponseBuilder::serialize_dap4_data() - END" << endl);
1379 if (get_store_result().length() != 0) {
1380 string serviceUrl = get_store_result();
1387 string *stylesheet_ref = 0, ss_ref_value;
1389 if (found && ss_ref_value.length() > 0) {
1390 stylesheet_ref = &ss_ref_value;
1394 if (resultCache == NULL) {
1401 string msg =
"The Stored Result request cannot be serviced. ";
1402 msg +=
"Unable to acquire StoredResultCache instance. ";
1403 msg +=
"This is most likely because the StoredResultCache is not (correctly) configured.";
1405 BESDEBUG(
"dap",
"[WARNING] " << msg << endl);
1406 d4au.writeD4AsyncResponseRejected(xmlWrtr, UNAVAILABLE, msg, stylesheet_ref);
1407 out << xmlWrtr.get_doc();
1409 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap4_result() - Sent AsyncRequestRejected" << endl);
1414 if (get_async_accepted().length() != 0) {
1419 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap4_result() - serviceUrl="<< serviceUrl << endl);
1421 string storedResultId =
"";
1425 "BESDapResponseBuilder::store_dap4_result() - storedResultId='"<< storedResultId <<
"'" << endl);
1428 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap4_result() - targetURL='"<< targetURL <<
"'" << endl);
1430 d4au.writeD4AsyncAccepted(xmlWrtr, 0, 0, targetURL, stylesheet_ref);
1431 out << xmlWrtr.get_doc();
1433 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap4_result() - sent AsyncAccepted" << endl);
1441 d4au.writeD4AsyncRequired(xmlWrtr, 0, 0, stylesheet_ref);
1442 out << xmlWrtr.get_doc();
1444 BESDEBUG(
"dap",
"BESDapResponseBuilder::store_dap4_result() - sent AsyncAccepted" << endl);