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/19 07:18:16 UTC
svn commit: r423373 - in /webservices/sandesha/trunk/c: include/
include/sandesha2/ src/msgprocessors/ src/util/ src/workers/
Author: sahan
Date: Tue Jul 18 22:18:15 2006
New Revision: 423373
URL: http://svn.apache.org/viewvc?rev=423373&view=rev
Log:
Adding sandesha2_terminate_seq_msg_processor and sandesha2_terminate_seq_res_msg_processor
Adding sender
Added:
webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_msg_processor.h
webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_res_msg_processor.h
webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c
webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_res_msg_processor.c
webservices/sandesha/trunk/c/src/workers/sender.c
Modified:
webservices/sandesha/trunk/c/include/sandesha2/sandesha2_spec_specific_consts.h
webservices/sandesha/trunk/c/include/sandesha2_sender.h
webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am
webservices/sandesha/trunk/c/src/util/spec_specific_consts.c
webservices/sandesha/trunk/c/src/workers/Makefile.am
webservices/sandesha/trunk/c/src/workers/in_order_invoker.c
Modified: webservices/sandesha/trunk/c/include/sandesha2/sandesha2_spec_specific_consts.h
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/include/sandesha2/sandesha2_spec_specific_consts.h?rev=423373&r1=423372&r2=423373&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/include/sandesha2/sandesha2_spec_specific_consts.h (original)
+++ webservices/sandesha/trunk/c/include/sandesha2/sandesha2_spec_specific_consts.h Tue Jul 18 22:18:15 2006
@@ -60,27 +60,27 @@
sandesha2_spec_specific_consts_get_default_spec_version(
const axis2_env_t *env);
-axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
sandesha2_spec_specific_consts_get_terminate_seq_action(
const axis2_env_t *env,
axis2_char_t *spec_version);
-axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
sandesha2_spec_specific_consts_get_create_seq_action(
const axis2_env_t *env,
axis2_char_t *spec_version);
-axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
sandesha2_spec_specific_consts_get_create_seq_soap_action(
const axis2_env_t *env,
axis2_char_t *spec_version);
-axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
sandesha2_spec_specific_consts_get_close_seq_action(
const axis2_env_t *env,
axis2_char_t *spec_version);
-axis2_char_t *AXIS2_CALL
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
sandesha2_spec_specific_consts_get_ack_request_action(
const axis2_env_t *env,
axis2_char_t *spec_version);
@@ -98,6 +98,16 @@
sandesha2_spec_specific_consts_get_anon_uri(
const axis2_env_t *env,
axis2_char_t *addr_ns_val);
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+sandesha2_spec_specific_consts_is_term_seq_res_reqd(
+ const axis2_env_t *env,
+ axis2_char_t *spec_version);
+
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+sandesha2_spec_specific_consts_get_terminate_seq_soap_action(
+ const axis2_env_t *env,
+ axis2_char_t *spec_version);
/** @} */
#ifdef __cplusplus
}
Added: webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_msg_processor.h
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_msg_processor.h?rev=423373&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_msg_processor.h (added)
+++ webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_msg_processor.h Tue Jul 18 22:18:15 2006
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef SANDESHA2_TERMINATE_SEQ_MSG_PROCESSOR_H
+#define SANDESHA2_TERMINATE_SEQ_MSG_PROCESSOR_H
+
+/**
+ * @file sandesha2_terminate_seq_msg_processor.h
+ * @brief
+ */
+
+#include <axis2_utils_defines.h>
+#include <axis2_env.h>
+#include <sandesha2/sandesha2_msg_processor.h>
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/** @defgroup sandesha2_terminate_seq_msg_processor
+ * @ingroup sandesha2_msgprocessors
+ * @{
+ */
+
+AXIS2_EXTERN sandesha2_msg_processor_t* AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_create(
+ const axis2_env_t *env);
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SANDESHA2_TERMINATE_SEQ_MSG_PROCESSOR_H */
+
Added: webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_res_msg_processor.h
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_res_msg_processor.h?rev=423373&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_res_msg_processor.h (added)
+++ webservices/sandesha/trunk/c/include/sandesha2/sandesha2_terminate_seq_res_msg_processor.h Tue Jul 18 22:18:15 2006
@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef SANDESHA2_TERMINATE_SEQ_RES_MSG_PROCESSOR_H
+#define SANDESHA2_TERMINATE_SEQ_RES_MSG_PROCESSOR_H
+
+/**
+ * @file sandesha2_terminate_seq_res_msg_processor.h
+ * @brief
+ */
+
+#include <axis2_utils_defines.h>
+#include <axis2_env.h>
+#include <sandesha2/sandesha2_msg_processor.h>
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/** @defgroup sandesha2_terminate_seq_res_msg_processor
+ * @ingroup sandesha2_msgprocessors
+ * @{
+ */
+
+AXIS2_EXTERN sandesha2_msg_processor_t* AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_create(
+ const axis2_env_t *env);
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SANDESHA2_TERMINATE_SEQ_RES_MSG_PROCESSOR_H */
+
Modified: webservices/sandesha/trunk/c/include/sandesha2_sender.h
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/include/sandesha2_sender.h?rev=423373&r1=423372&r2=423373&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/include/sandesha2_sender.h (original)
+++ webservices/sandesha/trunk/c/include/sandesha2_sender.h Tue Jul 18 22:18:15 2006
@@ -54,7 +54,7 @@
const axis2_env_t *env);
axis2_status_t (AXIS2_CALL *
- stop_for_seq) (
+ stop_sender_for_seq) (
sandesha2_sender_t *sender,
const axis2_env_t *env,
axis2_char_t *seq_id);
@@ -75,7 +75,7 @@
const axis2_env_t *env);
axis2_status_t (AXIS2_CALL *
- run_for_seq) (
+ run_sender_for_seq) (
sandesha2_sender_t *sender,
const axis2_env_t *env,
axis2_conf_ctx_t *conf_ctx,
@@ -94,7 +94,7 @@
#define SANDESHA2_SENDER_FREE(sender, env) \
(((sandesha2_sender_t *) sender)->ops->free (sender, env))
-#define SANDESHA2_SENDER_STOP_FOR_SEQ(sender, env, \
+#define SANDESHA2_SENDER_STOP_SENDER_FOR_SEQ(sender, env, \
seq_id) \
(((sandesha2_sender_t *) sender)->ops->\
stop_for_seq (sender, env, seq_id))
@@ -111,7 +111,7 @@
(((sandesha2_sender_t *) sender)->ops->\
run (sender, env))
-#define SANDESHA2_SENDER_RUN_FOR_SEQ(sender, env, conf_ctx, seq_id) \
+#define SANDESHA2_SENDER_RUN_SENDER_FOR_SEQ(sender, env, conf_ctx, seq_id) \
(((sandesha2_sender_t *) sender)->ops->\
run_for_seq (sender, env, conf_ctx, seq_id))
Modified: webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am?rev=423373&r1=423372&r2=423373&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am Tue Jul 18 22:18:15 2006
@@ -6,7 +6,9 @@
ack_msg_processor.c\
ack_req_msg_processor.c\
close_seq_msg_processor.c\
- create_seq_res_msg_processor.c
+ create_seq_res_msg_processor.c\
+ terminate_seq_msg_processor.c\
+ terminate_seq_res_msg_processor.c
INCLUDES = -I$(top_builddir)/include \
@AXIS2INC@
Added: webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c?rev=423373&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c (added)
+++ webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c Tue Jul 18 22:18:15 2006
@@ -0,0 +1,595 @@
+/*
+ * 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_terminate_seq_msg_processor.h>
+#include <sandesha2_seq_property_mgr.h>
+#include <sandesha2_seq_property_bean.h>
+#include <sandesha2_storage_mgr.h>
+#include <sandesha2_fault_mgr.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <sandesha2/sandesha2_utils.h>
+#include <sandesha2/sandesha2_msg_ctx.h>
+#include <sandesha2/sandesha2_terminate_seq.h>
+#include <axis2_msg_ctx.h>
+#include <axis2_string.h>
+#include <axis2_engine.h>
+#include <axiom_soap_const.h>
+#include <stdio.h>
+#include <sandesha2_storage_mgr.h>
+#include <axis2_msg_ctx.h>
+#include <axis2_conf_ctx.h>
+#include <axis2_core_utils.h>
+#include <sandesha2/sandesha2_seq_ack.h>
+#include <sandesha2/sandesha2_create_seq_res.h>
+#include <axis2_uuid_gen.h>
+#include <sandesha2_create_seq_bean.h>
+#include <sandesha2_create_seq_mgr.h>
+#include <axis2_endpoint_ref.h>
+#include <axis2_op_ctx.h>
+#include <sandesha2/sandesha2_spec_specific_consts.h>
+#include <sandesha2/sandesha2_ack_msg_processor.h>
+#include <sandesha2/sandesha2_seq.h>
+#include "../client/sandesha2_client_constants.h"
+
+/**
+ * @brief Terminate Sequence Message Processor struct impl
+ * Sandesha2 Terminate Sequence Msg Processor
+ */
+typedef struct sandesha2_terminate_seq_msg_processor_impl
+ sandesha2_terminate_seq_msg_processor_impl_t;
+
+struct sandesha2_terminate_seq_msg_processor_impl
+{
+ sandesha2_msg_processor_t msg_processor;
+};
+
+#define SANDESHA2_INTF_TO_IMPL(msg_proc) \
+ ((sandesha2_terminate_seq_msg_processor_impl_t *)\
+ (msg_proc))
+
+/***************************** Function headers *******************************/
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_process_in_msg (
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_process_out_msg(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ sandesha2_storage_mgr_t *storage_man,
+ axis2_char_t *seq_id,
+ sandesha2_msg_ctx_t *rm_msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_add_terminate_seq_res(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx,
+ axis2_char_t *seq_id,
+ sandesha2_storage_mgr_t *storage_man);
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_free (sandesha2_msg_processor_t *element,
+ const axis2_env_t *env);
+
+/***************************** End of function headers ************************/
+
+AXIS2_EXTERN sandesha2_msg_processor_t* AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_create(const axis2_env_t *env)
+{
+ sandesha2_terminate_seq_msg_processor_impl_t *msg_proc_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_proc_impl = ( sandesha2_terminate_seq_msg_processor_impl_t *)AXIS2_MALLOC
+ (env->allocator,
+ sizeof( sandesha2_terminate_seq_msg_processor_impl_t));
+
+ if(NULL == msg_proc_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg_proc_impl->msg_processor.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(sandesha2_msg_processor_ops_t));
+ if(NULL == msg_proc_impl->msg_processor.ops)
+ {
+ sandesha2_terminate_seq_msg_processor_free((sandesha2_msg_processor_t*)
+ msg_proc_impl, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg_proc_impl->msg_processor.ops->process_in_msg =
+ sandesha2_terminate_seq_msg_processor_process_in_msg;
+ msg_proc_impl->msg_processor.ops->process_out_msg =
+ sandesha2_terminate_seq_msg_processor_process_out_msg;
+ msg_proc_impl->msg_processor.ops->free =
+ sandesha2_terminate_seq_msg_processor_free;
+
+ return &(msg_proc_impl->msg_processor);
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_free (sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env)
+{
+ sandesha2_terminate_seq_msg_processor_impl_t *msg_proc_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg_proc_impl = SANDESHA2_INTF_TO_IMPL(msg_processor);
+
+ if(NULL != msg_processor->ops)
+ AXIS2_FREE(env->allocator, msg_processor->ops);
+
+ AXIS2_FREE(env->allocator, SANDESHA2_INTF_TO_IMPL(msg_processor));
+ return AXIS2_SUCCESS;
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_process_in_msg (
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+ axis2_msg_ctx_t *msg_ctx = NULL;
+ sandesha2_seq_ack_t *seq_ack = NULL;
+ sandesha2_terminate_seq_t *term_seq = NULL;
+ axis2_char_t *seq_id = NULL;
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ sandesha2_storage_mgr_t *storage_man = NULL;
+ sandesha2_fault_mgr_t *fault_mgr = NULL;
+ sandesha2_msg_ctx_t *fault_ctx = NULL;
+ sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL;
+ sandesha2_seq_property_bean_t *term_rcvd_bean = NULL;
+ sandesha2_seq_property_bean_t *transmit_bean = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+
+ msg_ctx = SANDESHA2_MSG_CTX_GET_MSG_CTX(rm_msg_ctx, env);
+
+ seq_ack = (sandesha2_seq_ack_t*)SANDESHA2_MSG_CTX_GET_MSG_PART(
+ rm_msg_ctx, env, SANDESHA2_MSG_PART_SEQ_ACKNOWLEDGEMENT);
+
+ if(NULL != seq_ack)
+ {
+ sandesha2_msg_processor_t *ack_processor = NULL;
+ ack_processor = sandesha2_ack_msg_processor_create(env);
+ SANDESHA2_MSG_PROCESSOR_PROCESS_IN_MSG(ack_processor, env, rm_msg_ctx);
+ }
+ term_seq = (sandesha2_terminate_seq_t*)SANDESHA2_MSG_CTX_GET_MSG_PART(
+ rm_msg_ctx, env, SANDESHA2_MSG_PART_TERMINATE_SEQ);
+ if(NULL == term_seq)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate "
+ "Sequence part is not available");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ seq_id = SANDESHA2_IDENTIFIER_GET_IDENTIFIER(
+ SANDESHA2_TERMINATE_SEQ_GET_IDENTIFIER(term_seq, env), env);
+ if(NULL == seq_id || 0 == AXIS2_STRLEN(seq_id))
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Invalid "
+ "sequence id");
+ return AXIS2_FAILURE;
+ }
+ conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
+ storage_man = sandesha2_utils_get_storage_mgr(env, conf_ctx,
+ AXIS2_CONF_CTX_GET_CONF(conf_ctx, env));
+ fault_mgr = sandesha2_fault_mgr_create(env);
+ fault_ctx = SANDESHA2_FAULT_MGR_CHECK_FOR_UNKNOWN_SEQ(fault_mgr, env,
+ rm_msg_ctx, seq_id, storage_man);
+ if(NULL != fault_ctx)
+ {
+ axis2_engine_t *engine = NULL;
+ engine = axis2_engine_create(env, conf_ctx);
+
+ AXIS2_ENGINE_SEND_FAULT(engine, env, SANDESHA2_MSG_CTX_GET_MSG_CTX(
+ fault_ctx, env));
+ AXIS2_MSG_CTX_PAUSE(msg_ctx, env);
+ return AXIS2_SUCCESS;
+ }
+ seq_prop_mgr = SANDESHA2_STORAGE_MGR_GET_SEQ_PROPERTY_MGR(storage_man, env);
+ term_rcvd_bean = sandesha2_seq_property_bean_create(env);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_SEQ_ID(term_rcvd_bean, env, seq_id);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_NAME(term_rcvd_bean, env,
+ SANDESHA2_SEQ_PROP_TERMINATE_RECEIVED);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(term_rcvd_bean, env,
+ SANDESHA2_VALUE_TRUE);
+ SANDESHA2_SEQ_PRPERTY_MGR_INSERT(seq_prop_mgr, env, term_rcvd_bean);
+
+ if(AXIS2_TRUE == sandesha2_spec_specific_consts_is_term_seq_res_reqd(env,
+ SANDESHA2_MSG_CTX_GET_RM_SPEC_VER(rm_msg_ctx, env)))
+ sandesha2_terminate_seq_msg_processor_add_terminate_seq_res(
+ msg_processor, env, rm_msg_ctx, seq_id, storage_man);
+ sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums(msg_processor,
+ env, conf_ctx, storage_man, seq_id, rm_msg_ctx);
+ sandesha2_terminate_mgr_clean_recv_side_on_terminate_msg(env, conf_ctx,
+ seq_id, storage_man);
+ transmit_bean = sandesha2_seq_property_bean_create_with_data(env, seq_id,
+ SANDESHA2_SEQ_PROP_SEQ_TERMINATED, SANDESHA2_VALUE_TRUE);
+ SANDESHA2_SEQ_PROPERTY_MGR_INSERT(seq_prop_mgr, env, transmit_bean);
+ sandesha2_seq_mgr_update_last_activated_time(env, seq_id, storage_man);
+
+ SANDESHA2_MSG_CTX_PAUSE(msg_ctx, env);
+
+ return AXIS2_SUCCESS;
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_setup_highest_msg_nums(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ sandesha2_storage_mgr_t *storage_man,
+ axis2_char_t *seq_id,
+ sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+ sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL;
+ axis2_char_t *highest_msg_num_str = NULL;
+ axis2_char_t *highest_msg_key = NULL;
+ long highest_in_msg_num = 0;
+ long highest_out_msg_num = 0;
+ axis2_char_t *res_side_int_seq_id = NULL;
+ axis2_bool_t add_res_side_term = AXIS2_FALSE;
+ axis2_char_t *out_seq_id = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, storage_man, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+
+ seq_prop_mgr = SANDESHA2_STORAGE_MGR_GET_SEQ_PROPERTY_MGR(storage_man, env);
+
+ highest_msg_num_str = sandesha2_utils_get_seq_property(env, seq_id,
+ SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_NUMBER, storage_man);
+ highest_msg_key = sandesha2_utils_get_seq_property(env, seq_id,
+ SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_KEY, storage_man);
+ if(NULL != highest_msg_num_str)
+ {
+ if(NULL == highest_msg_key)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Key of the "
+ "highest message number has not been stored");
+ return AXIS2_FAILURE;
+ }
+ highest_in_msg_num = atol(highest_msg_num_str);
+ }
+ res_side_int_seq_id = sandesha2_utils_get_outgoing_internal_seq_id(env,
+ seq_id);
+ if(0 == highest_in_msg_num)
+ add_res_side_term = AXIS2_FALSE;
+ else
+ {
+ sandesha2_seq_property_bean_t *last_in_msg_bean = NULL;
+ axis2_msg_ctx_t *highest_in_msg = NULL;
+ axis2_msg_ctx_t *highest_out_msg = NULL;
+
+ last_in_msg_bean = sandesha2_seq_property_bean_create_with_data(env,
+ seq_id, SANDESHA2_SEQ_PROP_LAST_IN_MESSAGE_NO,
+ highest_msg_num_str);
+ SANDESHA2_SEQ_PROPERTY_MGR_INSERT(seq_prop_mgr, env, last_in_msg_bean);
+ highest_in_msg = SANDESHA2_STORAGE_MGR_RETRIEVE_MSG_CTX(storage_man, env,
+ highest_msg_key, conf_ctx);
+ highest_out_msg = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(
+ highest_in_msg, env), env,
+ AXIS2_WSDL_MESSAGE_LABEL_OUT_VALUE);
+ if(NULL != highest_out_msg)
+ {
+ sandesha2_msg_ctx_t *highest_out_rm_msg = NULL;
+ sandesha2_seq_t *seq_of_out_msg = NULL;
+ highest_out_rm_msg = sandesha2_msg_initilizer_init_msg(env,
+ highest_out_msg);
+ seq_of_out_msg = (sandesha2_seq_t*)
+ SANDESHA2_MSG_CTX_GET_MSG_PART(highest_out_rm_msg, env,
+ SANDESHA2_MSG_PART_SEQ);
+ if(NULL != seq_of_out_msg)
+ {
+ axis2_char_t long_str[32];
+ sandesha2_seq_property_bean_t *highest_out_msg_bean = NULL;
+
+ highest_out_msg_num = SANDESHA2_MSG_NUMBER_GET_MSG_NUM(
+ SANDESHA2_SEQ_GET_MSG_NUM(seq_of_out_msg, env), env);
+ sprintf(long_str, "%ld", highest_out_msg_num);
+ highest_out_msg_bean =
+ sandesha2_seq_property_bean_create_with_data(env,
+ res_side_int_seq_id, SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NO,
+ long_str);
+ SANDESHA2_SEQ_PROPERTY_MGR_INSERT(seq_prop_mgr, env,
+ highest_out_msg_bean);
+ add_res_side_term = AXIS2_TRUE;
+ }
+ }
+ }
+ out_seq_id = sandesha2_utils_get_seq_property(env, res_side_int_seq_id,
+ SANDESHA2_SEQ_PROP_OUT_SEQ_ID, storage_man);
+ if(AXIS2_TRUE == add_res_side_term && highest_out_msg_num > 0 &&
+ NULL != res_side_int_seq_id && NULL != out_seq_id)
+ {
+ axis2_bool_t all_acked = AXIS2_FALSE;
+ all_acked = sandesha2_utils_is_all_msgs_acked_upto(env,
+ highest_out_msg_num, res_side_int_seq_id, storage_man);
+ if(AXIS2_TRUE == all_acked)
+ sandesha2_terminate_mgr_add_terminate_seq_msg(env, rm_msg_ctx,
+ out_seq_id, res_side_int_seq_id, storage_man);
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_add_terminate_seq_res(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx,
+ axis2_char_t *seq_id,
+ sandesha2_storage_mgr_t *storage_man)
+{
+ axis2_msg_ctx_t *msg_ctx = NULL;
+ axis2_msg_ctx_t *out_msg_ctx = NULL;
+ sandesha2_msg_ctx_t *out_rm_msg = NULL;
+ sandesha2_msg_ctx_t *ack_rm_msg = NULL;
+ sandesha2_seq_ack_t *seq_ack = NULL;
+ axis2_property_t *property = NULL;
+ axis2_engine_t *engine = NULL;
+ axis2_char_t *addr_ns_uri = NULL;
+ axis2_char_t *anon_uri = NULL;
+ axis2_endpoint_ref_t *to_epr = NULL;
+ axis2_ctx_t *ctx = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, storage_man, AXIS2_FAILURE);
+
+ msg_ctx = SANDESHA2_MSG_CTX_GET_MSG_CTX(rm_msg_ctx, env);
+ out_msg_ctx = axis2_core_utils_create_out_msg_ctx(env, msg_ctx);
+ out_rm_msg = sandesha2_msg_creator_create_terminate_seq_res_msg(env,
+ rm_msg_ctx, out_msg_ctx, storage_man);
+
+ ack_rm_msg = sandesha2_ack_mgr_generate_ack_msg(env, rm_msg_ctx, seq_id,
+ storage_man);
+ seq_ack = (sandesha2_seq_ack_t*)SANDESHA2_MSG_CTX_GET_MSG_PART(ack_rm_msg,
+ env, SANDESHA2_MSG_PART_SEQ_ACKNOWLEDGEMENT);
+ SANDESHA2_MSG_CTX_SET_MSG_PART(out_rm_msg, env,
+ SANDESHA2_MSG_PART_SEQ_ACKNOWLEDGEMENT,
+ (sandesha2_iom_rm_part_t*)seq_ack);
+ SANDESHA2_MSG_CTX_ADD_SOAP_ENVELOPE(out_rm_msg, env);
+ SANDESHA2_MSG_CTX_SET_FLOW(out_rm_msg, env, AXIS2_OUT_FLOW);
+
+ 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(out_msg_ctx, env,
+ SANDESHA2_APPLICATION_PROCESSING_DONE, property,
+ AXIS2_FALSE);
+ AXIS2_MSG_CTX_SET_RESPONSE_WRITTEN(out_msg_ctx, env, AXIS2_TRUE);
+
+ engine = axis2_engine_create(env, AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env));
+ AXIS2_ENGINE_SEND(engine, env, out_msg_ctx);
+
+ addr_ns_uri = sandesha2_utils_get_seq_property(env, seq_id,
+ SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE,
+ storage_man);
+ anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_uri);
+ to_epr = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
+
+ ctx = AXIS2_OP_CTX_GET_BASE(AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env), env);
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+
+ if(0 == AXIS2_STRCMP(anon_uri, AXIS2_ENDPOINT_REF_GET_ADDRESS(to_epr, env)))
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP("TRUE", env));
+ else
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP("FALSE", env));
+
+ AXIS2_CTX_SET_PROPERTY(ctx, env, AXIS2_RESPONSE_WRITTEN, property,
+ AXIS2_FALSE);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_msg_processor_process_out_msg(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+ axis2_msg_ctx_t *msg_ctx = NULL;
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ sandesha2_storage_mgr_t *storage_man = NULL;
+ sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL;
+ axis2_char_t *to_address = NULL;
+ axis2_char_t *seq_key = NULL;
+ axis2_char_t *int_seq_id = NULL;
+ axis2_char_t *out_seq_id = NULL;
+ axis2_property_t *property = NULL;
+ axis2_char_t *terminated = NULL;
+ axis2_op_t *old_op = NULL;
+ axis2_op_t *out_in_op = NULL;
+ axis2_qname_t *qname = NULL;
+ axis2_op_ctx_t *op_ctx = NULL;
+ sandesha2_terminate_seq_t *term_seq_part = NULL;
+ axis2_char_t *rm_version = NULL;
+ axis2_char_t *transport_to = NULL;
+ axis2_char_t *key = NULL;
+ sandesha2_sender_bean_t *term_bean = NULL;
+ sandesha2_sender_mgr_t *retrans_mgr = NULL;
+ sandesha2_seq_property_bean_t *term_added = NULL;
+ axis2_transport_out_desc_t *out_desc = NULL;
+ axis2_engine_t *engine = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+
+ msg_ctx = SANDESHA2_MSG_CTX_GET_MSG_CTX(rm_msg_ctx, env);
+ conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
+
+ storage_man = sandesha2_utils_get_storage_mgr(env, conf_ctx,
+ AXIS2_CONF_CTX_GET_CONF(conf_ctx, env));
+ seq_prop_mgr = SANDESHA2_STORAGE_MGR_GET_SEQ_PROPERTY_MGR(storage_man, env);
+ to_address = AXIS2_ENDPOINT_REF_GET_ADDRESS(AXIS2_MSG_CTX_GET_TO(msg_ctx,
+ env), env);
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env, SANDESHA2_CLIENT_SEQ_KEY,
+ AXIS2_FALSE);
+ seq_key = AXIS2_PROPERTY_GET_VALUE(property, env);
+ int_seq_id = sandesha2_utils_get_internal_seq_id(env, to_address, seq_key);
+ out_seq_id = sandesha2_utils_get_seq_property(env, int_seq_id,
+ SANDESHA2_SEQ_PROP_OUT_SEQ_ID, storage_man);
+ if(NULL == out_seq_id)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] seq_id was not"
+ " found. Cannot send the terminate message");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CANNOT_FIND_SEQ_ID,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ terminated = sandesha2_utils_get_seq_property(env, int_seq_id,
+ SANDESHA2_SEQ_PROP_TERMINATE_ADDED, storage_man);
+ old_op = AXIS2_MSG_CTX_GET_OP(msg_ctx, env);
+
+ qname = axis2_qname_create(env, "temp", NULL, NULL);
+
+ out_in_op = axis2_op_create_with_qname(env, qname);
+ AXIS2_OP_SET_MSG_EXCHANGE_PATTERN(out_in_op, env, AXIS2_MEP_URI_OUT_IN);
+ AXIS2_OP_SET_REMAINING_PHASES_INFLOW(out_in_op, env,
+ AXIS2_OP_GET_REMAINING_PHASES_INFLOW(old_op, env));
+ op_ctx = axis2_op_ctx_create(env, out_in_op, NULL);
+ AXIS2_OP_CTX_SET_PARENT(op_ctx, env, AXIS2_MSG_CTX_GET_SVC_CTX(msg_ctx, env));
+ AXIS2_CONF_CTX_REGISTER_OP_CTX(conf_ctx, env, SANDESHA2_MSG_CTX_GET_MSG_ID(
+ rm_msg_ctx, env), op_ctx);
+
+ if(NULL != terminated && 0 == AXIS2_STRCMP(terminated, SANDESHA2_VALUE_TRUE))
+ {
+ AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "[sandesha2] Terminate was "
+ "added previously");
+ return AXIS2_SUCCESS;
+ }
+ term_seq_part = (sandesha2_terminate_seq_t*)SANDESHA2_MSG_CTX_GET_MSG_PART(
+ rm_msg_ctx, env, SANDESHA2_MSG_PART_TERMINATE_SEQ);
+ SANDESHA2_IDENTIFIER_SET_IDENTIFIER(SANDESHA2_TERMINATE_SEQ_GET_IDENTIFIER(
+ term_seq_part, env), env, out_seq_id);
+ SANDESHA2_MSG_CTX_SET_FLOW(rm_msg_ctx, env, AXIS2_OUT_FLOW);
+ 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_APPLICATION_PROCESSING_DONE, property,
+ AXIS2_FALSE);
+ AXIS2_MSG_CTX_SET_TO(msg_ctx, env, axis2_endpoint_ref_create(env, to_address));
+ rm_version = sandesha2_utils_get_rm_version(env, int_seq_id, storage_man);
+ if(NULL == rm_version)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Cant find the"
+ " rm_version of the given message");
+ return AXIS2_FAILURE;
+ }
+ AXIS2_MSG_CTX_SET_WSA_ACTION(msg_ctx, env,
+ sandesha2_spec_specific_consts_get_terminate_seq_action(
+ env, rm_version));
+ AXIS2_MSG_CTX_SET_SOAP_ACTION(msg_ctx, env,
+ sandesha2_spec_specific_consts_get_terminate_seq_soap_action
+ (env, rm_version));
+ transport_to = sandesha2_utils_get_seq_property(env, int_seq_id,
+ SANDESHA2_SEQ_PROP_TRANSPORT_TO, storage_man);
+
+ if(NULL != transport_to)
+ {
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(transport_to,
+ env));
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ AXIS2_TRANSPORT_URL, property, AXIS2_FALSE);
+ }
+ SANDESHA2_MSG_CTX_ADD_SOAP_ENVELOPE(rm_msg_ctx, env);
+
+ key = axis2_uuid_gen(env);
+ term_bean = sandesha2_sender_bean_create(env);
+ SANDESHA2_SENDER_BEAN_SET_MSG_CTX_REF_KEY(term_bean, env, key);
+ SANDESHA2_STORAGE_MGR_STORE_MSG_CTX(storage_man, env, key, msg_ctx);
+
+ /* TODO: refine the terminate delay */
+ SANDESHA2_SENDER_BEAN_SET_TIME_TO_SEND(term_bean, env,
+ sandesha2_utils_get_current_time_in_millis(env) +
+ SANDESHA2_TERMINATE_DELAY);
+ SANDESHA2_SENDER_BEAN_MSG_ID(term_bean, env, AXIS2_MSG_CTX_GET_MSG_ID(
+ msg_ctx, env));
+ SANDESHA2_SENDER_BEAN_SET_SEND(term_bean, env, AXIS2_TRUE);
+
+ 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_SENDER_BEAN_SET_RESEND(term_bean, env, AXIS2_FALSE);
+
+ retrans_mgr = SANDESHA2_STORAGE_MGR_GET_RETRANS_MGR(storage_man, env);
+ SANDESHA2_SENDER_MGR_INSERT(retrans_mgr, env, term_bean);
+
+ term_added = sandesha2_seq_property_bean_create(env);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_NAME(term_added, env,
+ SANDESHA2_SEQ_PROP_TERMINATE_ADDED);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_SEQ_ID(term_added, env, out_seq_id);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(term_added, env, SANDESHA2_VALUE_TRUE);
+
+ SANDESHA2_SEQ_PROPERTY_MGR_INSERT(seq_prop_mgr, env, term_added);
+
+ out_desc = AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(msg_ctx, env);
+
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, out_desc);
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property,
+ AXIS2_FALSE);
+
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(key,env));
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ SANDESHA2_MESSAGE_STORE_KEY, property, AXIS2_FALSE);
+
+ 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_SET_SEND_TO_TRUE, property, AXIS2_FALSE);
+
+ AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(msg_ctx, env,
+ sandesha2_utils_get_transport_out(env));
+ engine = axis2_engine_create(env, conf_ctx);
+ AXIS2_ENGINE_SEND(engine, env, msg_ctx);
+ return AXIS2_SUCCESS;
+}
Added: webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_res_msg_processor.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_res_msg_processor.c?rev=423373&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_res_msg_processor.c (added)
+++ webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_res_msg_processor.c Tue Jul 18 22:18:15 2006
@@ -0,0 +1,131 @@
+/*
+ * 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_terminate_seq_res_msg_processor.h>
+
+
+/**
+ * @brief Terminate Sequence Response Message Processor struct impl
+ * Sandesha2 Terminate Sequence Response Msg Processor
+ */
+typedef struct sandesha2_terminate_seq_res_msg_processor_impl
+ sandesha2_terminate_seq_res_msg_processor_impl_t;
+
+struct sandesha2_terminate_seq_res_msg_processor_impl
+{
+ sandesha2_msg_processor_t msg_processor;
+};
+
+#define SANDESHA2_INTF_TO_IMPL(msg_proc) \
+ ((sandesha2_terminate_seq_res_msg_processor_impl_t *)\
+ (msg_proc))
+
+/***************************** Function headers *******************************/
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_process_in_msg (
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_process_out_msg(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx);
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_free (sandesha2_msg_processor_t *element,
+ const axis2_env_t *env);
+
+/***************************** End of function headers ************************/
+
+AXIS2_EXTERN sandesha2_msg_processor_t* AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_create(const axis2_env_t *env)
+{
+ sandesha2_terminate_seq_res_msg_processor_impl_t *msg_proc_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_proc_impl = ( sandesha2_terminate_seq_res_msg_processor_impl_t *)AXIS2_MALLOC
+ (env->allocator,
+ sizeof( sandesha2_terminate_seq_res_msg_processor_impl_t));
+
+ if(NULL == msg_proc_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg_proc_impl->msg_processor.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(sandesha2_msg_processor_ops_t));
+ if(NULL == msg_proc_impl->msg_processor.ops)
+ {
+ sandesha2_terminate_seq_res_msg_processor_free((sandesha2_msg_processor_t*)
+ msg_proc_impl, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg_proc_impl->msg_processor.ops->process_in_msg =
+ sandesha2_terminate_seq_res_msg_processor_process_in_msg;
+ msg_proc_impl->msg_processor.ops->process_out_msg =
+ sandesha2_terminate_seq_res_msg_processor_process_out_msg;
+ msg_proc_impl->msg_processor.ops->free =
+ sandesha2_terminate_seq_res_msg_processor_free;
+
+ return &(msg_proc_impl->msg_processor);
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_free (sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env)
+{
+ sandesha2_terminate_seq_res_msg_processor_impl_t *msg_proc_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg_proc_impl = SANDESHA2_INTF_TO_IMPL(msg_processor);
+
+ if(NULL != msg_processor->ops)
+ AXIS2_FREE(env->allocator, msg_processor->ops);
+
+ AXIS2_FREE(env->allocator, SANDESHA2_INTF_TO_IMPL(msg_processor));
+ return AXIS2_SUCCESS;
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_process_in_msg (
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+
+ return AXIS2_SUCCESS;
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_terminate_seq_res_msg_processor_process_out_msg(
+ sandesha2_msg_processor_t *msg_processor,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+
+ 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=423373&r1=423372&r2=423373&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/util/spec_specific_consts.c (original)
+++ webservices/sandesha/trunk/c/src/util/spec_specific_consts.c Tue Jul 18 22:18:15 2006
@@ -201,3 +201,40 @@
return AXIS2_FALSE;
}
+AXIS2_EXTERN axis2_char_t *AXIS2_CALL
+sandesha2_spec_specific_consts_get_terminate_seq_soap_action(
+ const axis2_env_t *env,
+ axis2_char_t *spec_version)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, spec_version, NULL);
+
+ if (0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_0, spec_version))
+ return SANDESHA2_SPEC_2005_02_SOAP_ACTION_TERMINATE_SEQ;
+ else if (0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_1, spec_version))
+ return SANDESHA2_SPEC_2005_10_SOAP_ACTION_TERMINATE_SEQ;
+ else
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE,
+ AXIS2_FAILURE);
+ return NULL;
+}
+
+
+AXIS2_EXTERN axis2_bool_t AXIS2_CALL
+sandesha2_spec_specific_consts_is_term_seq_res_reqd(
+ const axis2_env_t *env,
+ axis2_char_t *spec_version)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, spec_version, AXIS2_FALSE);
+
+ if (0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_0, spec_version))
+ return AXIS2_TRUE;
+ else if (0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_1, spec_version))
+ return AXIS2_FALSE;
+ else
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_UNKNOWN_SPEC_ERROR_MESSAGE,
+ AXIS2_FAILURE);
+
+ return AXIS2_FALSE;
+}
Modified: webservices/sandesha/trunk/c/src/workers/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/workers/Makefile.am?rev=423373&r1=423372&r2=423373&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/workers/Makefile.am (original)
+++ webservices/sandesha/trunk/c/src/workers/Makefile.am Tue Jul 18 22:18:15 2006
@@ -1,6 +1,7 @@
noinst_LTLIBRARIES = libsandesha2_workers.la
-libsandesha2_workers_la_SOURCES = in_order_invoker.c
+libsandesha2_workers_la_SOURCES = in_order_invoker.c\
+ sender.c
INCLUDES = -I$(top_builddir)/include \
@AXIS2INC@
Modified: 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=423373&r1=423372&r2=423373&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/workers/in_order_invoker.c (original)
+++ webservices/sandesha/trunk/c/src/workers/in_order_invoker.c Tue Jul 18 22:18:15 2006
@@ -177,11 +177,23 @@
const axis2_env_t *env, axis2_char_t *seq_id)
{
sandesha2_in_order_invoker_impl_t *invoker_impl = NULL;
+ int i = 0;
+
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);
+ for(i = 0; i < AXIS2_ARRY_LIST_SIZE(invoker_impl->working_seqs, env); i++)
+ {
+ axis2_char_t *tmp_id = NULL;
+ tmp_id = AXIS2_ARRAY_LIST_GET(invoker_impl->working_seqs, env, i);
+ if(0 == AXIS2_STRCMP(seq_id, tmp_id))
+ {
+ AXIS2_ARRAY_LIST_REMOVE(invoker_impl->working_seqs, env, i);
+ break;
+ }
+ }
if(0 == AXIS2_ARRY_LIST_SIZE(invoker_impl->working_seqs, env))
invoker_impl->run_invoker = AXIS2_FALSE;
axis2_thread_mutex_unlock(invoker_impl->mutex);
Added: webservices/sandesha/trunk/c/src/workers/sender.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/workers/sender.c?rev=423373&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/workers/sender.c (added)
+++ webservices/sandesha/trunk/c/src/workers/sender.c Tue Jul 18 22:18:15 2006
@@ -0,0 +1,540 @@
+/*
+ * 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_sender.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <sandesha2/sandesha2_utils.h>
+#include <sandesha2_transaction.h>
+#include <sandesha2_storage_mgr.h>
+#include <sandesha2_seq_property_bean.h>
+#include <sandesha2_seq_property_mgr.h>
+#include <sandesha2/sandesha2_msg_ctx.h>
+#include <sandesha2/sandesha2_seq.h>
+#include <axis2_addr.h>
+#include <axis2_engine.h>
+#include <stdio.h>
+
+
+/**
+ * @brief Sender struct impl
+ * Sandesha2 Sender Invoker
+ */
+typedef struct sandesha2_sender_impl sandesha2_sender_impl_t;
+typedef struct sandesha2_sender_args sandesha2_sender_args_t;
+
+struct sandesha2_sender_impl
+{
+ sandesha2_sender_t sender;
+ axis2_conf_ctx_t *conf_ctx;
+ axis2_bool_t run_sender;
+ axis2_array_list_t *working_seqs;
+ axis2_thread_mutex_t *mutex;
+};
+
+struct sandesha2_sender_args
+{
+ sandesha2_sender_impl_t *impl;
+ axis2_env_t *env;
+};
+
+#define SANDESHA2_INTF_TO_IMPL(sender) \
+ ((sandesha2_sender_impl_t *)(sender))
+
+/***************************** Function headers *******************************/
+axis2_status_t AXIS2_CALL
+sandesha2_sender_stop_sender_for_seq
+ (sandesha2_sender_t *sender,
+ const axis2_env_t *env, axis2_char_t *seq_id);
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_stop_sending (sandesha2_sender_t *sender,
+ const axis2_env_t *env);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_sender_started
+ (sandesha2_sender_t *sender,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_run_sender_for_seq
+ (sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ axis2_conf_ctx_t *conf_ctx,
+ axis2_char_t *seq_id);
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_run (sandesha2_sender_t *sender,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_check_for_sync_res(
+ sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ axis2_msg_ctx_t *msg_ctx);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_ack_already_piggybacked(
+ sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx);
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_fault_envelope(
+ sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ axiom_soap_envelope_t *soap_envelope);
+
+
+void * AXIS2_THREAD_FUNC
+sandesha2_sender_worker_func(axis2_thread_t *thd, void *data);
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_free(sandesha2_sender_t *sender,
+ const axis2_env_t *env);
+
+/***************************** End of function headers ************************/
+
+AXIS2_EXTERN sandesha2_sender_t* AXIS2_CALL
+sandesha2_sender_create(const axis2_env_t *env)
+{
+ sandesha2_sender_impl_t *sender_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ sender_impl = (sandesha2_sender_impl_t *)AXIS2_MALLOC
+ (env->allocator,
+ sizeof(sandesha2_sender_impl_t));
+
+ if(NULL == sender_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ sender_impl->conf_ctx = NULL;
+ sender_impl->run_sender = AXIS2_FALSE;
+ sender_impl->working_seqs = NULL;
+ sender_impl->mutex = NULL;
+ sender_impl->sender.ops = NULL;
+
+ sender_impl->sender.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(sandesha2_sender_ops_t));
+ if(NULL == sender_impl->sender.ops)
+ {
+ sandesha2_sender_free(
+ (sandesha2_sender_t*)sender_impl, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ sender_impl->working_seqs = axis2_array_list_create(env,
+ AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
+ sender_impl->mutex = axis2_thread_mutex_create(env->allocator,
+ AXIS2_THREAD_MUTEX_DEFAULT);
+
+ sender_impl->sender.ops->stop_sender_for_seq =
+ sandesha2_sender_stop_sender_for_seq;
+ sender_impl->sender.ops->stop_sending =
+ sandesha2_sender_stop_sending;
+ sender_impl->sender.ops->is_sender_started =
+ sandesha2_sender_is_sender_started;
+ sender_impl->sender.ops->run_sender_for_seq =
+ sandesha2_sender_run_sender_for_seq;
+ sender_impl->sender.ops->run = sandesha2_sender_run;
+ sender_impl->sender.ops->free = sandesha2_sender_free;
+
+ return &(sender_impl->sender);
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_free(sandesha2_sender_t *sender,
+ const axis2_env_t *env)
+{
+ sandesha2_sender_impl_t *sender_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+ /* Do not free this */
+ sender_impl->conf_ctx = NULL;
+
+ if(NULL != sender_impl->mutex)
+ {
+ axis2_thread_mutex_destroy(sender_impl->mutex);
+ sender_impl->mutex = NULL;
+ }
+ if(NULL != sender_impl->working_seqs)
+ {
+ AXIS2_ARRY_LIST_FREE(sender_impl->working_seqs, env);
+ sender_impl->working_seqs = NULL;
+ }
+ if(NULL != sender->ops)
+ {
+ AXIS2_FREE(env->allocator, sender->ops);
+ sender->ops = NULL;
+ }
+ AXIS2_FREE(env->allocator, SANDESHA2_INTF_TO_IMPL(sender));
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_stop_sender_for_seq
+ (sandesha2_sender_t *sender,
+ const axis2_env_t *env, axis2_char_t *seq_id)
+{
+ sandesha2_sender_impl_t *sender_impl = NULL;
+ int i = 0;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FAILURE);
+
+ sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+ axis2_thread_mutex_lock(sender_impl->mutex);
+ for(i = 0; i < AXIS2_ARRY_LIST_SIZE(sender_impl->working_seqs, env); i++)
+ {
+ axis2_char_t *tmp_id = NULL;
+ tmp_id = AXIS2_ARRAY_LIST_GET(sender_impl->working_seqs, env, i);
+ if(0 == AXIS2_STRCMP(seq_id, tmp_id))
+ {
+ AXIS2_ARRAY_LIST_REMOVE(sender_impl->working_seqs, env, i);
+ break;
+ }
+ }
+ if(0 == AXIS2_ARRY_LIST_SIZE(sender_impl->working_seqs, env))
+ sender_impl->run_sender = AXIS2_FALSE;
+ axis2_thread_mutex_unlock(sender_impl->mutex);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_stop_sending (sandesha2_sender_t *sender,
+ const axis2_env_t *env)
+{
+ sandesha2_sender_impl_t *sender_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+ axis2_thread_mutex_lock(sender_impl->mutex);
+ SANDESHA2_INTF_TO_IMPL(sender)->run_sender = AXIS2_FALSE;
+ axis2_thread_mutex_unlock(sender_impl->mutex);
+ return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_sender_started
+ (sandesha2_sender_t *sender,
+ const axis2_env_t *env)
+{
+ axis2_bool_t started = AXIS2_FALSE;
+ sandesha2_sender_impl_t *sender_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+
+ sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+ axis2_thread_mutex_lock(sender_impl->mutex);
+ started = SANDESHA2_INTF_TO_IMPL(sender)->run_sender;
+ axis2_thread_mutex_unlock(sender_impl->mutex);
+ return started;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_run_sender_for_seq
+ (sandesha2_sender_t *sender,
+ const axis2_env_t *env, axis2_conf_ctx_t *conf_ctx,
+ axis2_char_t *seq_id)
+{
+ sandesha2_sender_impl_t *sender_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);
+
+ sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+ axis2_thread_mutex_lock(sender_impl->mutex);
+ if(AXIS2_FALSE == sandesha2_utils_array_list_contains(env,
+ sender_impl->working_seqs, seq_id))
+ AXIS2_ARRY_LIST_ADD(sender_impl->working_seqs, env, seq_id);
+ if(AXIS2_FALSE == sender_impl->run_sender)
+ {
+ sender_impl->conf_ctx = conf_ctx;
+ sender_impl->run_sender = AXIS2_TRUE;
+ sandesha2_sender_run(sender, env);
+ }
+ axis2_thread_mutex_unlock(sender_impl->mutex);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_run (sandesha2_sender_t *sender,
+ const axis2_env_t *env)
+{
+ sandesha2_sender_impl_t *sender_impl = NULL;
+ axis2_thread_t *worker_thread = NULL;
+ sandesha2_sender_args_t args;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+ args.impl = sender_impl;
+ args.env = (axis2_env_t*)env;
+ worker_thread = AXIS2_THREAD_POOL_GET_THREAD(env->thread_pool,
+ sandesha2_sender_worker_func, (void*)&args);
+ if(NULL == worker_thread)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]Thread creation "
+ "failed sandesha2_sender_run");
+ return AXIS2_FAILURE;
+ }
+ AXIS2_THREAD_POOL_THREAD_DETACH(env->thread_pool, worker_thread);
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_sender_check_for_sync_res(
+ sandesha2_sender_t *sender,
+ 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_MSG_CTX_GET_PROPERTY(msg_ctx, env, AXIS2_TRANSPORT_IN,
+ AXIS2_FALSE);
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_piggybackable_msg_type(
+ sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ int msg_type)
+{
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+
+ return AXIS2_FALSE;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_ack_already_piggybacked(
+ sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ sandesha2_msg_ctx_t *rm_msg_ctx)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
+
+
+ return AXIS2_FALSE;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_sender_is_fault_envelope(
+ sandesha2_sender_t *sender,
+ const axis2_env_t *env,
+ axiom_soap_envelope_t *soap_envelope)
+{
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, soap_envelope, AXIS2_FAILURE);
+
+
+ return AXIS2_FALSE;
+}
+
+/**
+ * Thread worker function.
+ */
+void * AXIS2_THREAD_FUNC
+sandesha2_sender_worker_func(axis2_thread_t *thd, void *data)
+{
+ sandesha2_sender_impl_t *sender_impl = NULL;
+ sandesha2_sender_t *sender = NULL;
+ sandesha2_sender_args_t *args;
+ axis2_env_t *env = NULL;
+
+ args = (sandesha2_sender_args_t*)data;
+ env = args->env;
+ sender_impl = args->impl;
+ sender = (sandesha2_sender_t*)sender_impl;
+
+ while(AXIS2_TRUE == sender_impl->run_sender)
+ {
+ sandesha2_transaction_t *transaction = NULL;
+ /* Use when transaction handling is done
+ axis2_bool_t rollbacked = AXIS2_FALSE;*/
+ sandesha2_storage_mgr_t *storage_mgr = NULL;
+ sandesha2_next_msg_mgr_t *next_msg_mgr = NULL;
+ sandesha2_sender_mgr_t *storage_map_mgr = NULL;
+ sandesha2_seq_property_mgr_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_mgr = sandesha2_utils_get_storage_mgr(env,
+ sender_impl->conf_ctx,
+ AXIS2_CONF_CTX_GET_CONF(sender_impl->conf_ctx, env));
+ next_msg_mgr = SANDESHA2_STORAGE_MGR_GET_NEXT_MSG_MGR(
+ storage_mgr, env);
+ storage_map_mgr = SANDESHA2_STORAGE_MGR_GET_STORAGE_MAP_MGR
+ (storage_mgr, env);
+ seq_prop_mgr = SANDESHA2_STORAGE_MGR_GET_SEQ_PROPERTY_MGR(
+ storage_mgr, env);
+ transaction = SANDESHA2_STORAGE_MGR_GET_TRANSACTION(storage_mgr,
+ env);
+ all_seq_bean = SANDESHA2_SEQ_PROPERTY_MGR_RETRIEVE(seq_prop_mgr,
+ env, SANDESHA2_SEQ_PROP_ALL_SEQS,
+ SANDESHA2_SEQ_PROP_INCOMING_SEQ_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_sender_bean_t *find_bean = NULL;
+ axis2_bool_t invoked = AXIS2_FALSE;
+ int j = 0;
+ axis2_bool_t continue_seq = AXIS2_TRUE;
+
+ seq_id = AXIS2_ARRAY_LIST_GET(all_seq_list, env, i);
+ SANDESHA2_TRANSACTION_COMMIT(transaction, env);
+ transaction = SANDESHA2_STORAGE_MGR_GET_TRANSACTION(
+ storage_mgr, env);
+ next_msg_bean = SANDESHA2_NEXT_MSG_MGR_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_ARRAY_LIST_STRING);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(all_seq_bean, env,
+ str_list);
+ SANDESHA2_SEQ_PROPERTY_MGR_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_sender_bean_create_with_data(env, NULL,
+ next_msg_no, seq_id, AXIS2_FALSE);*/
+ st_map_list = SANDESHA2_INVOKER_MGR_FIND(storage_map_mgr,
+ env, find_bean);
+ for(j = 0; j < AXIS2_ARRAY_LIST_SIZE(st_map_list, env); j++)
+ {
+ sandesha2_sender_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_KEY(st_map_bean,
+ env);
+ msg_to_invoke = SANDESHA2_STORAGE_MGR_RETRIEVE_MSG_CTX(
+ storage_mgr, env, key, sender_impl->conf_ctx);
+ rm_msg_ctx = sandesha2_msg_initilizer_init_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, sender_impl->conf_ctx);
+ if(AXIS2_TRUE == post_failure_invocation)
+ {
+ sandesha2_sender_make_msg_ready_for_reinjection(
+ sender, 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_MGR_GET_TRANSACTION(
+ storage_mgr, env);
+ SANDESHA2_STORAGE_MGR_DELETE(storage_mgr, env, key);
+ msg_ctx = SANDESHA2_STORAGE_MGR_RETRIEVE_MSG_CTX(
+ storage_mgr, env, key, sender_impl->conf_ctx);
+ if(NULL != msg_ctx)
+ SANDESHA2_STORAGE_MGR_REMOVE_MSG_CTX(storage_mgr,
+ env, key);
+ if(SANDESHA2_MSG_TYPE_APPLICATION ==
+ SANDESHA2_MSG_CTX_GET_MSG_TYPE(rm_msg_ctx, env))
+ {
+ sandesha2_seq_t *seq = NULL;
+ seq = (sandesha2_seq_t*)_MSG_CTX_GET_MSG_PART(
+ rm_msg_ctx, env, SANDESHA2_MSG_PART_SEQ);
+ if(NULL != SANDESHA2_SEQ_GET_LAST_MSG(seq, env))
+ {
+ sandesha2_terminate_mgr_clean_recv_side_after_invocation(
+ env, sender_impl->conf_ctx, seq_id,
+ storage_mgr);
+ /* we are done with current seq */
+ continue_seq = AXIS2_FALSE;
+ break;
+ }
+ }
+ }
+ if(AXIS2_FALSE == continue_seq)
+ 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_MGR_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