You are viewing a plain text version of this content. The canonical link for it is here.
Posted to sandesha-dev@ws.apache.org by sa...@apache.org on 2006/07/10 23:00:18 UTC
svn commit: r420631 [3/3] - in /webservices/sandesha/trunk/c: ./
include/sandesha2/ src/ src/msgprocessors/ src/storage/beans/
src/transport/ src/util/ src/workers/
Added: webservices/sandesha/trunk/c/src/transport/sandesha2_transport_sender.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/transport/sandesha2_transport_sender.c?rev=420631&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/transport/sandesha2_transport_sender.c (added)
+++ webservices/sandesha/trunk/c/src/transport/sandesha2_transport_sender.c Mon Jul 10 14:00:16 2006
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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 <sandesha2/sandesha2_transport_sender.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <sandesha2/sandesha2_storage_manager.h>
+#include <sandesha2/sandesha2_utils.h>
+#include <axis2_conf.h>
+#include <axis2_string.h>
+
+
+/**
+ * @brief Transport Sender struct impl
+ * Sandesha2 Transport Sender
+ */
+typedef struct sandesha2_transport_sender_impl sandesha2_transport_sender_impl_t;
+
+struct sandesha2_transport_sender_impl
+{
+ axis2_transport_sender_t transport_sender;
+};
+
+#define SANDESHA2_INTF_TO_IMPL(transport_sender) \
+ ((sandesha2_transport_sender_impl_t *)(transport_sender))
+
+/***************************** Function headers *******************************/
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_init
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ axis2_transport_out_desc_t *transport_out);
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_cleanup
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env,
+ axis2_msg_ctx_t *msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_invoke
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env,
+ axis2_msg_ctx_t *msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_free(axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env);
+
+/***************************** End of function headers ************************/
+
+AXIS2_EXTERN axis2_transport_sender_t* AXIS2_CALL
+sandesha2_transport_sender_create(const axis2_env_t *env)
+{
+ sandesha2_transport_sender_impl_t *transport_sender_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ transport_sender_impl = (sandesha2_transport_sender_impl_t *)
+ AXIS2_MALLOC (env->allocator,
+ sizeof(sandesha2_transport_sender_impl_t));
+
+ if(NULL == transport_sender_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ transport_sender_impl->transport_sender.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(axis2_transport_sender_ops_t));
+ if(NULL == transport_sender_impl->transport_sender.ops)
+ {
+ sandesha2_transport_sender_free((axis2_transport_sender_t*)
+ transport_sender_impl, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ transport_sender_impl->transport_sender.ops->init =
+ sandesha2_transport_sender_init;
+ transport_sender_impl->transport_sender.ops->cleanup =
+ sandesha2_transport_sender_cleanup;
+ transport_sender_impl->transport_sender.ops->invoke =
+ sandesha2_transport_sender_invoke;
+ transport_sender_impl->transport_sender.ops->free =
+ sandesha2_transport_sender_free;
+
+ return &(transport_sender_impl->transport_sender);
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_free(axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ if(NULL != transport_sender->ops)
+ {
+ AXIS2_FREE(env->allocator, transport_sender->ops);
+ transport_sender->ops = NULL;
+ }
+ AXIS2_FREE(env->allocator, SANDESHA2_INTF_TO_IMPL(transport_sender));
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_init
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ axis2_transport_out_desc_t *transport_out)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, transport_out, AXIS2_FAILURE);
+
+ /* we have nothing to do here */
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_cleanup
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env,
+ axis2_msg_ctx_t *msg_ctx)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+
+ /* we have nothing to do here */
+ return AXIS2_SUCCESS;
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_transport_sender_invoke
+ (axis2_transport_sender_t *transport_sender,
+ const axis2_env_t *env,
+ axis2_msg_ctx_t *msg_ctx)
+{
+ axis2_property_t *property = NULL;
+ axis2_transport_out_desc_t *out_desc = NULL;
+ axis2_char_t *key = NULL;
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ axis2_conf_t *conf = NULL;
+ sandesha2_storage_manager_t *storage_man = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, AXIS2_FALSE);
+
+ if(NULL == property || NULL == AXIS2_PROPERTY_GET_VALUE(property, env))
+ return AXIS2_FAILURE;
+ out_desc = AXIS2_PROPERTY_GET_VALUE(property, env);
+ AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(msg_ctx, env, out_desc);
+
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ SANDESHA2_MESSAGE_STORE_KEY, AXIS2_FALSE);
+
+ if(NULL == property || NULL == AXIS2_PROPERTY_GET_VALUE(property, env))
+ return AXIS2_FAILURE;
+
+ key = AXIS2_PROPERTY_GET_VALUE(property, env);
+ conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
+ conf = AXIS2_CONF_CTX_GET_CONF(conf_ctx, env);
+ storage_man = sandesha2_utils_get_storage_manager(env, conf_ctx, conf);
+
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(SANDESHA2_VALUE_TRUE,
+ env));
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, SANDESHA2_QUALIFIED_FOR_SENDING,
+ property, AXIS2_FALSE);
+ SANDESHA2_STORAGE_MANAGER_UPDATE_MSG_CTX(storage_man, env, key, msg_ctx);
+ return AXIS2_SUCCESS;
+}
Modified: webservices/sandesha/trunk/c/src/util/spec_specific_consts.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/spec_specific_consts.c?rev=420631&r1=420630&r2=420631&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/spec_specific_consts.c (original)
+++ webservices/sandesha/trunk/c/src/util/spec_specific_consts.c Mon Jul 10 14:00:16 2006
@@ -41,6 +41,23 @@
return NULL
}
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+sandesha2_spec_specific_consts_get_rm_ns_val(const axis2_env_t *env,
+ axis2_char_t *spec_ver)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, spec_ver, NULL);
+ if(0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_0, spec_ver))
+ {
+ return SANDESHA2_SPEC_2005_02_NS_URI;
+ }
+ if(0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_1, spec_ver))
+ {
+ return SANDESHA2_SPEC_2005_10_NS_URI;
+ }
+ return NULL;
+}
+
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
sandesha2_spec_specific_consts_is_ack_final_allowed(const axis2_env_t *env,
axis2_char_t *rm_spec_ver)
@@ -87,5 +104,6 @@
}
return AXIS2_FALSE;
}
+
Modified: webservices/sandesha/trunk/c/src/util/utils.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/utils.c?rev=420631&r1=420630&r2=420631&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/utils.c (original)
+++ webservices/sandesha/trunk/c/src/util/utils.c Mon Jul 10 14:00:16 2006
@@ -15,43 +15,316 @@
*/
#include <sandesha2/sandesha2_utils.h>
-
+#include <axis2_param.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <sandesha2/sandesha2_in_order_invoker.h>
+#include <sandesha2/sandesha2_transport_sender.h>
+#include <sandesha2/sandesha2_seq_property_bean_manager.h>
+#include <sandesha2/sandesha2_error.h>
+#include <axis2_string.h>
+#include <axis2_conf.h>
+#include <axis2_property.h>
+#include <axiom_soap_body.h>
AXIS2_EXTERN axis2_status_t AXIS2_CALL
sandesha2_utils_remove_soap_body_part(const axis2_env_t *env,
- axis2_soap_envelope_t *envelope, axis2_qname_t *qname)
+ axiom_soap_envelope_t *envelope, axis2_qname_t *qname)
{
- axis2_soap_body_t *soap_body = NULL;
- axis2_om_node_t *body_node = NULL;
- axis2_om_element_t *body_element = NULL;
- axis2_om_element_t *body_element = NULL;
+ axiom_soap_body_t *soap_body = NULL;
+ axiom_node_t *body_node = NULL;
+ axiom_node_t *body_rm_node = NULL;
+ axiom_element_t *body_element = NULL;
+ axiom_element_t *body_rm_element = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, envelope, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, qname, AXIS2_FAILURE);
- soap_body = AXIS2_SOAP_ENVELOPE_GET_BODY(envelope, env);
+ soap_body = AXIOM_SOAP_ENVELOPE_GET_BODY(envelope, env);
if(NULL == soap_body)
{
return AXIS2_FAILURE;
}
- body_node = AXIS2_SOAP_BODY_GET_BASE_NODE(soap_body, env);
+ body_node = AXIOM_SOAP_BODY_GET_BASE_NODE(soap_body, env);
if(NULL == body_node)
{
return AXIS2_FAILURE;
}
- body_element = AXIS2_OM_NODE_GET_DATA_ELEMENT(body_node, env);
+ body_element = AXIOM_NODE_GET_DATA_ELEMENT(body_node, env);
if(NULL == body_element)
{
return AXIS2_FAILURE;
}
- body_rm_element = AXIS2_OM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(body_element,
+ body_rm_element = AXIOM_ELEMENT_GET_FIRST_CHILD_WITH_QNAME(body_element,
env, qname, body_node, &body_rm_node);
if(NULL != body_rm_element)
{
- AXIS2_OM_NODE_DETACH(body_rm_node, env);
+ AXIOM_NODE_DETACH(body_rm_node, env);
+ }
+ return AXIS2_SUCCESS;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+sandesha2_utils_get_rm_version(const axis2_env_t *env,
+ axis2_char_t *key,
+ sandesha2_storage_manager_t *storage_man)
+{
+ sandesha2_seq_property_bean_manager_t *seq_prop_man = NULL;
+ sandesha2_seq_property_bean_t *rm_version_bean = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, key, NULL);
+ AXIS2_PARAM_CHECK(env->error, storage_man, NULL);
+
+ seq_prop_man = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ storage_man, env);
+ rm_version_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_man,
+ env, key, SANDESHA2_SEQ_PROP_RM_SPEC_VERSION);
+ if(NULL == rm_version_bean)
+ return NULL;
+ return SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(rm_version_bean, env);
+}
+
+AXIS2_EXTERN sandesha2_storage_manager_t* AXIS2_CALL
+sandesha2_utils_get_storage_manager(const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ axis2_conf_t *conf)
+{
+ axis2_param_t *parameter = NULL;
+ axis2_char_t *value = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL);
+ AXIS2_PARAM_CHECK(env->error, conf, NULL);
+
+ parameter = AXIS2_CONF_GET_PARAM(conf, env,
+ SANDESHA2_STORAGE_MANAGER_PARAMETER);
+ if(NULL == parameter)
+ parameter = axis2_param_create(env, SANDESHA2_STORAGE_MANAGER_PARAMETER,
+ SANDESHA2_DEFAULT_STORAGE_MANAGER);
+ value = AXIS2_PARAM_GET_VALUE(parameter, env);
+ if(0 == AXIS2_STRCMP(value, SANDESHA2_INMEMORY_STORAGE_MANAGER))
+ return sandesha2_utils_get_inmemory_storage_manager(env, conf_ctx);
+ else if (0 == AXIS2_STRCMP(value, SANDESHA2_PERMANENT_STORAGE_MANAGER))
+ return sandesha2_utils_get_permanent_storage_manager(env, conf_ctx);
+ else
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_STORAGE_MANAGER,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+sandesha2_utils_get_seq_property(const axis2_env_t *env,
+ axis2_char_t *id,
+ axis2_char_t *name,
+ sandesha2_storage_manager_t *storage_man)
+{
+ sandesha2_seq_property_bean_manager_t *seq_prop_man = NULL;
+ sandesha2_seq_property_bean_t *seq_prop_bean = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, id, NULL);
+ AXIS2_PARAM_CHECK(env->error, name, NULL);
+ AXIS2_PARAM_CHECK(env->error, storage_man, NULL);
+
+ seq_prop_man = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ storage_man, env);
+ seq_prop_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_man,
+ env, id, name);
+ if(NULL == seq_prop_bean)
+ return NULL;
+ return SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(seq_prop_bean, env);
+ return NULL;
+}
+
+AXIS2_EXTERN sandesha2_property_bean_t* AXIS2_CALL
+sandesha2_utils_get_property_bean(const axis2_env_t *env,
+ axis2_conf_t *conf)
+{
+ axis2_param_t *param = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, conf, NULL);
+
+ param = AXIS2_CONF_GET_PARAM(conf, env, SANDESHA2_SANDESHA_PROPERTY_BEAN);
+ if(NULL == param)
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONFIGURATION_NOT_SET,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+ return (sandesha2_property_bean_t*)AXIS2_PARAM_GET_VALUE(param, env);
+
+}
+
+AXIS2_EXTERN axis2_array_list_t* AXIS2_CALL
+sandesha2_utils_get_array_list_from_string(const axis2_env_t *env,
+ axis2_char_t *string)
+{
+ axis2_char_t *dup_string = NULL;
+ axis2_char_t *temp_str = NULL;
+ axis2_bool_t added = AXIS2_FALSE;
+ axis2_array_list_t *ret = axis2_array_list_create(env,
+ AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, string, NULL);
+
+ dup_string = AXIS2_STRDUP(string, env);
+ temp_str = strtok(dup_string, ",");
+ while(NULL != temp_str)
+ {
+ axis2_char_t *temp_element = AXIS2_STRDUP(temp_str, env);
+ added = AXIS2_TRUE;
+ AXIS2_ARRAY_LIST_ADD(ret, env, temp_element);
+ }
+ AXIS2_FREE(env->allocator, dup_string);
+ if(AXIS2_FALSE == added)
+ {
+ AXIS2_ARRAY_LIST_FREE(ret, env);
+ return NULL;
+ }
+ return ret;
+}
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+sandesha2_utils_array_list_contains(const axis2_env_t *env,
+ axis2_array_list_t *list,
+ axis2_char_t *string)
+{
+ int i = 0;
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, list, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, string, AXIS2_FALSE);
+
+ for(i = 0; i < AXIS2_ARRAY_LIST_SIZE(list, env); i++)
+ {
+ axis2_char_t *element = AXIS2_ARRAY_LIST_GET(list, env, i);
+ if(NULL != element && 0 == AXIS2_STRCMP(element, string))
+ return AXIS2_TRUE;
+ }
+ return AXIS2_FAILURE;
+}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+sandesha2_utils_array_list_to_string(const axis2_env_t *env,
+ axis2_array_list_t *list)
+{
+ axis2_char_t *list_string = NULL;
+ int i = 0;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, list, NULL);
+
+ list_string = AXIS2_STRDUP("[", env);
+ for(i = 0; i < AXIS2_ARRY_LIST_SIZE(list, env); i++)
+ {
+ axis2_char_t *element = AXIS2_ARRAY_LIST_GET(list, env, i);
+ list_string = axis2_strcat(env, list_string, ",", element, NULL);
+ }
+ list_string = axis2_strcat(env, list_string, "]", NULL);
+
+ return list_string;
+}
+
+AXIS2_EXTERN axis2_status_t AXIS2_CALL
+sandesha2_utils_start_invoker_for_seq(const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ axis2_char_t *seq_id)
+{
+ sandesha2_in_order_invoker_t *invoker = NULL;
+ axis2_property_t *property = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
+
+ property = AXIS2_CTX_GET_PROPERTY(AXIS2_CONF_CTX_GET_BASE(conf_ctx, env),
+ env, SANDESHA2_INVOKER, AXIS2_FALSE);
+ if(NULL == property)
+ return AXIS2_FAILURE;
+ invoker = AXIS2_PROPERTY_GET_VALUE(property, env);
+ if(NULL == invoker)
+ {
+ invoker = sandesha2_in_order_invoker_create(env);
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, invoker);
+ AXIS2_CTX_SET_PROPERTY(AXIS2_CONF_CTX_GET_BASE(conf_ctx, env),
+ env, SANDESHA2_INVOKER, property, AXIS2_FALSE);
}
+ SANDESHA2_IN_ORDER_INVOKER_RUN_FOR_SEQ(invoker, env, conf_ctx, seq_id);
return AXIS2_SUCCESS;
}
+
+AXIS2_EXTERN axis2_char_t* AXIS2_CALL
+sandesha2_utils_get_outgoing_internal_seq_id(const axis2_env_t *env,
+ axis2_char_t *seq_id)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, seq_id, NULL);
+
+ return axis2_strcat(env, SANDESHA2_INTERNAL_SEQUENCE_PREFIX, ":",
+ seq_id, NULL);
+}
+AXIS2_EXTERN axis2_transport_out_desc_t* AXIS2_CALL
+sandesha2_utils_get_transport_out(const axis2_env_t *env)
+{
+ axis2_transport_out_desc_t *out_desc = NULL;
+ axis2_transport_sender_t *transport_sender = NULL;
+ axis2_qname_t *qname = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ transport_sender = sandesha2_transport_sender_create(env);
+ qname = axis2_qname_create(env, "Sandesha2TransportOutDesc", NULL, NULL);
+ out_desc = axis2_transport_out_desc_create_with_qname(env, qname);
+ AXIS2_TRANSPORT_OUT_DESC_SET_SENDER(out_desc, env, transport_sender);
+ return out_desc;
+}
+AXIS2_EXTERN sandesha2_storage_manager_t* AXIS2_CALL
+sandesha2_utils_get_inmemory_storage_manager(const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx)
+{
+ axis2_property_t *property = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL);
+
+ property = AXIS2_CTX_GET_PROPERTY(AXIS2_CONF_CTX_GET_BASE(conf_ctx, env),
+ env, SANDESHA2_INMEMORY_STORAGE_MANAGER, AXIS2_FALSE);
+
+ if(NULL != property && NULL != AXIS2_PROPERTY_GET_VALUE(property, env))
+ return (sandesha2_storage_manager_t*)AXIS2_PROPERTY_GET_VALUE(property,
+ env);
+ else
+ {
+ /* TODO we need to class load the proper storage manager */
+ sandesha2_storage_manager_t *storage_man =
+ sandesha2_storage_manager_create(env, conf_ctx);
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, storage_man);
+ AXIS2_CTX_SET_PROPERTY(AXIS2_CONF_CTX_GET_BASE(conf_ctx, env),
+ env, SANDESHA2_INMEMORY_STORAGE_MANAGER, property,
+ AXIS2_FALSE);
+ return storage_man;
+ }
+ return NULL;
+}
+
+AXIS2_EXTERN sandesha2_storage_manager_t* AXIS2_CALL
+sandesha2_utils_get_permanent_storage_manager(const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, NULL);
+
+ /*TODO implement when the persistent storage is avalable */
+ return NULL;
+}
Added: webservices/sandesha/trunk/c/src/workers/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/workers/Makefile.am?rev=420631&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/workers/Makefile.am (added)
+++ webservices/sandesha/trunk/c/src/workers/Makefile.am Mon Jul 10 14:00:16 2006
@@ -0,0 +1,7 @@
+noinst_LTLIBRARIES = libsandesha2_workers.la
+
+libsandesha2_workers_la_SOURCES = in_order_invoker.c
+
+INCLUDES = -I$(top_builddir)/include \
+ @AXIS2INC@
+
Added: webservices/sandesha/trunk/c/src/workers/in_order_invoker.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/workers/in_order_invoker.c?rev=420631&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/workers/in_order_invoker.c (added)
+++ webservices/sandesha/trunk/c/src/workers/in_order_invoker.c Mon Jul 10 14:00:16 2006
@@ -0,0 +1,484 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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 <sandesha2/sandesha2_in_order_invoker.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <sandesha2/sandesha2_utils.h>
+#include <sandesha2/sandesha2_transaction.h>
+#include <sandesha2/sandesha2_storage_manager.h>
+#include <sandesha2/sandesha2_seq_property_bean.h>
+#include <sandesha2/sandesha2_msg_ctx.h>
+#include <sandesha2/sandesha2_sequence.h>
+#include <axis2_addr.h>
+#include <axis2_engine.h>
+#include <stdio.h>
+
+
+/**
+ * @brief In Order Invoker struct impl
+ * Sandesha2 In Order Invoker
+ */
+typedef struct sandesha2_in_order_invoker_impl sandesha2_in_order_invoker_impl_t;
+typedef struct sandesha2_in_order_invoker_args sandesha2_in_order_invoker_args_t;
+
+struct sandesha2_in_order_invoker_impl
+{
+ sandesha2_in_order_invoker_t invoker;
+ axis2_conf_ctx_t *conf_ctx;
+ axis2_bool_t run_invoker;
+ axis2_array_list_t *working_sequences;
+ axis2_thread_mutex_t *mutex;
+};
+
+struct sandesha2_in_order_invoker_args
+{
+ sandesha2_in_order_invoker_impl_t *impl;
+ axis2_env_t *env;
+};
+
+#define SANDESHA2_INTF_TO_IMPL(invoker) \
+ ((sandesha2_in_order_invoker_impl_t *)(invoker))
+
+/***************************** Function headers *******************************/
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_stop_invoker_for_seq
+ (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env, axis2_char_t *seq_id);
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_stop_invoking (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_order_invoker_is_invoker_started
+ (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_run_invoker_for_seq
+ (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env, axis2_conf_ctx_t *conf_ctx,
+ axis2_char_t *seq_id);
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_run (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_make_msg_ready_for_reinjection(
+ sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx);
+
+void * AXIS2_THREAD_FUNC
+sandesha2_in_order_invoker_worker_func(axis2_thread_t *thd, void *data);
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_free(sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env);
+
+/***************************** End of function headers ************************/
+
+AXIS2_EXTERN sandesha2_in_order_invoker_t* AXIS2_CALL
+sandesha2_in_order_invoker_create(const axis2_env_t *env)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ invoker_impl = (sandesha2_in_order_invoker_impl_t *)AXIS2_MALLOC
+ (env->allocator,
+ sizeof(sandesha2_in_order_invoker_impl_t));
+
+ if(NULL == invoker_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ invoker_impl->conf_ctx = NULL;
+ invoker_impl->run_invoker = AXIS2_FALSE;
+ invoker_impl->working_sequences = NULL;
+ invoker_impl->mutex = NULL;
+ invoker_impl->invoker.ops = NULL;
+
+ invoker_impl->invoker.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(sandesha2_in_order_invoker_ops_t));
+ if(NULL == invoker_impl->invoker.ops)
+ {
+ sandesha2_in_order_invoker_free(
+ (sandesha2_in_order_invoker_t*)invoker_impl, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ invoker_impl->working_sequences = axis2_array_list_create(env,
+ AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+ invoker_impl->mutex = axis2_thread_mutex_create(env->allocator,
+ AXIS2_THREAD_MUTEX_DEFAULT);
+
+ invoker_impl->invoker.ops->stop_invoker_for_seq =
+ sandesha2_in_order_invoker_stop_invoker_for_seq;
+ invoker_impl->invoker.ops->stop_invoking =
+ sandesha2_in_order_invoker_stop_invoking;
+ invoker_impl->invoker.ops->is_invoker_started =
+ sandesha2_in_order_invoker_is_invoker_started;
+ invoker_impl->invoker.ops->run_invoker_for_seq =
+ sandesha2_in_order_invoker_run_invoker_for_seq;
+ invoker_impl->invoker.ops->run = sandesha2_in_order_invoker_run;
+ invoker_impl->invoker.ops->free = sandesha2_in_order_invoker_free;
+
+ return &(invoker_impl->invoker);
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_free(sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+ /* Do not free this */
+ invoker_impl->conf_ctx = NULL;
+
+ if(NULL != invoker_impl->mutex)
+ {
+ axis2_thread_mutex_destroy(invoker_impl->mutex);
+ invoker_impl->mutex = NULL;
+ }
+ if(NULL != invoker_impl->working_sequences)
+ {
+ AXIS2_ARRY_LIST_FREE(invoker_impl->working_sequences, env);
+ invoker_impl->working_sequences = NULL;
+ }
+ if(NULL != invoker->ops)
+ {
+ AXIS2_FREE(env->allocator, invoker->ops);
+ invoker->ops = NULL;
+ }
+ AXIS2_FREE(env->allocator, SANDESHA2_INTF_TO_IMPL(invoker));
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_stop_invoker_for_seq
+ (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env, axis2_char_t *seq_id)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
+
+ invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+ axis2_thread_mutex_lock(invoker_impl->mutex);
+ if(0 == AXIS2_ARRY_LIST_SIZE(invoker_impl->working_sequences, env))
+ invoker_impl->run_invoker = AXIS2_FALSE;
+ axis2_thread_mutex_unlock(invoker_impl->mutex);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_stop_invoking (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+ axis2_thread_mutex_lock(invoker_impl->mutex);
+ SANDESHA2_INTF_TO_IMPL(invoker)->run_invoker = AXIS2_FALSE;
+ axis2_thread_mutex_unlock(invoker_impl->mutex);
+ return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_order_invoker_is_invoker_started
+ (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env)
+{
+ axis2_bool_t started = AXIS2_FALSE;
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+ invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+ axis2_thread_mutex_lock(invoker_impl->mutex);
+ started = SANDESHA2_INTF_TO_IMPL(invoker)->run_invoker;
+ axis2_thread_mutex_unlock(invoker_impl->mutex);
+ return started;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_run_invoker_for_seq
+ (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env, axis2_conf_ctx_t *conf_ctx,
+ axis2_char_t *seq_id)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
+
+ invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+ axis2_thread_mutex_lock(invoker_impl->mutex);
+ if(AXIS2_FALSE == sandesha2_utils_array_list_contains(env,
+ invoker_impl->working_sequences, seq_id))
+ AXIS2_ARRY_LIST_ADD(invoker_impl->working_sequences, env, seq_id);
+ if(AXIS2_FALSE == invoker_impl->run_invoker)
+ {
+ invoker_impl->conf_ctx = conf_ctx;
+ invoker_impl->run_invoker = AXIS2_TRUE;
+ sandesha2_in_order_invoker_run(invoker, env);
+ }
+ axis2_thread_mutex_unlock(invoker_impl->mutex);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_run (sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ axis2_thread_t *worker_thread = NULL;
+ sandesha2_in_order_invoker_args_t args;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+ args.impl = invoker_impl;
+ args.env = (axis2_env_t*)env;
+ worker_thread = AXIS2_THREAD_POOL_GET_THREAD(env->thread_pool,
+ sandesha2_in_order_invoker_worker_func, (void*)&args);
+ if(NULL == worker_thread)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Thread creation failed"
+ " sandesha2_in_order_invoker_run");
+ return AXIS2_FAILURE;
+ }
+ AXIS2_THREAD_POOL_THREAD_DETACH(env->thread_pool, worker_thread);
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_order_invoker_make_msg_ready_for_reinjection(
+ sandesha2_in_order_invoker_t *invoker,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
+{
+ axis2_property_t *property = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, AXIS2_WSA_VERSION, property,
+ AXIS2_FALSE);
+ AXIS2_MSG_CTX_SET_MESSAGE_ID(msg_ctx, env, NULL);
+ AXIS2_MSG_CTX_SET_TO(msg_ctx, env, NULL);
+ AXIS2_MSG_CTX_SET_WSA_ACTION(msg_ctx, env, NULL);
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(SANDESHA2_VALUE_TRUE,
+ env));
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, SANDESHA2_REINJECTED_MESSAGE,
+ property, AXIS2_FALSE);
+ return AXIS2_SUCCESS;
+}
+
+/**
+ * Thread worker function.
+ */
+void * AXIS2_THREAD_FUNC
+sandesha2_in_order_invoker_worker_func(axis2_thread_t *thd, void *data)
+{
+ sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ sandesha2_in_order_invoker_t *invoker = NULL;
+ sandesha2_in_order_invoker_args_t *args;
+ axis2_env_t *env = NULL;
+
+ args = (sandesha2_in_order_invoker_args_t*)data;
+ env = args->env;
+ invoker_impl = args->impl;
+ invoker = (sandesha2_in_order_invoker_t*)invoker_impl;
+
+ while(AXIS2_TRUE == invoker_impl->run_invoker)
+ {
+ sandesha2_transaction_t *transaction = NULL;
+ /* Use when transaction handling is done
+ axis2_bool_t rollbacked = AXIS2_FALSE;*/
+ sandesha2_storage_manager_t *storage_manager = NULL;
+ sandesha2_next_msg_bean_manager_t *next_msg_mgr = NULL;
+ sandesha2_invoker_bean_manager_t *storage_map_mgr = NULL;
+ sandesha2_seq_property_bean_manager_t *seq_prop_mgr = NULL;
+ sandesha2_seq_property_bean_t *all_seq_bean = NULL;
+ axis2_array_list_t *all_seq_list = NULL;
+ int i = 0;
+
+ sleep(1);
+ storage_manager = sandesha2_utils_get_storage_manager(env,
+ invoker_impl->conf_ctx,
+ AXIS2_CONF_CTX_GET_CONF(invoker_impl->conf_ctx, env));
+ next_msg_mgr = SANDESHA2_STORAGE_MANAGER_GET_NEXT_MSG_BEAN_MANAGER(
+ storage_manager, env);
+ storage_map_mgr = SANDESHA2_STORAGE_MANAGER_GET_STORAGE_MAP_BEAN_MANAGER
+ (storage_manager, env);
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ storage_manager, env);
+ transaction = SANDESHA2_STORAGE_MANAGER_GET_TRANSACTION(storage_manager,
+ env);
+ all_seq_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr,
+ env, SANDESHA2_SEQ_PROP_ALL_SEQUENCES,
+ SANDESHA2_SEQ_PROP_INCOMING_SEQUENCE_LIST);
+ if(NULL == all_seq_bean)
+ continue;
+ all_seq_list = sandesha2_utils_get_array_list_from_string(env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(all_seq_bean, env));
+ if(NULL == all_seq_list)
+ continue;
+
+ for(i = 0; i < AXIS2_ARRAY_LIST_SIZE(all_seq_list, env); i++)
+ {
+ axis2_char_t *seq_id = NULL;
+ long next_msg_no = -1;
+ sandesha2_next_msg_bean_t *next_msg_bean = NULL;
+ axis2_array_list_t *st_map_list = NULL;
+ sandesha2_invoker_bean_t *find_bean = NULL;
+ axis2_bool_t invoked = AXIS2_FALSE;
+ int j = 0;
+ axis2_bool_t continue_sequence = AXIS2_TRUE;
+
+ seq_id = AXIS2_ARRAY_LIST_GET(all_seq_list, env, i);
+ SANDESHA2_TRANSACTION_COMMIT(transaction, env);
+ transaction = SANDESHA2_STORAGE_MANAGER_GET_TRANSACTION(
+ storage_manager, env);
+ next_msg_bean = SANDESHA2_NEXT_MSG_BEAN_MANAGER_RETRIEVE(
+ next_msg_mgr, env, seq_id);
+ if(NULL == next_msg_bean)
+ {
+ axis2_char_t *str_list = NULL;
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Next message not set"
+ " correctly. Removing invalid entry.");
+ AXIS2_ARRAY_LIST_REMOVE(all_seq_list, env, i);
+ /* We need to make sure we are not skipping element after
+ * removing current element
+ */
+ i--;
+ str_list = sandesha2_utils_array_list_to_string(env, all_seq_list);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(all_seq_bean, env,
+ str_list);
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_UPDATE(seq_prop_mgr, env,
+ all_seq_bean);
+ continue;
+ }
+ next_msg_no = SANDESHA2_NEXT_MSG_BEAN_GET_NEXT_MSG_NO_TO_PROCESS(
+ next_msg_bean, env);
+ if(next_msg_no < 0)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid message number"
+ " as the Next Message Number.");
+ return data;
+ }
+ find_bean = sandesha2_invoker_bean_create_with_data(env, NULL,
+ next_msg_no, seq_id, AXIS2_FALSE);
+ st_map_list = SANDESHA2_INVOKER_BEAN_MANAGER_FIND(storage_map_mgr,
+ env, find_bean);
+ for(j = 0; j < AXIS2_ARRAY_LIST_SIZE(st_map_list, env); j++)
+ {
+ sandesha2_invoker_bean_t *st_map_bean = NULL;
+ axis2_char_t *key = NULL;
+ axis2_msg_ctx_t *msg_to_invoke = NULL;
+ sandesha2_msg_ctx_t *rm_msg_ctx = NULL;
+ axis2_property_t *property = NULL;
+ axis2_bool_t post_failure_invocation = AXIS2_FALSE;
+ axis2_char_t *post_failure_str = NULL;
+ axis2_msg_ctx_t *msg_ctx = NULL;
+ axis2_engine_t *engine = NULL;
+
+ st_map_bean = AXIS2_ARRAY_LIST_GET(st_map_list, env, j);
+ key = SANDESHA2_INVOKER_BEAN_GET_MSG_CONTEXT_REF_ID(st_map_bean,
+ env);
+ msg_to_invoke = SANDESHA2_STORAGE_MANAGER_RETRIEVE_MSG_CTX(
+ storage_manager, env, key, invoker_impl->conf_ctx);
+ rm_msg_ctx = sandesha2_msg_initilizer_initilize_msg(env,
+ msg_to_invoke);
+ /* have to commit the transaction before invoking. This may get
+ * changed when WS-AT is available.
+ */
+ SANDESHA2_TRANSACTION_COMMIT(transaction, env);
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(
+ SANDESHA2_VALUE_TRUE, env));
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ SANDESHA2_WITHIN_TRANSACTION, property, AXIS2_FALSE);
+
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ SANDESHA2_POST_FAILURE_MESSAGE, AXIS2_FALSE);
+ if(NULL != property)
+ post_failure_str = AXIS2_PROPERTY_GET_VALUE(property, env);
+ if(NULL != post_failure_str && 0 == AXIS2_STRCMP(
+ post_failure_str, SANDESHA2_VALUE_TRUE))
+ post_failure_invocation = AXIS2_TRUE;
+ engine = axis2_engine_create(env, invoker_impl->conf_ctx);
+ if(AXIS2_TRUE == post_failure_invocation)
+ {
+ sandesha2_in_order_invoker_make_msg_ready_for_reinjection(
+ invoker, env, msg_to_invoke);
+ AXIS2_ENGINE_RECIEVE(engine, env, msg_to_invoke);
+ }
+ else
+ AXIS2_ENGINE_RESUME_RECIEVE(engine, env, msg_to_invoke);
+ invoked = AXIS2_TRUE;
+ transaction = SANDESHA2_STORAGE_MANAGER_GET_TRANSACTION(
+ storage_manager, env);
+ SANDESHA2_STORAGE_MANAGER_DELETE(storage_manager, env, key);
+ msg_ctx = SANDESHA2_STORAGE_MANAGER_RETRIEVE_MSG_CTX(
+ storage_manager, env, key, invoker_impl->conf_ctx);
+ if(NULL != msg_ctx)
+ SANDESHA2_STORAGE_MANAGER_REMOVE_MSG_CTX(storage_manager,
+ env, key);
+ if(SANDESHA2_MSG_TYPE_APPLICATION ==
+ SANDESHA2_MSG_CTX_GET_MSG_TYPE(rm_msg_ctx, env))
+ {
+ sandesha2_sequence_t *sequence = NULL;
+ sequence = (sandesha2_sequence_t*)_MSG_CTX_GET_MSG_PART(
+ rm_msg_ctx, env, SANDESHA2_MSG_PART_SEQUENCE);
+ if(NULL != SANDESHA2_SEQUENCE_GET_LAST_MSG(sequence, env))
+ {
+ sandesha2_terminate_manager_clean_recv_side_after_invocation(
+ env, invoker_impl->conf_ctx, seq_id,
+ storage_manager);
+ /* we are done with current sequence */
+ continue_sequence = AXIS2_FALSE;
+ break;
+ }
+ }
+ }
+ if(AXIS2_FALSE == continue_sequence)
+ break;
+ if(AXIS2_TRUE == invoked)
+ {
+ next_msg_no++;
+ SANDESHA2_NEXT_MSG_BEAN_SET_NEXT_MSG_NO_TO_PROCESS(next_msg_bean,
+ env, next_msg_no);
+ SANDESHA2_NEXT_MSG_BEAN_MANAGER_UPDATE(next_msg_mgr, env,
+ next_msg_bean);
+ }
+ }
+ SANDESHA2_TRANSACTION_COMMIT(transaction, env);
+
+ /* TODO make transaction handling effective */
+ }
+ return NULL;
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org