From 0425aadc78680e53000fd0108b540d6eca048516 Mon Sep 17 00:00:00 2001 From: gmcdonald Date: Sat, 13 Feb 2010 01:32:03 +0000 Subject: Moving axis svn, part of TLP move INFRA-2441 git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68 --- src/core/transport/amqp/sender/Makefile.am | 26 ++ src/core/transport/amqp/sender/axis2_amqp_sender.c | 344 +++++++++++++++++++++ src/core/transport/amqp/sender/axis2_amqp_sender.h | 63 ++++ .../transport/amqp/sender/qpid_sender/Makefile.am | 23 ++ .../amqp/sender/qpid_sender/axis2_qpid_sender.cpp | 242 +++++++++++++++ .../amqp/sender/qpid_sender/axis2_qpid_sender.h | 49 +++ .../qpid_sender/axis2_qpid_sender_interface.cpp | 130 ++++++++ .../qpid_sender/axis2_qpid_sender_interface.h | 50 +++ 8 files changed, 927 insertions(+) create mode 100644 src/core/transport/amqp/sender/Makefile.am create mode 100644 src/core/transport/amqp/sender/axis2_amqp_sender.c create mode 100644 src/core/transport/amqp/sender/axis2_amqp_sender.h create mode 100644 src/core/transport/amqp/sender/qpid_sender/Makefile.am create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp create mode 100644 src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h (limited to 'src/core/transport/amqp/sender') diff --git a/src/core/transport/amqp/sender/Makefile.am b/src/core/transport/amqp/sender/Makefile.am new file mode 100644 index 0000000..8af0c7b --- /dev/null +++ b/src/core/transport/amqp/sender/Makefile.am @@ -0,0 +1,26 @@ +SUBDIRS = qpid_sender + +lib_LTLIBRARIES = libaxis2_amqp_sender.la + +libaxis2_amqp_sender_la_SOURCES = axis2_amqp_sender.c + +libaxis2_amqp_sender_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + $(top_builddir)/src/core/transport/amqp/sender/qpid_sender/libaxis2_qpid_sender.la + +libaxis2_amqp_sender_la_LDFLAGS = -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/transport/amqp/receiver \ + -I$(top_builddir)/src/core/transport/amqp/receiver/qpid_receiver \ + -I$(top_builddir)/src/core/transport/amqp/sender \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include + diff --git a/src/core/transport/amqp/sender/axis2_amqp_sender.c b/src/core/transport/amqp/sender/axis2_amqp_sender.c new file mode 100644 index 0000000..aae5496 --- /dev/null +++ b/src/core/transport/amqp/sender/axis2_amqp_sender.c @@ -0,0 +1,344 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include + +static const axis2_transport_sender_ops_t amqp_sender_ops = +{ + axis2_amqp_sender_init, + axis2_amqp_sender_invoke, + axis2_amqp_sender_clean_up, + axis2_amqp_sender_free +}; + +AXIS2_EXTERN axis2_transport_sender_t* AXIS2_CALL +axis2_amqp_sender_create( + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, NULL); + + axis2_amqp_sender_resource_pack_t* sender_resource_pack = NULL; + + sender_resource_pack = (axis2_amqp_sender_resource_pack_t*)AXIS2_MALLOC(env->allocator, + sizeof(axis2_amqp_sender_resource_pack_t)); + + if(!sender_resource_pack) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + sender_resource_pack->sender.ops = &amqp_sender_ops; + sender_resource_pack->conf_ctx = NULL; + + return &(sender_resource_pack->sender); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_init( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx, + axis2_transport_out_desc_t* out_desc) +{ + axis2_amqp_sender_resource_pack_t* sender_resource_pack = NULL; + axutil_property_t* property = NULL; + int* request_timeout = (int*)AXIS2_MALLOC(env->allocator, sizeof(int)); + *request_timeout = AXIS2_QPID_NULL_CONF_INT; + + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + + sender_resource_pack = AXIS2_AMQP_SENDER_TO_RESOURCE_PACK(sender); + sender_resource_pack->conf_ctx = conf_ctx; + + /* Set request timeout */ + *request_timeout = axis2_amqp_util_get_out_desc_conf_value_int(out_desc, env, + AXIS2_AMQP_CONF_QPID_REQUEST_TIMEOUT); + if(*request_timeout == AXIS2_QPID_NULL_CONF_INT) + { + *request_timeout = AXIS2_QPID_DEFAULT_REQUEST_TIMEOUT; + } + property = axutil_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0, 0, + (void*)request_timeout); + axis2_conf_ctx_set_property(sender_resource_pack->conf_ctx, env, + AXIS2_AMQP_CONF_CTX_PROPERTY_REQUEST_TIMEOUT, property); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_invoke( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx) +{ + AXIS2_ENV_CHECK(env, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE); + + axiom_soap_envelope_t* request_soap_envelope = NULL; + axiom_xml_writer_t* xml_writer = NULL; + axiom_output_t* request_om_output = NULL; + axis2_char_t* request_content = NULL; + axis2_bool_t is_server = AXIS2_TRUE; + axis2_bool_t is_soap_11 = AXIS2_FALSE; + axutil_string_t* content_type = NULL; + const axis2_char_t* soap_action = NULL; + axis2_bool_t do_mtom = AXIS2_FALSE; + axis2_bool_t status = AXIS2_FAILURE; + + request_soap_envelope = axis2_msg_ctx_get_soap_envelope(msg_ctx, env); + + xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0, + AXIS2_XML_PARSER_TYPE_BUFFER); + if(!xml_writer) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create XML Writer"); + return AXIS2_FAILURE; + } + + request_om_output = axiom_output_create(env, xml_writer); + if(!request_om_output) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Create OM Output"); + axiom_xml_writer_free(xml_writer, env); + xml_writer = NULL; + return AXIS2_FAILURE; + } + + is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + + /* Set SOAP version */ + axiom_output_set_soap11(request_om_output, env, is_soap_11); + + /* Content-Type */ + if(AXIS2_TRUE == is_soap_11) + { + /* SOAP1.1 */ + content_type = axutil_string_create(env, AXIS2_AMQP_HEADER_ACCEPT_TEXT_XML); + } + else + { + /* SOAP1.2 */ + content_type = axutil_string_create(env, AXIS2_AMQP_HEADER_ACCEPT_APPL_SOAP); + } + + /* SOAP action */ + soap_action = axutil_string_get_buffer(axis2_msg_ctx_get_soap_action(msg_ctx, env), env); + + if(!soap_action) + soap_action = ""; + + /* Handle MTOM */ + do_mtom = axis2_msg_ctx_get_doing_mtom(msg_ctx, env); + + axiom_output_set_do_optimize(request_om_output, env, do_mtom); + axiom_soap_envelope_serialize(request_soap_envelope, env, request_om_output, AXIS2_FALSE); + + if(do_mtom) + { + axis2_status_t mtom_status = AXIS2_FAILURE; + axutil_array_list_t* mime_parts = NULL; + + mtom_status = axiom_output_flush(request_om_output, env); + + if(mtom_status == AXIS2_SUCCESS) + { + mime_parts = axiom_output_get_mime_parts(request_om_output, env); + if(!mime_parts) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Unable to create the mime part list from request_om_output"); + + return AXIS2_FAILURE; + } + else + { + axis2_msg_ctx_set_mime_parts(msg_ctx, env, mime_parts); + } + } + + content_type = axutil_string_create(env, axiom_output_get_content_type(request_om_output, + env)); + } + + request_content = (axis2_char_t*)axiom_xml_writer_get_xml(xml_writer, env); + if(!request_content) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to Serialize the SOAP Envelope"); + return AXIS2_FAILURE; + } + + is_server = axis2_amqp_util_msg_ctx_get_server_side(msg_ctx, env); + + if(is_server) + { + status = axis2_qpid_send(request_content, env, axutil_string_get_buffer(content_type, env), + soap_action, msg_ctx); + } + else + { + if(AXIS2_TRUE == axis2_amqp_util_msg_ctx_get_use_separate_listener(msg_ctx, env)) /* Dual Channel */ + { + status = axis2_qpid_send(request_content, env, axutil_string_get_buffer(content_type, + env), soap_action, msg_ctx); + } + else + { + axis2_op_t* op = NULL; + const axis2_char_t* mep = NULL; + + op = axis2_msg_ctx_get_op(msg_ctx, env); + + if(op) + { + mep = axis2_op_get_msg_exchange_pattern(op, env); + } + + axis2_amqp_response_t* response = NULL; + response = axis2_qpid_send_receive(request_content, env, axutil_string_get_buffer( + content_type, env), soap_action, msg_ctx); + + if(response) + { + /* Create in stream */ + if(response->data) + { + axutil_stream_t* in_stream = NULL; + axutil_property_t* property = NULL; + + in_stream = axutil_stream_create_basic(env); + axutil_stream_write(in_stream, env, response->data, response->length); + + property = axutil_property_create(env); + axutil_property_set_scope(property, env, AXIS2_SCOPE_REQUEST); + axutil_property_set_free_func(property, env, axutil_stream_free_void_arg); + axutil_property_set_value(property, env, in_stream); + + axis2_msg_ctx_set_property(msg_ctx, env, AXIS2_TRANSPORT_IN, property); + } + + if(mep) + { + if(0 == axutil_strcmp(mep, AXIS2_MEP_URI_OUT_IN)) /* Out-In */ + { + axiom_soap_envelope_t* response_soap_envelope = NULL; + + response_soap_envelope = axis2_amqp_util_get_soap_envelope(response, env, + msg_ctx); + if(response_soap_envelope) + { + axis2_msg_ctx_set_response_soap_envelope(msg_ctx, env, + response_soap_envelope); + } + } + } + + status = AXIS2_SUCCESS; + + axis2_msg_ctx_set_status_code(msg_ctx, env, status); + + axis2_amqp_response_free(response, env); + } + else + { + if(mep) + { + if(axutil_strcmp(mep, AXIS2_MEP_URI_OUT_ONLY) == 0 || axutil_strcmp(mep, + AXIS2_MEP_URI_ROBUST_OUT_ONLY) == 0) /* One-way */ + { + status = AXIS2_SUCCESS; + + /* Set status code in msg_ctx */ + axis2_msg_ctx_set_status_code(msg_ctx, env, status); + } + } + } + } + } + + if(content_type) + axutil_string_free(content_type, env); + + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_clean_up( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx) +{ + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_sender_free( + axis2_transport_sender_t* sender, + const axutil_env_t* env) +{ + AXIS2_ENV_CHECK(env, void); + + axis2_amqp_sender_resource_pack_t* sender_resource_pack = NULL; + sender_resource_pack = AXIS2_AMQP_SENDER_TO_RESOURCE_PACK(sender); + + AXIS2_FREE(env->allocator, sender_resource_pack); +} + +/* Library Exports */ + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_get_instance( +#else + axis2_amqp_sender_get_instance( +#endif + struct axis2_transport_sender** inst, + const axutil_env_t* env) +{ + int status = AXIS2_SUCCESS; + + *inst = axis2_amqp_sender_create(env); + if(!(*inst)) + { + status = AXIS2_FAILURE; + } + + return status; +} + +AXIS2_EXPORT int +#ifndef AXIS2_STATIC_DEPLOY +axis2_remove_instance( +#else + axis2_amqp_sender_remove_instance( +#endif + axis2_transport_sender_t* inst, + const axutil_env_t* env) +{ + if(inst) + { + axis2_transport_sender_free(inst, env); + } + + return AXIS2_SUCCESS; +} + diff --git a/src/core/transport/amqp/sender/axis2_amqp_sender.h b/src/core/transport/amqp/sender/axis2_amqp_sender.h new file mode 100644 index 0000000..b523347 --- /dev/null +++ b/src/core/transport/amqp/sender/axis2_amqp_sender.h @@ -0,0 +1,63 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_AMQP_SENDER_H +#define AXIS2_AMQP_SENDER_H + +#include +#include +#include +#include + +typedef struct axis2_amqp_sender_resource_pack +{ + axis2_transport_sender_t sender; + axis2_conf_ctx_t* conf_ctx; +} +axis2_amqp_sender_resource_pack_t; + +#define AXIS2_AMQP_SENDER_TO_RESOURCE_PACK(amqp_sender) \ + ((axis2_amqp_sender_resource_pack_t*)(amqp_sender)) + +AXIS2_EXTERN axis2_transport_sender_t* AXIS2_CALL +axis2_amqp_sender_create(const axutil_env_t* env); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_init( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_conf_ctx_t* conf_ctx, + axis2_transport_out_desc_t* out_desc); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_invoke( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_amqp_sender_clean_up( + axis2_transport_sender_t* sender, + const axutil_env_t* env, + axis2_msg_ctx_t* msg_ctx); + +AXIS2_EXTERN void AXIS2_CALL +axis2_amqp_sender_free( + axis2_transport_sender_t* sender, + const axutil_env_t* env); + +#endif diff --git a/src/core/transport/amqp/sender/qpid_sender/Makefile.am b/src/core/transport/amqp/sender/qpid_sender/Makefile.am new file mode 100644 index 0000000..46dcb5e --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/Makefile.am @@ -0,0 +1,23 @@ +lib_LTLIBRARIES = libaxis2_qpid_sender.la + +libaxis2_qpid_sender_la_SOURCES = axis2_qpid_sender.cpp \ + axis2_qpid_sender_interface.cpp + +libaxis2_qpid_sender_la_LIBADD = $(top_builddir)/util/src/libaxutil.la \ + $(top_builddir)/src/core/transport/amqp/util/libaxis2_amqp_util.la \ + $(QPID_HOME)/lib/libqpidclient.la + +libaxis2_qpid_sender_la_LDFLAGS = g++ -version-info $(VERSION_NO) + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/transport/amqp/sender/qpid_sender \ + -I$(top_builddir)/src/core/transport/amqp/util \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/context \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/util/include \ + -I$(top_builddir)/axiom/include \ + -I$(QPID_HOME)/include + diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp new file mode 100644 index 0000000..7f0799b --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.cpp @@ -0,0 +1,242 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * tcp://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace qpid::client; +using namespace qpid::framing; + +Axis2QpidSender::Axis2QpidSender( + string qpidBrokerIP, + int qpidBrokerPort, + const axutil_env_t* env) +{ + this->qpidBrokerIP = qpidBrokerIP; + this->qpidBrokerPort = qpidBrokerPort; + this->env = env; + this->responseContent = ""; + this->responseContentType = ""; +} + +Axis2QpidSender::~Axis2QpidSender( + void) +{ +} + +bool +Axis2QpidSender::SendReceive( + string messageContent, + string toQueueName, + bool isSOAP11, + string contentType, + string soapAction, + axutil_array_list_t* mime_parts, + int timeout) +{ + bool status = false; + this->responseContent = ""; + this->responseContentType = ""; + + try + { + Connection connection; + connection.open(qpidBrokerIP, qpidBrokerPort); + + Session session = connection.newSession(); + + /* Declare Private Queue */ + string replyToQueueName = AXIS2_AMQP_TEMP_QUEUE_NAME_PREFIX; + replyToQueueName.append(axutil_uuid_gen(env)); + + session.queueDeclare(arg::queue = replyToQueueName, arg::autoDelete = true); + session.exchangeBind(arg::exchange = AXIS2_AMQP_EXCHANGE_DIRECT, arg::queue + = replyToQueueName, arg::bindingKey = replyToQueueName); + + /* Create Message */ + Message reqMessage; + + reqMessage.getDeliveryProperties().setRoutingKey(toQueueName); + reqMessage.getMessageProperties().setReplyTo(ReplyTo(AXIS2_AMQP_EXCHANGE_DIRECT, + replyToQueueName)); + + reqMessage.getHeaders().setString(AXIS2_AMQP_HEADER_CONTENT_TYPE, contentType); + reqMessage.getHeaders().setString(AXIS2_AMQP_HEADER_SOAP_ACTION, soapAction); + + if(mime_parts) + { + string mimeBody; + GetMimeBody(mime_parts, mimeBody); + + messageContent.clear();/* MIME parts include SOAP envelop */ + + messageContent.append(mimeBody); + } + + reqMessage.setData(messageContent); + + session.messageTransfer(arg::content = reqMessage, arg::destination + = AXIS2_AMQP_EXCHANGE_DIRECT); + + /* Create subscription manager */ + SubscriptionManager subscriptionManager(session); + + Message resMessage; + qpid::sys::Duration reqTimeout(timeout * AXIS2_AMQP_NANOSEC_PER_MILLISEC); + + if(subscriptionManager.get(resMessage, replyToQueueName, reqTimeout)) + { + responseContent = resMessage.getData(); + responseContentType = resMessage.getHeaders().getAsString( + AXIS2_AMQP_HEADER_CONTENT_TYPE); + + status = true; + } + + connection.close(); + } + catch(const std::exception& e) + { + } + + return status; +} + +bool +Axis2QpidSender::Send( + string messageContent, + string toQueueName, + string replyToQueueName, + bool isSOAP11, + string contentType, + string soapAction, + axutil_array_list_t* mime_parts) +{ + bool status = false; + + try + { + Connection connection; + connection.open(qpidBrokerIP, qpidBrokerPort); + + Session session = connection.newSession(); + + /* Create Message */ + Message message; + + message.getDeliveryProperties().setRoutingKey(toQueueName); + + if(!replyToQueueName.empty()) /* Client dual-channel */ + { + message.getMessageProperties().setReplyTo(ReplyTo(AXIS2_AMQP_EXCHANGE_DIRECT, + replyToQueueName)); + + session.queueDeclare(arg::queue = replyToQueueName); + session.exchangeBind(arg::exchange = AXIS2_AMQP_EXCHANGE_DIRECT, arg::queue + = replyToQueueName, arg::bindingKey = replyToQueueName); + } + + message.getHeaders().setString(AXIS2_AMQP_HEADER_CONTENT_TYPE, contentType); + message.getHeaders().setString(AXIS2_AMQP_HEADER_SOAP_ACTION, soapAction); + + if(mime_parts) + { + string mimeBody; + GetMimeBody(mime_parts, mimeBody); + + messageContent.clear();/* MIME parts include SOAP envelop */ + + messageContent.append(mimeBody); + } + + message.setData(messageContent); + + session.messageTransfer(arg::content = message, arg::destination + = AXIS2_AMQP_EXCHANGE_DIRECT); + + connection.close(); + + status = true; + } + catch(const std::exception& e) + { + } + + return status; +} + +void +Axis2QpidSender::GetMimeBody( + axutil_array_list_t* mime_parts, + string& mimeBody) +{ + int i = 0; + axiom_mime_part_t *mime_part = NULL; + axis2_status_t status = AXIS2_SUCCESS; + + if(!mime_parts) + return; + + for(i = 0; i < axutil_array_list_size(mime_parts, env); i++) + { + mime_part = (axiom_mime_part_t *)axutil_array_list_get(mime_parts, env, i); + + if(mime_part->type == AXIOM_MIME_PART_BUFFER) + { + mimeBody.append(mime_part->part, mime_part->part_size); + } + else if(mime_part->type == AXIOM_MIME_PART_FILE) + { + int length; + char* buffer; + + ifstream file; + file.open(mime_part->file_name, ios::binary); + + file.seekg(0, ios::end); + length = file.tellg(); + file.seekg(0, ios::beg); + + buffer = new char[length]; + + file.read(buffer, length); + file.close(); + + mimeBody.append(buffer, length); + + delete[] buffer; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unknown mime type"); + return; + } + + if(status == AXIS2_FAILURE) + { + break; + } + } +} diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h new file mode 100644 index 0000000..8c94cfa --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender.h @@ -0,0 +1,49 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * tcp://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_QPID_SENDER_H +#define AXIS2_QPID_SENDER_H + +#include +#include +#include + +using std::string; + +class Axis2QpidSender +{ + public: + Axis2QpidSender(string qpidBrokerIP, int qpidBrokerPort, const axutil_env_t* env); + ~Axis2QpidSender(void); + + bool SendReceive(string messageContent, string toQueueName, bool isSOAP11, + string contentType, string soapAction, axutil_array_list_t* mime_parts, int timeout); + bool Send(string messageContent, string toQueueName, string replyToQueueName, bool isSOAP11, + string contentType, string soapAction, axutil_array_list_t* mime_parts); + + string responseContent; + string responseContentType; + + private: + void GetMimeBody(axutil_array_list_t* mime_parts, string& mimeBody); + + string qpidBrokerIP; + int qpidBrokerPort; + const axutil_env_t* env; +}; + +#endif diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp new file mode 100644 index 0000000..ac4f51e --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.cpp @@ -0,0 +1,130 @@ +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +AXIS2_EXTERN axis2_amqp_response_t* AXIS2_CALL +axis2_qpid_send_receive( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx) +{ + axis2_amqp_destination_info_t* destination_info = NULL; + destination_info = axis2_amqp_util_msg_ctx_get_destination_info(msg_ctx, env); + + if (!destination_info || !destination_info->broker_ip || + !destination_info->broker_port || !destination_info->queue_name) + { + return NULL; + } + + axis2_bool_t is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + axutil_array_list_t* mime_parts = axis2_msg_ctx_get_mime_parts(msg_ctx, env); + int timeout = axis2_amqp_util_msg_ctx_get_request_timeout(msg_ctx, env); + + /* Get Response */ + Axis2QpidSender qpid_sender(destination_info->broker_ip, + destination_info->broker_port, env); + + bool status = qpid_sender.SendReceive(request_content, destination_info->queue_name, + is_soap_11, content_type, soap_action, mime_parts, timeout); + + axis2_amqp_destination_info_free(destination_info, env); + + if (!status) + { + return NULL; + } + + /* Create response */ + axis2_amqp_response_t* response = (axis2_amqp_response_t*)AXIS2_MALLOC( + env->allocator, sizeof(axis2_amqp_response_t)); + + /* Data */ + response->data = AXIS2_MALLOC(env->allocator, qpid_sender.responseContent.size()); + memcpy(response->data, qpid_sender.responseContent.c_str(), + qpid_sender.responseContent.size()); + + /* Length */ + response->length = qpid_sender.responseContent.size(); + + /* ContentType */ + response->content_type = (axis2_char_t*)AXIS2_MALLOC( + env->allocator, qpid_sender.responseContentType.size() + 1); + strcpy(response->content_type, qpid_sender.responseContentType.c_str()); + + return response; +} + + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_qpid_send( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx) +{ + axis2_amqp_destination_info_t* destination_info = NULL; + axis2_status_t status = AXIS2_FAILURE; + string reply_to_queue_name = ""; + + destination_info = axis2_amqp_util_msg_ctx_get_destination_info(msg_ctx, env); + + if (!destination_info || !destination_info->broker_ip || + !destination_info->broker_port || !destination_info->queue_name) + { + return AXIS2_FAILURE; + } + + axis2_bool_t is_soap_11 = axis2_msg_ctx_get_is_soap_11(msg_ctx, env); + axutil_array_list_t* mime_parts = axis2_msg_ctx_get_mime_parts(msg_ctx, env); + + /* If client side, find reply_to_queue_name */ + if (!axis2_msg_ctx_get_server_side(msg_ctx, env)) + { + axis2_conf_ctx_t* conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env); + + axis2_char_t* queue_name = + axis2_amqp_util_conf_ctx_get_dual_channel_queue_name(conf_ctx, env); + if (queue_name) + reply_to_queue_name = queue_name; + } + + Axis2QpidSender qpid_sender(destination_info->broker_ip, + destination_info->broker_port, env); + + status = qpid_sender.Send(request_content, destination_info->queue_name, + reply_to_queue_name, is_soap_11, content_type, soap_action, mime_parts); + + axis2_amqp_destination_info_free(destination_info, env); + + return status; +} + +#ifdef __cplusplus +} +#endif diff --git a/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h new file mode 100644 index 0000000..94e232f --- /dev/null +++ b/src/core/transport/amqp/sender/qpid_sender/axis2_qpid_sender_interface.h @@ -0,0 +1,50 @@ +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef AXIS2_QPID_SENDER_INTERFACE_H +#define AXIS2_QPID_SENDER_INTERFACE_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +AXIS2_EXTERN axis2_amqp_response_t* AXIS2_CALL +axis2_qpid_send_receive( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx); + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_qpid_send( + const axis2_char_t* request_content, + const axutil_env_t* env, + const axis2_char_t* content_type, + const axis2_char_t* soap_action, + axis2_msg_ctx_t* msg_ctx); + +#ifdef __cplusplus +} +#endif + +#endif -- cgit v1.1-32-gdbae