xml::element* make_fault(const std::exception& ex)
{
return make_fault(string(ex.what()));
}
Arc::MCC_Status Service_JavaWrapper::process(Arc::Message& inmsg, Arc::Message& outmsg)
{
JNIEnv *jenv = NULL;
/* Attach to the current Java engine thread */
jvm->AttachCurrentThread((void **)&jenv, NULL);
/* Get the process function of service */
jmethodID processID = jenv->GetMethodID(serviceClass, "process", "(Lnordugrid/arc/SOAPMessage;Lnordugrid/arc/SOAPMessage;)Lnordugrid/arc/MCC_Status;");
if (processID == NULL) {
return java_error(jenv, "Cannot find process method of Java class");
}
/* convert inmsg and outmsg to Java objects */
Arc::SOAPMessage *inmsg_ptr = NULL;
Arc::SOAPMessage *outmsg_ptr = NULL;
try {
inmsg_ptr = new Arc::SOAPMessage(inmsg);
outmsg_ptr = new Arc::SOAPMessage(outmsg);
} catch(std::exception& e) { };
if(!inmsg_ptr) {
logger.msg(Arc::ERROR, "input is not SOAP");
return make_fault(outmsg);
};
if(!outmsg_ptr) {
logger.msg(Arc::ERROR, "output is not SOAP");
return make_fault(outmsg);
};
jclass JSOAPMessageClass = jenv->FindClass("nordugrid/arc/SOAPMessage");
if (JSOAPMessageClass == NULL) {
return java_error(jenv, "Cannot find SOAPMessage object");
}
/* Get the constructor of Java object */
jmethodID constructorID = jenv->GetMethodID(JSOAPMessageClass, "<init>", "(I)V");
if (constructorID == NULL) {
return java_error(jenv, "Cannot find constructor function of message");
}
/* Convert C++ object to Java objects */
jobject jinmsg = jenv->NewObject(JSOAPMessageClass, constructorID, (jlong)((long int)inmsg_ptr));
if (jinmsg == NULL) {
return java_error(jenv, "Cannot convert input message to Java object");
}
jobject joutmsg = jenv->NewObject(JSOAPMessageClass, constructorID, (jlong)((long int)outmsg_ptr));
if (jinmsg == NULL) {
return java_error(jenv, "Cannot convert output message to Java object");
}
/* Create arguments for Java process function */
jvalue args[2];
args[0].l = jinmsg;
args[1].l = joutmsg;
/* Call the process method of Java object */
jobject jmcc_status = jenv->CallObjectMethodA(serviceObj, processID, args);
if (jmcc_status == NULL) {
return java_error(jenv, "Error in call process function of Java object");
}
/* Get SWIG specific getCPtr function of Message class */
jmethodID msg_getCPtrID = jenv->GetStaticMethodID(JSOAPMessageClass, "getCPtr", "(Lnordugrid/arc/SOAPMessage;)J");
if (msg_getCPtrID == NULL) {
return java_error(jenv, "Cannot find getCPtr method of Java Message class");
}
/* Get Java MCC_Status class */
jclass JMCC_StatusClass = jenv->FindClass("nordugrid/arc/MCC_Status");
if (JMCC_StatusClass == NULL) {
logger.msg(Arc::ERROR, "Cannot find MCC_Status object");
/* Cleanup */
jvm->DetachCurrentThread();
return Arc::MCC_Status(Arc::GENERIC_ERROR);
}
/* Get SWIG specific getCPtr function of MCC_Status class */
jmethodID mcc_status_getCPtrID = jenv->GetStaticMethodID(JMCC_StatusClass, "getCPtr", "(Lnordugrid/arc/MCC_Status;)J");
if (mcc_status_getCPtrID == NULL) {
return java_error(jenv, "Cannot find getCPtr method of Java MCC_Status class");
}
/* Convert Java status object to C++ class */
jlong mcc_status_addr = jenv->CallStaticLongMethod(JMCC_StatusClass, mcc_status_getCPtrID, jmcc_status);
if (!mcc_status_addr) {
logger.msg(ERROR, "Java object returned NULL status");
return MCC_Status(GENERIC_ERROR);
}
Arc::MCC_Status status(*((Arc::MCC_Status *)(long)mcc_status_addr));
/* Convert Java output message object to C++ class */
jlong outmsg_addr = jenv->CallStaticLongMethod(JSOAPMessageClass, msg_getCPtrID, joutmsg);
Arc::SOAPMessage *outmsg_ptr2 = (Arc::SOAPMessage *)(long)outmsg_addr;
/* std::string xml;
outmsg_ptr2->Payload()->GetXML(xml);
std::cout << xml << std::endl; */
Arc::PayloadSOAP *pl = new Arc::PayloadSOAP(*(outmsg_ptr2->Payload()));
outmsg.Payload((MessagePayload *)pl);
// XXX: how to handle error?
/* Detach from the Java engine */
jvm->DetachCurrentThread();
return status;
}
void server::handle_request(const http::request& req, http::reply& rep)
{
string action;
try
{
xml::element* response;
if (req.method == "POST") // must be a SOAP call
{
xml::document doc;
doc.read(req.payload);
envelope env(doc);
xml::element* request = env.request();
action = request->name();
log() << action << ' ';
response = make_envelope(dispatch(action, env.request()));
}
else if (req.method == "GET")
{
// start by sanitizing the request's URI
string uri = req.uri;
// strip off the http part including hostname and such
if (ba::starts_with(uri, "http://"))
{
string::size_type s = uri.find_first_of('/', 7);
if (s != string::npos)
uri.erase(0, s);
}
// now make the path relative to the root
while (uri.length() > 0 and uri[0] == '/')
uri.erase(uri.begin());
fs::path path(uri);
fs::path::iterator p = path.begin();
if (p == path.end())
throw http::bad_request;
string root = (*p++).string();
if (root == "rest")
{
action = (*p++).string();
xml::element* request(new xml::element(action));
while (p != path.end())
{
string name = http::decode_url((*p++).string());
if (p == path.end())
break;
xml::element* param(new xml::element(name));
string value = http::decode_url((*p++).string());
param->content(value);
request->append(param);
}
log() << action << ' ';
response = make_envelope(dispatch(action, request));
}
else if (root == "wsdl")
{
log() << "wsdl";
response = make_wsdl(m_location);
}
else
{
log() << req.uri;
throw http::not_found;
}
}
else
throw http::bad_request;
rep.set_content(response);
}
catch (std::exception& e)
{
rep.set_content(make_fault(e));
}
catch (http::status_type& s)
{
rep = http::reply::stock_reply(s);
}
}
