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 da...@apache.org on 2006/12/07 05:26:55 UTC
svn commit: r483342 [3/5] - in /webservices/sandesha/trunk/c: ./ config/
include/ samples/ samples/RMSampleService/ samples/rm_echo/
samples/rm_ping/ src/ src/client/ src/core/ src/handlers/
src/msgprocessors/ src/polling/ src/util/ src/workers/ src/wsrm/
Modified: webservices/sandesha/trunk/c/src/msgprocessors/app_msg_processor.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/app_msg_processor.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/app_msg_processor.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/app_msg_processor.c Wed Dec 6 20:26:47 2006
@@ -33,6 +33,10 @@
#include <sandesha2_constants.h>
#include <sandesha2_utils.h>
#include <sandesha2_msg_ctx.h>
+#include <sandesha2_create_seq_mgr.h>
+#include <sandesha2_sender_mgr.h>
+#include <sandesha2_sender_bean.h>
+
#include <axis2_msg_ctx.h>
#include <axis2_string.h>
#include <axis2_engine.h>
@@ -204,18 +208,17 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log,
- "[sandesha2] sandesha2_app_msg_processor_process_in_msg .........");
- printf("sandesha2_app_msg_processor_process_in_msg\n");
+ "[sandesha2] sandesha2_app_msg_processor_process_in_msg .........");
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
if(!msg_ctx)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_MSG_CTX,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
property = sandesha2_msg_ctx_get_property(rm_msg_ctx, env,
- SANDESHA2_APPLICATION_PROCESSING_DONE);
+ SANDESHA2_APPLICATION_PROCESSING_DONE);
if(property)
{
@@ -239,42 +242,41 @@
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, value);
AXIS2_CTX_SET_PROPERTY(ctx, env, AXIS2_RESPONSE_WRITTEN,
- property, AXIS2_FALSE);
+ property, AXIS2_FALSE);
}
}
conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
storage_mgr = sandesha2_utils_get_storage_mgr(env, conf_ctx,
- AXIS2_CONF_CTX_GET_CONF(conf_ctx, env));
+ AXIS2_CONF_CTX_GET_CONF(conf_ctx, env));
fault_ctx = sandesha2_fault_mgr_check_for_last_msg_num_exceeded(
- env, rm_msg_ctx, storage_mgr);
+ env, rm_msg_ctx, storage_mgr);
if(fault_ctx)
{
axis2_engine_t *engine = axis2_engine_create(env, conf_ctx);
- if(AXIS2_FAILURE == AXIS2_ENGINE_SEND_FAULT(engine, env,
- sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)))
+ if(!AXIS2_ENGINE_SEND_FAULT(engine, env,
+ sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)))
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_FAULT,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
AXIS2_MSG_CTX_SET_PAUSED(msg_ctx, env, AXIS2_TRUE);
return AXIS2_SUCCESS;
}
seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(
- storage_mgr, env);
+ storage_mgr, env);
seq = (sandesha2_seq_t*)sandesha2_msg_ctx_get_msg_part(rm_msg_ctx, env,
- SANDESHA2_MSG_PART_SEQ);
+ SANDESHA2_MSG_PART_SEQ);
sandesha2_seq_set_must_understand(seq, env, AXIS2_FALSE);
str_seq_id = sandesha2_identifier_get_identifier(
- sandesha2_seq_get_identifier(seq, env), env);
- AXIS2_LOG_INFO(env->log, "[sandesha2] str_seq_id :%s.........", str_seq_id);
+ sandesha2_seq_get_identifier(seq, env), env);
fault_ctx = sandesha2_fault_mgr_check_for_unknown_seq(env,rm_msg_ctx,
- str_seq_id, storage_mgr);
+ str_seq_id, storage_mgr);
if(fault_ctx)
{
axis2_engine_t *engine = axis2_engine_create(env, conf_ctx);
- if(AXIS2_FAILURE == AXIS2_ENGINE_SEND_FAULT(engine, env,
- sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)))
+ if(!AXIS2_ENGINE_SEND_FAULT(engine, env,
+ sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)))
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_FAULT,
AXIS2_FAILURE);
@@ -290,34 +292,34 @@
if(fault_ctx)
{
axis2_engine_t *engine = axis2_engine_create(env, conf_ctx);
- if(AXIS2_FAILURE == AXIS2_ENGINE_SEND_FAULT(engine, env,
- sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)))
+ if(!AXIS2_ENGINE_SEND_FAULT(engine, env,
+ sandesha2_msg_ctx_get_msg_ctx(fault_ctx, env)))
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_FAULT,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
AXIS2_MSG_CTX_SET_PAUSED(msg_ctx, env, AXIS2_TRUE);
return AXIS2_SUCCESS;
}
sandesha2_seq_mgr_update_last_activated_time(env, str_seq_id,
- storage_mgr);
+ storage_mgr);
msgs_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
- str_seq_id,
- SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES);
+ str_seq_id,
+ SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES);
msg_no = SANDESHA2_MSG_NUMBER_GET_MSG_NUM(sandesha2_seq_get_msg_num(
- seq, env), env);
+ seq, env), env);
if(0 == msg_no)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_MSG_NUM,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
str_key = axis2_uuid_gen(env);
highest_in_msg_no_str = sandesha2_utils_get_seq_property(env, str_seq_id,
- SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_NUMBER, storage_mgr);
+ SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_NUMBER, storage_mgr);
highest_in_msg_key_str = sandesha2_utils_get_seq_property(env, str_seq_id,
- SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_KEY, storage_mgr);
+ SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_KEY, storage_mgr);
if(!highest_in_msg_key_str)
{
highest_in_msg_key_str = axis2_uuid_gen(env);
@@ -335,28 +337,28 @@
highest_in_msg_no = msg_no;
highest_msg_no_bean = sandesha2_seq_property_bean_create_with_data(env,
- str_seq_id, SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_NUMBER,
- msg_num_str);
+ str_seq_id, SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_NUMBER,
+ msg_num_str);
highest_msg_key_bean = sandesha2_seq_property_bean_create_with_data(env,
- str_seq_id, SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_KEY,
- highest_in_msg_key_str);
+ str_seq_id, SANDESHA2_SEQ_PROP_HIGHEST_IN_MSG_KEY,
+ highest_in_msg_key_str);
sandesha2_storage_mgr_remove_msg_ctx(storage_mgr, env,
- highest_in_msg_key_str);
+ highest_in_msg_key_str);
sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env,
- highest_in_msg_key_str, msg_ctx);
+ highest_in_msg_key_str, msg_ctx);
if(highest_in_msg_no_str)
{
sandesha2_seq_property_mgr_update(seq_prop_mgr, env,
- highest_msg_no_bean);
+ highest_msg_no_bean);
sandesha2_seq_property_mgr_update(seq_prop_mgr, env,
- highest_msg_key_bean);
+ highest_msg_key_bean);
}
else
{
sandesha2_seq_property_mgr_insert(seq_prop_mgr, env,
- highest_msg_no_bean);
+ highest_msg_no_bean);
sandesha2_seq_property_mgr_insert(seq_prop_mgr, env,
- highest_msg_key_bean);
+ highest_msg_key_bean);
}
}
@@ -369,14 +371,14 @@
msgs_bean = sandesha2_seq_property_bean_create(env);
sandesha2_seq_property_bean_set_seq_id(msgs_bean, env, str_seq_id);
sandesha2_seq_property_bean_set_name(msgs_bean, env,
- SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES);
+ SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES);
sandesha2_seq_property_bean_set_value(msgs_bean, env, msgs_str);
}
msg_no_present_in_list = sandesha2_app_msg_processor_msg_num_is_in_list(env,
- msgs_str, msg_no);
+ msgs_str, msg_no);
if(msg_no_present_in_list &&
- 0 == AXIS2_STRCMP(SANDESHA2_QOS_DEFAULT_INVOCATION_TYPE,
- SANDESHA2_QOS_EXACTLY_ONCE))
+ 0 == AXIS2_STRCMP(SANDESHA2_QOS_DEFAULT_INVOCATION_TYPE,
+ SANDESHA2_QOS_EXACTLY_ONCE))
{
sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE);
}
@@ -391,21 +393,21 @@
}
next_mgr = sandesha2_storage_mgr_get_next_msg_mgr(storage_mgr,
- env);
+ env);
next_msg_bean = sandesha2_next_msg_mgr_retrieve(next_mgr, env,
- str_seq_id);
+ str_seq_id);
if(!next_msg_bean)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SEQ_NOT_EXIST,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
storage_map_mgr = sandesha2_storage_mgr_get_storage_map_mgr(
- storage_mgr, env);
+ storage_mgr, env);
in_order_invoke = sandesha2_property_bean_is_in_order(
- sandesha2_utils_get_property_bean(env,
- AXIS2_CONF_CTX_GET_CONF(conf_ctx, env)), env);
- if(in_order_invoke)
+ sandesha2_utils_get_property_bean(env,
+ AXIS2_CONF_CTX_GET_CONF(conf_ctx, env)), env);
+ if(AXIS2_MSG_CTX_GET_SERVER_SIDE(msg_ctx, env) && in_order_invoke)
{
sandesha2_seq_property_bean_t *incoming_seq_list_bean = NULL;
axis2_array_list_t *incoming_seq_list = NULL;
@@ -480,7 +482,7 @@
AXIS2_MSG_CTX_SET_PAUSED(msg_ctx, env, AXIS2_FALSE);
}*/
AXIS2_LOG_INFO(env->log,
- "[sandesha2] Exit: sandesha2_app_msg_processor_process_in_msg");
+ "[sandesha2] Exit: sandesha2_app_msg_processor_process_in_msg");
return AXIS2_SUCCESS;
}
@@ -522,7 +524,6 @@
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] sandesha2_app_msg_processor_process_out_msg .........");
- printf("sandesha2_app_msg_processor_process_out_msg\n");
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
@@ -539,11 +540,11 @@
to_epr = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
if(!to_epr || !AXIS2_ENDPOINT_REF_GET_ADDRESS(to_epr, env)
- || 0 == AXIS2_STRLEN(AXIS2_ENDPOINT_REF_GET_ADDRESS(
- to_epr, env)))
+ || 0 == AXIS2_STRLEN(AXIS2_ENDPOINT_REF_GET_ADDRESS(
+ to_epr, env)))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "to epr is not set - a"
- "requirement in sandesha client side");
+ "requirement in sandesha client side");
return AXIS2_FAILURE;
}
@@ -561,7 +562,7 @@
req_rm_msg_ctx = sandesha2_msg_init_init_msg(env, req_msg_ctx);
req_seq = (sandesha2_seq_t *) sandesha2_msg_ctx_get_msg_part(
- req_rm_msg_ctx, env, SANDESHA2_MSG_PART_SEQ);
+ req_rm_msg_ctx, env, SANDESHA2_MSG_PART_SEQ);
if(!req_seq)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sequence is NULL");
@@ -598,19 +599,18 @@
to = (axis2_char_t*)AXIS2_ENDPOINT_REF_GET_ADDRESS(to_epr, env);
property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- SANDESHA2_CLIENT_SEQ_KEY, AXIS2_FALSE);
+ SANDESHA2_CLIENT_SEQ_KEY, AXIS2_FALSE);
if(property)
seq_key = AXIS2_PROPERTY_GET_VALUE(property, env);
internal_seq_id = sandesha2_utils_get_internal_seq_id(env,
- to, seq_key);
+ to, seq_key);
property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
- SANDESHA2_CLIENT_LAST_MESSAGE, AXIS2_FALSE);
+ SANDESHA2_CLIENT_LAST_MESSAGE, AXIS2_FALSE);
if(property)
last_app_msg = AXIS2_PROPERTY_GET_VALUE(property, env);
- printf("last_app_msg:%s######################################\n", last_app_msg);
- if(last_app_msg && 0 == AXIS2_STRCMP(last_app_msg,
- SANDESHA2_VALUE_TRUE))
- last_msg = AXIS2_TRUE;
+ if(last_app_msg && 0 == AXIS2_STRCMP(last_app_msg,
+ SANDESHA2_VALUE_TRUE))
+ last_msg = AXIS2_TRUE;
}
property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
SANDESHA2_CLIENT_MESSAGE_NUMBER, AXIS2_FALSE);
@@ -661,7 +661,6 @@
msg_number_str);
sandesha2_seq_property_mgr_insert(seq_prop_mgr, env,
res_highest_msg_bean);
- printf("last_msg:%d########################################\n", last_msg);
if(last_msg)
{
sandesha2_seq_property_bean_t *res_highest_msg_key_bean = NULL;
@@ -671,7 +670,6 @@
env, internal_seq_id,
SANDESHA2_SEQ_PROP_HIGHEST_OUT_MSG_KEY,
storage_key);
- printf("internal_seq_id########################################:%s\n", internal_seq_id);
res_last_msg_key_bean = sandesha2_seq_property_bean_create_with_data(
env, internal_seq_id,
SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NO,
@@ -740,8 +738,8 @@
{
if(!out_seq_bean)
send_create_seq = AXIS2_TRUE;
- sandesha2_seq_mgr_setup_new_client_seq(env, msg_ctx,
- internal_seq_id, spec_ver, storage_mgr);
+ sandesha2_seq_mgr_setup_new_client_seq(env, msg_ctx, internal_seq_id,
+ spec_ver, storage_mgr);
}
if(send_create_seq)
{
@@ -770,7 +768,7 @@
{
property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
SANDESHA2_CLIENT_ACKS_TO, AXIS2_FALSE);
- if(NULL != property)
+ if(property)
acks_to = AXIS2_PROPERTY_GET_VALUE(property, env);
}
if(is_svr_side)
@@ -893,7 +891,7 @@
AXIS2_PARAM_CHECK(env->error, list, AXIS2_FALSE);
sprintf(str_long, "%ld", num);
- if(NULL != strstr(list, str_long))
+ if(strstr(list, str_long))
return AXIS2_TRUE;
return AXIS2_FALSE;
@@ -914,33 +912,34 @@
sandesha2_msg_ctx_t *ack_rm_msg = NULL;
axis2_engine_t *engine = NULL;
axis2_msg_ctx_t *msg_ctx = NULL;
+ axis2_msg_ctx_t *temp_msg_ctx = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, msg_str, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, mgr, AXIS2_FAILURE);
-
+ temp_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
seq = (sandesha2_seq_t*)sandesha2_msg_ctx_get_msg_part(rm_msg_ctx, env,
- SANDESHA2_MSG_PART_SEQ);
+ SANDESHA2_MSG_PART_SEQ);
seq_id = sandesha2_identifier_get_identifier(
- sandesha2_seq_get_identifier(seq, env), env);
+ sandesha2_seq_get_identifier(seq, env), env);
conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx,
- env), env);
+ env), env);
if(!conf_ctx)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_CONF_CTX_NULL, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
ack_requested = (sandesha2_ack_requested_t*)sandesha2_msg_ctx_get_msg_part(
- rm_msg_ctx, env, SANDESHA2_MSG_PART_ACK_REQUEST);
+ rm_msg_ctx, env, SANDESHA2_MSG_PART_ACK_REQUEST);
if(ack_requested)
{
sandesha2_ack_requested_set_must_understand(ack_requested, env,
- AXIS2_FALSE);
+ AXIS2_FALSE);
sandesha2_msg_ctx_add_soap_envelope(rm_msg_ctx, env);
}
ack_rm_msg = sandesha2_ack_mgr_generate_ack_msg(env, rm_msg_ctx, seq_id,
- mgr);
+ mgr);
engine = axis2_engine_create(env, conf_ctx);
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(ack_rm_msg, env);
if(AXIS2_SUCCESS != AXIS2_ENGINE_SEND(engine, env, msg_ctx))
@@ -957,7 +956,7 @@
sandesha2_msg_ctx_t *rm_msg_ctx,
axis2_char_t *internal_seq_id,
axis2_char_t *acks_to,
- sandesha2_storage_mgr_t *mgr)
+ sandesha2_storage_mgr_t *storage_mgr)
{
axis2_msg_ctx_t *msg_ctx = NULL;
sandesha2_create_seq_t *create_seq_part = NULL;
@@ -978,58 +977,65 @@
axis2_engine_t *engine = NULL;
axis2_property_t *property = NULL;
axis2_char_t *msg_id = NULL;
+ axis2_char_t *create_seq_msg_store_key = NULL;
+ axis2_char_t *ref_msg_store_key = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, internal_seq_id, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, acks_to, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->error, mgr, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, storage_mgr, AXIS2_FAILURE);
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
create_seq_rm_msg = sandesha2_msg_creator_create_create_seq_msg(env,
- rm_msg_ctx, internal_seq_id, acks_to, mgr);
+ rm_msg_ctx, internal_seq_id, acks_to, storage_mgr);
sandesha2_msg_ctx_set_flow(create_seq_rm_msg, env,
- SANDESHA2_MSG_CTX_OUT_FLOW);
+ SANDESHA2_MSG_CTX_OUT_FLOW);
create_seq_part = (sandesha2_create_seq_t*)sandesha2_msg_ctx_get_msg_part(
- create_seq_rm_msg, env, SANDESHA2_MSG_PART_CREATE_SEQ);
+ create_seq_rm_msg, env, SANDESHA2_MSG_PART_CREATE_SEQ);
seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(
- mgr, env);
+ storage_mgr, env);
create_seq_man = sandesha2_storage_mgr_get_create_seq_mgr(
- mgr, env);
- retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr(mgr, env);
+ storage_mgr, env);
+ retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr(storage_mgr, env);
seq_offer = sandesha2_create_seq_get_seq_offer(create_seq_part, env);
- if(NULL != seq_offer)
+ if(seq_offer)
{
axis2_char_t *seq_offer_id = NULL;
sandesha2_seq_property_bean_t *offer_seq_bean = NULL;
seq_offer_id = sandesha2_identifier_get_identifier(
- sandesha2_seq_offer_get_identifier(seq_offer, env),
- env);
+ sandesha2_seq_offer_get_identifier(seq_offer, env), env);
offer_seq_bean = sandesha2_seq_property_bean_create(env);
sandesha2_seq_property_bean_set_name(offer_seq_bean, env,
- SANDESHA2_SEQ_PROP_OFFERED_SEQ);
+ SANDESHA2_SEQ_PROP_OFFERED_SEQ);
sandesha2_seq_property_bean_set_seq_id(offer_seq_bean, env,
- internal_seq_id);
+ internal_seq_id);
sandesha2_seq_property_bean_set_value(offer_seq_bean, env,
- seq_offer_id);
+ seq_offer_id);
sandesha2_seq_property_mgr_insert(seq_prop_mgr, env,
- offer_seq_bean);
+ offer_seq_bean);
}
create_seq_msg = sandesha2_msg_ctx_get_msg_ctx(create_seq_rm_msg, env);
AXIS2_MSG_CTX_SET_RELATES_TO(create_seq_msg, env, NULL);
-
create_seq_bean = sandesha2_create_seq_bean_create_with_data(env,
- internal_seq_id, (axis2_char_t*)AXIS2_MSG_CTX_GET_WSA_MESSAGE_ID(
- create_seq_msg, env), NULL);
- SANDESHA2_CREATE_SEQ_MGR_INSERT(create_seq_man, env,
- create_seq_bean);
+ internal_seq_id, (axis2_char_t*)AXIS2_MSG_CTX_GET_WSA_MESSAGE_ID(
+ create_seq_msg, env), NULL);
+ create_seq_msg_store_key = axis2_uuid_gen(env);
+ sandesha2_create_seq_bean_set_create_seq_msg_store_key(create_seq_bean, env,
+ create_seq_msg_store_key);
+ /* Storing the create_seq_msg_ctx as a reference */
+ ref_msg_store_key = axis2_uuid_gen(env);
+ sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env, ref_msg_store_key,
+ create_seq_msg);
+ sandesha2_create_seq_bean_set_ref_msg_store_key(create_seq_bean, env,
+ ref_msg_store_key);
+ SANDESHA2_CREATE_SEQ_MGR_INSERT(create_seq_man, env, create_seq_bean);
addr_ns_uri = sandesha2_utils_get_seq_property(env, internal_seq_id,
- SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE,
- mgr);
+ SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE, storage_mgr);
anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_uri);
- if(NULL == AXIS2_MSG_CTX_GET_REPLY_TO(create_seq_msg, env))
+ if(!AXIS2_MSG_CTX_GET_REPLY_TO(create_seq_msg, env))
{
axis2_endpoint_ref_t *cs_epr = NULL;
cs_epr = axis2_endpoint_ref_create(env, anon_uri);
@@ -1037,31 +1043,29 @@
}
str_key = axis2_uuid_gen(env);
create_seq_entry = sandesha2_sender_bean_create(env);
- sandesha2_sender_bean_set_msg_ctx_ref_key(create_seq_entry, env,
- str_key);
+ sandesha2_sender_bean_set_msg_ctx_ref_key(create_seq_entry, env, str_key);
millisecs = sandesha2_utils_get_current_time_in_millis(env);
sandesha2_sender_bean_set_time_to_send(create_seq_entry, env, millisecs);
msg_id = sandesha2_msg_ctx_get_msg_id(create_seq_rm_msg, env);
sandesha2_sender_bean_set_msg_id(create_seq_entry, env, msg_id);
sandesha2_sender_bean_set_internal_seq_id(create_seq_entry, env,
- internal_seq_id);
+ internal_seq_id);
sandesha2_sender_bean_set_send(create_seq_entry, 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_FALSE,
- env));
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(SANDESHA2_VALUE_FALSE,
+ env));
AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
- SANDESHA2_QUALIFIED_FOR_SENDING, property,
- AXIS2_FALSE);
+ SANDESHA2_QUALIFIED_FOR_SENDING, property, AXIS2_FALSE);
sandesha2_sender_bean_set_msg_type(create_seq_entry, env,
- SANDESHA2_MSG_TYPE_CREATE_SEQ);
+ SANDESHA2_MSG_TYPE_CREATE_SEQ);
sandesha2_sender_mgr_insert(retrans_mgr, env, create_seq_entry);
- sandesha2_storage_mgr_store_msg_ctx(mgr, env, str_key, create_seq_msg);
+ sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env, str_key, create_seq_msg);
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(str_key, env));
AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env, SANDESHA2_MESSAGE_STORE_KEY,
- property, AXIS2_FALSE);
+ property, AXIS2_FALSE);
orig_trans_out = AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(create_seq_msg, env);
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
@@ -1069,19 +1073,17 @@
AXIS2_PROPERTY_SET_FREE_FUNC(property, env,
orig_trans_out->ops->free_void_arg);
AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
- SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property,
- AXIS2_FALSE);
+ SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property, AXIS2_FALSE);
trans_out = sandesha2_utils_get_transport_out(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_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, SANDESHA2_VALUE_TRUE);
AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env, SANDESHA2_SET_SEND_TO_TRUE,
- property, AXIS2_FALSE);
+ property, AXIS2_FALSE);
AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(create_seq_msg, env, trans_out);
engine = axis2_engine_create(env, AXIS2_MSG_CTX_GET_CONF_CTX(create_seq_msg,
- env));
- if(AXIS2_FAILURE == AXIS2_ENGINE_RESUME_SEND(engine, env, create_seq_msg))
+ env));
+ if(!AXIS2_ENGINE_RESUME_SEND(engine, env, create_seq_msg))
return AXIS2_FAILURE;
return AXIS2_SUCCESS;
@@ -1127,17 +1129,14 @@
AXIS2_PARAM_CHECK(env->error, mgr, AXIS2_FAILURE);
app_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
-
- seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(
- mgr, env);
- retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr
- (mgr, env);
+ seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(mgr, env);
+ retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr(mgr, env);
to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
- internal_seq_id, SANDESHA2_SEQ_PROP_TO_EPR);
+ internal_seq_id, SANDESHA2_SEQ_PROP_TO_EPR);
reply_to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
- internal_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR);
+ internal_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR);
out_seq_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
- internal_seq_id, SANDESHA2_SEQ_PROP_OUT_SEQ_ID);
+ internal_seq_id, SANDESHA2_SEQ_PROP_OUT_SEQ_ID);
if(!to_bean)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] To is NULL");
@@ -1145,37 +1144,36 @@
return AXIS2_FAILURE;
}
to_epr = axis2_endpoint_ref_create(env,
- sandesha2_seq_property_bean_get_value(to_bean, env));
+ sandesha2_seq_property_bean_get_value(to_bean, env));
if(reply_to_bean)
reply_to_epr = axis2_endpoint_ref_create(env,
- sandesha2_seq_property_bean_get_value(reply_to_bean,
- env));
+ sandesha2_seq_property_bean_get_value(reply_to_bean, env));
if(AXIS2_MSG_CTX_GET_SERVER_SIDE(app_msg_ctx, env))
{
axis2_endpoint_ref_t *reply_to = NULL;
req_msg = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(app_msg_ctx, env),
- env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
+ env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
if(req_msg)
{
reply_to = AXIS2_MSG_CTX_GET_REPLY_TO(req_msg, env);
}
if(reply_to)
new_to_str = (axis2_char_t*)AXIS2_ENDPOINT_REF_GET_ADDRESS(
- reply_to, env);
+ reply_to, env);
}
- if(NULL != new_to_str)
+ if(new_to_str)
sandesha2_msg_ctx_set_to(rm_msg_ctx, env, axis2_endpoint_ref_create(env,
- new_to_str));
+ new_to_str));
else
sandesha2_msg_ctx_set_to(rm_msg_ctx, env, to_epr);
- if(NULL != reply_to_epr)
+ if(reply_to_epr)
sandesha2_msg_ctx_set_reply_to(rm_msg_ctx, env, reply_to_epr);
rm_version = sandesha2_utils_get_rm_version(env, internal_seq_id, mgr);
- if(NULL == rm_version)
+ if(!rm_version)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to fine RM spec version");
return AXIS2_FAILURE;
@@ -1187,25 +1185,24 @@
SANDESHA2_MSG_NUMBER_SET_MSG_NUM(msg_number, env, msg_num);
sandesha2_seq_set_msg_num(seq, env, msg_number);
- if(AXIS2_TRUE == AXIS2_MSG_CTX_GET_SERVER_SIDE(app_msg_ctx, env))
+ if(AXIS2_MSG_CTX_GET_SERVER_SIDE(app_msg_ctx, env))
{
sandesha2_msg_ctx_t *req_rm_msg = NULL;
req_rm_msg = sandesha2_msg_init_init_msg(env, req_msg);
req_seq = (sandesha2_seq_t*)sandesha2_msg_ctx_get_msg_part(req_rm_msg,
- env, SANDESHA2_MSG_PART_SEQ);
- if(NULL == req_seq)
+ env, SANDESHA2_MSG_PART_SEQ);
+ if(!req_seq)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sequence not found");
- AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_SEQ,
- AXIS2_FAILURE);
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_SEQ, AXIS2_FAILURE);
return AXIS2_FAILURE;
}
- if(NULL != sandesha2_seq_get_last_msg(req_seq, env))
+ if(sandesha2_seq_get_last_msg(req_seq, env))
{
last_msg = AXIS2_TRUE;
sandesha2_seq_set_last_msg(seq, env,
- sandesha2_last_msg_create(env, rm_ns_val));
+ sandesha2_last_msg_create(env, rm_ns_val));
}
}
else
@@ -1214,22 +1211,20 @@
axis2_property_t *property = NULL;
op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(app_msg_ctx, env);
- if(NULL != op_ctx)
+ if(op_ctx)
{
property = AXIS2_MSG_CTX_GET_PROPERTY(app_msg_ctx, env,
- SANDESHA2_CLIENT_LAST_MESSAGE, AXIS2_FALSE);
- if(NULL != property)
+ SANDESHA2_CLIENT_LAST_MESSAGE, AXIS2_FALSE);
+ if(property)
{
axis2_char_t *value = AXIS2_PROPERTY_GET_VALUE(property, env);
- if(NULL != value && 0 == AXIS2_STRCMP(value,
- SANDESHA2_VALUE_TRUE))
+ if(value && 0 == AXIS2_STRCMP(value, SANDESHA2_VALUE_TRUE))
{
axis2_char_t *spec_ver = NULL;
spec_ver = sandesha2_utils_get_rm_version(env,
internal_seq_id, mgr);
last_msg = AXIS2_TRUE;
- if(AXIS2_TRUE ==
- sandesha2_spec_specific_consts_is_last_msg_indicator_reqd
+ if(sandesha2_spec_specific_consts_is_last_msg_indicator_reqd
(env, spec_ver))
{
sandesha2_seq_set_last_msg(seq, env,
@@ -1239,8 +1234,8 @@
}
}
}
- if(!out_seq_bean || !sandesha2_seq_property_bean_get_value(
- out_seq_bean, env))
+ if(!out_seq_bean || !sandesha2_seq_property_bean_get_value(out_seq_bean,
+ env))
str_identifier = SANDESHA2_TEMP_SEQ_ID;
else
str_identifier = sandesha2_seq_property_bean_get_value(out_seq_bean, env);
@@ -1249,21 +1244,21 @@
sandesha2_identifier_set_identifier(identifier, env, str_identifier);
sandesha2_seq_set_identifier(seq, env, identifier);
sandesha2_msg_ctx_set_msg_part(rm_msg_ctx, env, SANDESHA2_MSG_PART_SEQ,
- (sandesha2_iom_rm_part_t*)seq);
+ (sandesha2_iom_rm_part_t*)seq);
/* TODO add_ack_requested */
sandesha2_msg_ctx_add_soap_envelope(rm_msg_ctx, env);
app_msg_entry = sandesha2_sender_bean_create(env);
sandesha2_sender_bean_set_msg_ctx_ref_key(app_msg_entry, env,
- storage_key);
+ storage_key);
millisecs = sandesha2_utils_get_current_time_in_millis(env);
sandesha2_sender_bean_set_time_to_send(app_msg_entry, env, millisecs);
msg_id = sandesha2_msg_ctx_get_msg_id(rm_msg_ctx, env);
sandesha2_sender_bean_set_msg_id(app_msg_entry, env, msg_id);
sandesha2_sender_bean_set_msg_no(app_msg_entry, env, msg_num);
sandesha2_sender_bean_set_msg_type(app_msg_entry, env,
- SANDESHA2_MSG_TYPE_APPLICATION);
- if(!out_seq_bean || !sandesha2_seq_property_bean_get_value(
- out_seq_bean, env))
+ SANDESHA2_MSG_TYPE_APPLICATION);
+ if(!out_seq_bean || !sandesha2_seq_property_bean_get_value(out_seq_bean,
+ env))
{
sandesha2_sender_bean_set_send(app_msg_entry, env, AXIS2_FALSE);
}
@@ -1273,9 +1268,9 @@
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));
+ SANDESHA2_VALUE_TRUE, env));
AXIS2_MSG_CTX_SET_PROPERTY(app_msg_ctx, env,
- SANDESHA2_SET_SEND_TO_TRUE, property, AXIS2_FALSE);
+ SANDESHA2_SET_SEND_TO_TRUE, property, AXIS2_FALSE);
}
sandesha2_sender_bean_set_internal_seq_id(app_msg_entry, env, internal_seq_id);
sandesha2_storage_mgr_store_msg_ctx(mgr, env, storage_key, app_msg_ctx);
@@ -1284,12 +1279,12 @@
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(
- SANDESHA2_VALUE_FALSE, env));
+ SANDESHA2_VALUE_FALSE, env));
AXIS2_MSG_CTX_SET_PROPERTY(app_msg_ctx, env,
- SANDESHA2_QUALIFIED_FOR_SENDING, property, AXIS2_FALSE);
+ SANDESHA2_QUALIFIED_FOR_SENDING, property, AXIS2_FALSE);
trs_sender = AXIS2_TRANSPORT_OUT_DESC_GET_SENDER(
- AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(app_msg_ctx, env), env);
- if(NULL != trs_sender)
+ AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(app_msg_ctx, env), env);
+ if(trs_sender)
{
axis2_transport_out_desc_t *trans_out = NULL;
@@ -1297,7 +1292,7 @@
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(storage_key, env));
AXIS2_MSG_CTX_SET_PROPERTY(app_msg_ctx, env,
- SANDESHA2_MESSAGE_STORE_KEY, property, AXIS2_FALSE);
+ SANDESHA2_MESSAGE_STORE_KEY, property, AXIS2_FALSE);
property = axis2_property_create(env);
AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
@@ -1306,14 +1301,14 @@
trans_out->ops->free_void_arg);
AXIS2_PROPERTY_SET_VALUE(property, env, trans_out);
AXIS2_MSG_CTX_SET_PROPERTY(app_msg_ctx, env,
- SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property,
- AXIS2_FALSE);
+ SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property, AXIS2_FALSE);
AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(app_msg_ctx, env,
- sandesha2_utils_get_transport_out(env));
+ sandesha2_utils_get_transport_out(env));
}
AXIS2_MSG_CTX_SET_CURRENT_HANDLER_INDEX(app_msg_ctx, env,
- AXIS2_MSG_CTX_GET_CURRENT_HANDLER_INDEX(app_msg_ctx, env) + 1);
- engine = axis2_engine_create(env, AXIS2_MSG_CTX_GET_CONF_CTX(app_msg_ctx, env));
+ AXIS2_MSG_CTX_GET_CURRENT_HANDLER_INDEX(app_msg_ctx, env) + 1);
+ engine = axis2_engine_create(env, AXIS2_MSG_CTX_GET_CONF_CTX(app_msg_ctx,
+ env));
return AXIS2_ENGINE_RESUME_SEND(engine, env, app_msg_ctx);
}
@@ -1332,18 +1327,15 @@
AXIS2_PARAM_CHECK(env->error, internal_seq_id, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, mgr, AXIS2_FAILURE);
- seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(
- mgr, env);
+ seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(mgr, env);
next_msg_no_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr,
- env, internal_seq_id,
- SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
+ env, internal_seq_id, SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
- if(NULL != next_msg_no_bean)
+ if(next_msg_no_bean)
{
axis2_char_t *str_value = NULL;
-
str_value = sandesha2_seq_property_bean_get_value(next_msg_no_bean, env);
- if(NULL != str_value)
+ if(str_value)
{
next_msg_no = atol(str_value);
}
@@ -1370,34 +1362,30 @@
if(msg_num <= 0)
{
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_MSG_NUM,
- AXIS2_FAILURE);
+ AXIS2_FAILURE);
return AXIS2_FAILURE;
}
- seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(
- mgr, env);
- next_msg_no_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr,
- env, internal_seq_id,
- SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
- if(NULL == next_msg_no_bean)
+ seq_prop_mgr = sandesha2_storage_mgr_get_seq_property_mgr(mgr, env);
+ next_msg_no_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
+ internal_seq_id, SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
+ if(!next_msg_no_bean)
{
update = AXIS2_FALSE;
next_msg_no_bean = sandesha2_seq_property_bean_create(env);
sandesha2_seq_property_bean_set_seq_id(next_msg_no_bean, env,
- internal_seq_id);
+ internal_seq_id);
sandesha2_seq_property_bean_set_name(next_msg_no_bean, env,
- SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
+ SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
}
sprintf(str_long, "%ld", msg_num);
sandesha2_seq_property_bean_set_value(next_msg_no_bean, env, str_long);
- if(AXIS2_TRUE == update)
+ if(update)
{
- sandesha2_seq_property_mgr_update(seq_prop_mgr, env,
- next_msg_no_bean);
+ sandesha2_seq_property_mgr_update(seq_prop_mgr, env, next_msg_no_bean);
}
else
{
- sandesha2_seq_property_mgr_insert(seq_prop_mgr, env,
- next_msg_no_bean);
+ sandesha2_seq_property_mgr_insert(seq_prop_mgr, env, next_msg_no_bean);
}
return AXIS2_SUCCESS;
}
Modified: webservices/sandesha/trunk/c/src/msgprocessors/create_seq_msg_processor.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/create_seq_msg_processor.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/create_seq_msg_processor.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/create_seq_msg_processor.c Wed Dec 6 20:26:47 2006
@@ -173,7 +173,6 @@
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] sandesha2_create_seq_msg_processor_process_in_msg .........");
- printf("sandesha2_create_seq_msg_processor_process_in_msg\n");
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
create_seq_part = (sandesha2_create_seq_t*)sandesha2_msg_ctx_get_msg_part(
@@ -252,6 +251,8 @@
axis2_char_t *int_seq_id = NULL;
sandesha2_create_seq_mgr_t *create_seq_mgr = NULL;
sandesha2_seq_property_bean_t *out_seq_bean = NULL;
+
+ AXIS2_LOG_INFO(env->log, "[sandesha2] Offer Accepted .........");
create_seq_bean = sandesha2_create_seq_bean_create(env);
sandesha2_create_seq_bean_set_seq_id(create_seq_bean, env,
@@ -376,7 +377,7 @@
create_seq_mgr = sandesha2_storage_mgr_get_create_seq_mgr(storage_mgr, env);
find_bean = sandesha2_create_seq_bean_create_with_data(env, NULL, NULL,
seq_id);
- list = SANDESHA2_CREATE_SEQ_MGR_FIND(create_seq_mgr, env, find_bean);
+ list = sandesha2_create_seq_mgr_find(create_seq_mgr, env, find_bean);
/* Single char offerings are not accepted */
if(1 >= AXIS2_STRLEN(seq_id))
return AXIS2_FALSE;
Modified: webservices/sandesha/trunk/c/src/msgprocessors/create_seq_res_msg_processor.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/create_seq_res_msg_processor.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/create_seq_res_msg_processor.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/create_seq_res_msg_processor.c Wed Dec 6 20:26:47 2006
@@ -21,6 +21,9 @@
#include <sandesha2_constants.h>
#include <sandesha2_utils.h>
#include <sandesha2_msg_ctx.h>
+#include <sandesha2_seq_property_mgr.h>
+#include <sandesha2_sender_mgr.h>
+#include <sandesha2_sender_bean.h>
#include <axis2_msg_ctx.h>
#include <axis2_string.h>
#include <axis2_engine.h>
@@ -161,7 +164,7 @@
sandesha2_create_seq_res_t *csr_part = NULL;
axis2_char_t *new_out_seq_id = NULL;
axis2_relates_to_t *relates_to = NULL;
- const axis2_char_t *create_seq_msg_id = NULL;
+ axis2_char_t *create_seq_msg_id = NULL;
sandesha2_sender_mgr_t *retrans_mgr = NULL;
sandesha2_create_seq_mgr_t *create_seq_mgr = NULL;
sandesha2_create_seq_bean_t *create_seq_bean = NULL;
@@ -177,12 +180,12 @@
int i = 0, size = 0;
axis2_ctx_t *ctx = NULL;
axis2_property_t *property = NULL;
+ axis2_bool_t polling_mode = AXIS2_FALSE;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] sandesha2_create_seq_res_msg_processor_process_in_msg .........");
- printf("sandesha2_create_seq_res_msg_processor_process_in_msg\n");
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
@@ -228,10 +231,10 @@
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
- create_seq_msg_id = AXIS2_RELATES_TO_GET_VALUE(relates_to, env);
+ create_seq_msg_id = (axis2_char_t *) AXIS2_RELATES_TO_GET_VALUE(relates_to, env);
retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr(storage_mgr, env);
create_seq_mgr = sandesha2_storage_mgr_get_create_seq_mgr(storage_mgr, env);
- create_seq_bean = SANDESHA2_CREATE_SEQ_MGR_RETRIEVE(create_seq_mgr, env,
+ create_seq_bean = sandesha2_create_seq_mgr_retrieve(create_seq_mgr, env,
create_seq_msg_id);
if(!create_seq_bean)
{
@@ -291,7 +294,12 @@
sandesha2_seq_property_bean_t *addr_ver_bean = NULL;
axis2_char_t *rm_spec_ver = NULL;
axis2_char_t *addr_ns_val = NULL;
+ axis2_char_t *ref_msg_store_key = NULL;
+ axis2_char_t *new_msg_store_key = NULL;
+ axis2_msg_ctx_t *ref_msg_ctx = NULL;
+ AXIS2_LOG_INFO(env->log,
+ "[sandesha2] In Accept .........");
offerd_seq_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env,
int_seq_id, SANDESHA2_SEQ_PROP_OFFERED_SEQ);
if(!offerd_seq_bean)
@@ -316,11 +324,41 @@
next_bean = sandesha2_next_msg_bean_create(env);
sandesha2_next_msg_bean_set_seq_id(next_bean, env, offered_seq_id);
+ /*sandesha2_next_msg_bean_set_seq_id(next_bean, env, int_seq_id);*/
sandesha2_next_msg_bean_set_next_msg_no_to_process(next_bean, env, 1);
+
+ rm_spec_ver = sandesha2_msg_ctx_get_rm_spec_ver(rm_msg_ctx, env);
+ if(0 == AXIS2_STRCMP(SANDESHA2_SPEC_VERSION_1_1, rm_spec_ver))
+ {
+ axis2_char_t *reply_to_addr = sandesha2_utils_get_seq_property(env,
+ int_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR, storage_mgr);
+ if(reply_to_addr)
+ {
+ polling_mode = sandesha2_utils_is_anon_uri(env, reply_to_addr);
+
+ }
+ }
+ /* Storing the referenceMessage of the sending side sequence as the reference message
+ * of the receiving side as well.
+ * This can be used when creating new outgoing messages.
+ */
+ ref_msg_store_key = sandesha2_create_seq_bean_get_ref_msg_store_key(
+ create_seq_bean, env);
+ if(ref_msg_store_key)
+ ref_msg_ctx = sandesha2_storage_mgr_retrieve_msg_ctx(storage_mgr,
+ env, ref_msg_store_key, conf_ctx);
+ new_msg_store_key = axis2_uuid_gen(env);
+ sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env,
+ new_msg_store_key, ref_msg_ctx);
+ sandesha2_next_msg_bean_set_ref_msg_key(next_bean, env,
+ new_msg_store_key);
+ sandesha2_next_msg_bean_set_polling_mode(next_bean, env, polling_mode);
+ /* If polling_mode is true, starting the polling manager */
+ if(polling_mode)
+ sandesha2_utils_start_polling_mgr(env, conf_ctx);
next_bean_mgr = sandesha2_storage_mgr_get_next_msg_mgr(storage_mgr,
env);
sandesha2_next_msg_mgr_insert(next_bean_mgr, env, next_bean);
- rm_spec_ver = sandesha2_msg_ctx_get_rm_spec_ver(rm_msg_ctx, env);
spec_ver_bean = sandesha2_seq_property_bean_create_with_data(env,
offered_seq_id, SANDESHA2_SEQ_PROP_RM_SPEC_VERSION,
@@ -421,7 +459,6 @@
sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] Exit: sandesha2_create_seq_res_msg_processor_process_in_msg");
- printf("[sandesha2] Exit: sandesha2_create_seq_res_msg_processor_process_in_msg\n");
return AXIS2_SUCCESS;
}
Modified: webservices/sandesha/trunk/c/src/msgprocessors/make_connection_msg_processor.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/make_connection_msg_processor.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/make_connection_msg_processor.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/make_connection_msg_processor.c Wed Dec 6 20:26:47 2006
@@ -28,6 +28,8 @@
#include <sandesha2_sender_worker.h>
#include <sandesha2_msg_pending.h>
#include <sandesha2_msg_init.h>
+#include <sandesha2_sender_mgr.h>
+#include <sandesha2_sender_bean.h>
#include <axis2_msg_ctx.h>
#include <axis2_string.h>
#include <axis2_engine.h>
@@ -45,20 +47,20 @@
* @brief Make Connection Message Processor struct impl
* Sandesha2 Make Connection Msg Processor
*/
-typedef struct sandesha2_make_connnection_msg_processor_impl
- sandesha2_make_connnection_msg_processor_impl_t;
+typedef struct sandesha2_make_connection_msg_processor_impl
+ sandesha2_make_connection_msg_processor_impl_t;
-struct sandesha2_make_connnection_msg_processor_impl
+struct sandesha2_make_connection_msg_processor_impl
{
sandesha2_msg_processor_t msg_processor;
};
#define SANDESHA2_INTF_TO_IMPL(msg_proc) \
- ((sandesha2_make_connnection_msg_processor_impl_t *)(msg_proc))
+ ((sandesha2_make_connection_msg_processor_impl_t *)(msg_proc))
/***************************** Function headers *******************************/
static axis2_status_t AXIS2_CALL
-sandesha2_make_connnection_msg_processor_process_in_msg (
+sandesha2_make_connection_msg_processor_process_in_msg (
sandesha2_msg_processor_t *msg_processor,
const axis2_env_t *env,
sandesha2_msg_ctx_t *rm_msg_ctx);
@@ -76,22 +78,22 @@
sandesha2_msg_ctx_t *make_conn_msg_ctx);
static axis2_status_t AXIS2_CALL
-sandesha2_make_connnection_msg_processor_free (
+sandesha2_make_connection_msg_processor_free (
sandesha2_msg_processor_t *msg_processor,
const axis2_env_t *env);
/***************************** End of function headers ************************/
AXIS2_EXTERN sandesha2_msg_processor_t* AXIS2_CALL
-sandesha2_make_connnection_msg_processor_create(
+sandesha2_make_connection_msg_processor_create(
const axis2_env_t *env)
{
- sandesha2_make_connnection_msg_processor_impl_t *msg_proc_impl = NULL;
+ sandesha2_make_connection_msg_processor_impl_t *msg_proc_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- msg_proc_impl = (sandesha2_make_connnection_msg_processor_impl_t *)AXIS2_MALLOC
+ msg_proc_impl = (sandesha2_make_connection_msg_processor_impl_t *)AXIS2_MALLOC
(env->allocator,
- sizeof(sandesha2_make_connnection_msg_processor_impl_t));
+ sizeof(sandesha2_make_connection_msg_processor_impl_t));
if(!msg_proc_impl)
{
@@ -103,26 +105,26 @@
sizeof(sandesha2_msg_processor_ops_t));
if(!msg_proc_impl->msg_processor.ops)
{
- sandesha2_make_connnection_msg_processor_free((sandesha2_msg_processor_t*)
+ sandesha2_make_connection_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_make_connnection_msg_processor_process_in_msg;
- msg_proc_impl->msg_processor.ops->free = sandesha2_make_connnection_msg_processor_free;
+ sandesha2_make_connection_msg_processor_process_in_msg;
+ msg_proc_impl->msg_processor.ops->free = sandesha2_make_connection_msg_processor_free;
return &(msg_proc_impl->msg_processor);
}
static axis2_status_t AXIS2_CALL
-sandesha2_make_connnection_msg_processor_free (
+sandesha2_make_connection_msg_processor_free (
sandesha2_msg_processor_t *msg_processor,
const axis2_env_t *env)
{
- sandesha2_make_connnection_msg_processor_impl_t *msg_proc_impl = NULL;
+ sandesha2_make_connection_msg_processor_impl_t *msg_proc_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
msg_proc_impl = SANDESHA2_INTF_TO_IMPL(msg_processor);
@@ -139,7 +141,7 @@
* This is processed using a SenderWorker.
*/
static axis2_status_t AXIS2_CALL
-sandesha2_make_connnection_msg_processor_process_in_msg (
+sandesha2_make_connection_msg_processor_process_in_msg (
sandesha2_msg_processor_t *msg_processor,
const axis2_env_t *env,
sandesha2_msg_ctx_t *rm_msg_ctx)
@@ -167,9 +169,8 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
- AXIS2_LOG_INFO(env->log, "[sandesha2] sandesha2_make_connnection_msg_" \
+ AXIS2_LOG_INFO(env->log, "[sandesha2] sandesha2_make_connection_msg_" \
"processor_process_in_msg .........");
- printf("sandesha2_make_connnection_msg_processor_process_in_msg\n");
make_conn = (sandesha2_make_connection_t*)
sandesha2_msg_ctx_get_msg_part(rm_msg_ctx, env,
@@ -177,7 +178,7 @@
if(!make_conn)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]"
- " make_connnection part is null");
+ " make_connection part is null");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING,
AXIS2_FAILURE);
return AXIS2_FAILURE;
@@ -249,7 +250,8 @@
if(size > 0)
{
unsigned int rand_var = axis2_rand_get_seed_value_based_on_time(env);
- item_to_pick = axis2_rand_with_range(&rand_var, 1, size);
+ item_to_pick = axis2_rand_with_range(&rand_var, 0, size);
+ item_to_pick--;
}
if(size > 1)
pending = AXIS2_TRUE; /*There are more than one message to be delivered
@@ -264,10 +266,14 @@
break;
}
if(!sender_bean)
+ {
return AXIS2_SUCCESS;
+ }
transport_out = AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(msg_ctx, env);
if(!transport_out)
{
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]"
+ " Cannot infer transport for the make connection request");
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CANNOT_INFER_TRANSPORT,
AXIS2_FAILURE);
return AXIS2_FAILURE;
@@ -287,11 +293,9 @@
axis2_ctx_t *ctx = AXIS2_OP_CTX_GET_BASE(op_ctx, env);
if (ctx)
{
- axis2_char_t *value = NULL;
- value = AXIS2_STRDUP("TRUE", env);
property = axis2_property_create(env);
- AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
- AXIS2_PROPERTY_SET_VALUE(property, env, value);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, "TRUE");
AXIS2_CTX_SET_PROPERTY(ctx, env, AXIS2_RESPONSE_WRITTEN,
property, AXIS2_FALSE);
}
@@ -311,6 +315,8 @@
sandesha2_sender_worker_set_transport_out(sender_worker, env, transport_out);
sandesha2_sender_worker_run(sender_worker, env);
}
+ AXIS2_LOG_INFO(env->log, "[sandesha2] EXIT sandesha2_make_connection_msg_" \
+ "processor_process_in_msg .........");
return AXIS2_SUCCESS;
}
@@ -320,13 +326,22 @@
sandesha2_msg_ctx_t *return_msg_ctx,
axis2_bool_t pending)
{
- axiom_soap_envelope_t *soap_env = sandesha2_msg_ctx_get_soap_envelope(
+ axis2_char_t *rm_ns = NULL;
+ sandesha2_msg_pending_t *msg_pending = NULL;
+ axiom_soap_envelope_t *soap_env = NULL;
+ if(return_msg_ctx)
+ {
+ soap_env = sandesha2_msg_ctx_get_soap_envelope(
return_msg_ctx, env);
- axis2_char_t *rm_ns = sandesha2_msg_ctx_get_rm_ns_val(return_msg_ctx, env);
- sandesha2_msg_pending_t *msg_pending = sandesha2_msg_pending_create(env,
- rm_ns);
- sandesha2_msg_pending_set_pending(msg_pending, env, pending);
- sandesha2_msg_pending_to_soap_envelope(msg_pending, env, soap_env);
+ rm_ns = sandesha2_msg_ctx_get_rm_ns_val(return_msg_ctx, env);
+ msg_pending = sandesha2_msg_pending_create(env, rm_ns);
+ }
+ if(msg_pending)
+ {
+ sandesha2_msg_pending_set_pending(msg_pending, env, pending);
+ sandesha2_msg_pending_to_soap_envelope((sandesha2_iom_rm_part_t *)
+ msg_pending, env, soap_env);
+ }
}
static void
@@ -336,13 +351,18 @@
sandesha2_msg_ctx_t *make_conn_msg_ctx)
{
axis2_property_t *property = NULL;
- property = sandesha2_msg_ctx_get_property(make_conn_msg_ctx, env,
+ if(make_conn_msg_ctx && return_msg_ctx)
+ {
+ property = sandesha2_msg_ctx_get_property(make_conn_msg_ctx, env,
AXIS2_TRANSPORT_OUT);
- AXIS2_MSG_CTX_SET_PROPERTY(return_msg_ctx, env, AXIS2_TRANSPORT_OUT,
- property, AXIS2_FALSE);
- property = sandesha2_msg_ctx_get_property(make_conn_msg_ctx, env,
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_MSG_CTX_SET_PROPERTY(return_msg_ctx, env, AXIS2_TRANSPORT_OUT,
+ AXIS2_PROPERTY_CLONE(property, env), AXIS2_FALSE);
+ property = sandesha2_msg_ctx_get_property(make_conn_msg_ctx, env,
AXIS2_HTTP_OUT_TRANSPORT_INFO);
- AXIS2_MSG_CTX_SET_PROPERTY(return_msg_ctx, env,
- AXIS2_HTTP_OUT_TRANSPORT_INFO, property, AXIS2_FALSE);
+ AXIS2_MSG_CTX_SET_PROPERTY(return_msg_ctx, env,
+ AXIS2_HTTP_OUT_TRANSPORT_INFO, AXIS2_PROPERTY_CLONE(property, env),
+ AXIS2_FALSE);
+ }
}
Modified: webservices/sandesha/trunk/c/src/msgprocessors/msg_processor_creator.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/msg_processor_creator.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/msg_processor_creator.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/msg_processor_creator.c Wed Dec 6 20:26:47 2006
@@ -37,6 +37,7 @@
#include <sandesha2_close_seq_msg_processor.h>
#include <sandesha2_ack_req_msg_processor.h>
#include <sandesha2_app_msg_processor.h>
+#include <sandesha2_make_connection_msg_processor.h>
#include <axis2_string.h>
#include <stdio.h>
/**
@@ -71,6 +72,9 @@
case SANDESHA2_MSG_TYPE_CLOSE_SEQ:
return (sandesha2_msg_processor_t *)
sandesha2_close_seq_msg_processor_create(env);
+ case SANDESHA2_MSG_TYPE_MAKE_CONNECTION_MSG:
+ return (sandesha2_msg_processor_t *)
+ sandesha2_make_connection_msg_processor_create(env);
default :
return NULL;
}
Modified: 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?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/terminate_seq_msg_processor.c Wed Dec 6 20:26:47 2006
@@ -22,6 +22,8 @@
#include <sandesha2_utils.h>
#include <sandesha2_msg_ctx.h>
#include <sandesha2_terminate_seq.h>
+#include <sandesha2_sender_bean.h>
+#include <sandesha2_sender_mgr.h>
#include <axis2_msg_ctx.h>
#include <axis2_string.h>
#include <axis2_engine.h>
@@ -176,7 +178,6 @@
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] sandesha2_terminate_msg_processor_process_in_msg .........");
- printf("sandesha2_terminate_msg_processor_process_in_msg\n");
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
@@ -248,7 +249,6 @@
sandesha2_msg_ctx_set_paused(rm_msg_ctx, env, AXIS2_TRUE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] Exit: sandesha2_terminate_msg_processor_process_in_msg");
- printf("[sandesha2] Exit: sandesha2_terminate_msg_processor_process_in_msg\n");
return AXIS2_SUCCESS;
}
@@ -398,14 +398,59 @@
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_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, SANDESHA2_VALUE_TRUE);
AXIS2_MSG_CTX_SET_PROPERTY(out_msg_ctx, env,
- SANDESHA2_APPLICATION_PROCESSING_DONE, property,
- AXIS2_FALSE);
+ SANDESHA2_APPLICATION_PROCESSING_DONE, property, AXIS2_FALSE);
AXIS2_MSG_CTX_SET_RESPONSE_WRITTEN(out_msg_ctx, env, AXIS2_TRUE);
+ /* test code */
+ axis2_transport_out_desc_t *orig_trans_out = NULL;
+ axis2_transport_out_desc_t *trans_out = NULL;
+ orig_trans_out = AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(out_msg_ctx, env);
+ property = axis2_property_create_with_args(env, 3, 0, orig_trans_out);
+ AXIS2_MSG_CTX_SET_PROPERTY(out_msg_ctx, env,
+ SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property, AXIS2_FALSE);
+ trans_out = sandesha2_utils_get_transport_out(env);
+ AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(out_msg_ctx, env, trans_out);
+
+ sandesha2_sender_bean_t *term_res_bean = NULL;
+ axis2_char_t *key = NULL;
+ sandesha2_sender_mgr_t *retrans_mgr = NULL;
+ key = axis2_uuid_gen(env);
+ term_res_bean = sandesha2_sender_bean_create(env);
+ sandesha2_sender_bean_set_msg_ctx_ref_key(term_res_bean, env, key);
+ /*AXIS2_MSG_CTX_SET_KEEP_ALIVE(msg_ctx, env, AXIS2_TRUE);*/
+ sandesha2_storage_mgr_store_msg_ctx(storage_man, env, key, out_msg_ctx);
+
+ /* TODO: refine the terminate delay */
+ sandesha2_sender_bean_set_time_to_send(term_res_bean, env,
+ sandesha2_utils_get_current_time_in_millis(env) +
+ SANDESHA2_TERMINATE_DELAY);
+ sandesha2_sender_bean_set_msg_id(term_res_bean, env,
+ (axis2_char_t *) AXIS2_MSG_CTX_GET_MSG_ID(out_msg_ctx, env));
+ sandesha2_sender_bean_set_send(term_res_bean, env, AXIS2_TRUE);
+
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, SANDESHA2_VALUE_TRUE);
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx, env, SANDESHA2_QUALIFIED_FOR_SENDING,
+ property, AXIS2_FALSE);
+ sandesha2_sender_bean_set_resend(term_res_bean, env, AXIS2_FALSE);
+ retrans_mgr = sandesha2_storage_mgr_get_retrans_mgr(storage_man, env);
+ sandesha2_sender_mgr_insert(retrans_mgr, env, term_res_bean);
+
+ /* end test code */
+
+
+
+
+
+
+
+
+
+
engine = axis2_engine_create(env, AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env));
AXIS2_ENGINE_SEND(engine, env, out_msg_ctx);
@@ -457,13 +502,14 @@
sandesha2_sender_mgr_t *retrans_mgr = NULL;
sandesha2_seq_property_bean_t *term_added = NULL;
axis2_transport_out_desc_t *out_desc = NULL;
+ axis2_transport_out_desc_t *sandesha2_out_desc = NULL;
axis2_engine_t *engine = NULL;
+ axis2_transport_sender_t *transport_sender = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
AXIS2_LOG_INFO(env->log,
"[sandesha2] sandesha2_terminate_msg_processor_process_out_msg .........");
- printf("sandesha2_terminate_msg_processor_process_out_msg\n");
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
@@ -475,7 +521,8 @@
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);
+ if(property)
+ 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);
@@ -564,13 +611,10 @@
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);
-
+ AXIS2_PROPERTY_SET_VALUE(property, env, SANDESHA2_VALUE_TRUE);
+ 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);
@@ -605,13 +649,15 @@
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));
+ sandesha2_out_desc = sandesha2_utils_get_transport_out(env);
+ AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(msg_ctx, env, sandesha2_out_desc);
engine = axis2_engine_create(env, conf_ctx);
- AXIS2_ENGINE_SEND(engine, env, msg_ctx);
+ /*AXIS2_ENGINE_SEND(engine, env, msg_ctx);*/
+ transport_sender = AXIS2_TRANSPORT_OUT_DESC_GET_SENDER(sandesha2_out_desc,
+ env);
+ AXIS2_TRANSPORT_SENDER_INVOKE(transport_sender, env, msg_ctx);
AXIS2_LOG_INFO(env->log,
- "[sandesha2] Exit: sandesha2_terminate_msg_processor_process_out_msg");
+ "[sandesha2] Exit: sandesha2_terminate_msg_processor_process_out_msg");
return AXIS2_SUCCESS;
}
Modified: webservices/sandesha/trunk/c/src/polling/polling_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/polling/polling_mgr.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/polling/polling_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/polling/polling_mgr.c Wed Dec 6 20:26:47 2006
@@ -25,6 +25,9 @@
#include <sandesha2_seq.h>
#include <sandesha2_msg_init.h>
#include <sandesha2_msg_creator.h>
+#include <sandesha2_next_msg_mgr.h>
+#include <sandesha2_sender_bean.h>
+#include <sandesha2_sender_mgr.h>
#include <axis2_addr.h>
#include <axis2_engine.h>
#include <axis2_uuid_gen.h>
@@ -37,7 +40,6 @@
* Sandesha2 Polling Manager
*/
typedef struct sandesha2_polling_mgr_args sandesha2_polling_mgr_args_t;
-#define SANDESHA2_POLLING_MANAGER_WAIT_TIME 5000
struct sandesha2_polling_mgr_t
{
@@ -152,17 +154,22 @@
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE);
+ axis2_thread_mutex_lock(polling_mgr->mutex);
polling_mgr->conf_ctx = conf_ctx;
polling_mgr->scheduled_polling_reqs = axis2_array_list_create(env,
AXIS2_ARRAY_LIST_DEFAULT_CAPACITY);
if(!polling_mgr->conf_ctx || !polling_mgr->conf_ctx->ops)
+ {
+ axis2_thread_mutex_unlock(polling_mgr->mutex);
return AXIS2_FAILURE;
+ }
storage_mgr = sandesha2_utils_get_storage_mgr(env,
polling_mgr->conf_ctx,
AXIS2_CONF_CTX_GET_CONF(polling_mgr->conf_ctx, env));
- set_poll(AXIS2_TRUE);
+ sandesha2_polling_mgr_set_poll(polling_mgr, env, AXIS2_TRUE);
sandesha2_polling_mgr_run(polling_mgr, env, storage_mgr);
+ axis2_thread_mutex_unlock(polling_mgr->mutex);
return AXIS2_SUCCESS;
}
@@ -212,9 +219,8 @@
polling_mgr = args->impl;
storage_mgr = args->storage_mgr;
- while(sandesha2_polling_mgr_is_poll(polling_mgr, env))
+ while(polling_mgr->poll)
{
- sandesha2_storage_mgr_t *storage_mgr = NULL;
sandesha2_next_msg_mgr_t *next_msg_mgr = NULL;
sandesha2_next_msg_bean_t *next_msg_bean = NULL;
sandesha2_msg_ctx_t *ref_rm_msg_ctx = NULL;
@@ -267,7 +273,8 @@
{
unsigned int rand_var =
axis2_rand_get_seed_value_based_on_time(env);
- int item = axis2_rand_with_range(&rand_var, 1, size);
+ int item = axis2_rand_with_range(&rand_var, 0, size);
+ item--;
next_msg_bean = (sandesha2_next_msg_bean_t *)
AXIS2_ARRAY_LIST_GET(results, env, item);
}
@@ -296,7 +303,7 @@
seq_prop_key = seq_id;
reply_to = sandesha2_utils_get_seq_property(env, seq_prop_key,
SANDESHA2_SEQ_PROP_REPLY_TO_EPR, storage_mgr);
- if(sandesha2_util_is_wsrm_anon_reply_to(env, reply_to))
+ if(sandesha2_utils_is_wsrm_anon_reply_to(env, reply_to))
wsrm_anon_reply_to_uri = reply_to;
ref_msg_ctx = sandesha2_storage_mgr_retrieve_msg_ctx(storage_mgr, env,
ref_msg_key, polling_mgr->conf_ctx);
@@ -315,8 +322,8 @@
/* Storing the MakeConnection message */
make_conn_msg_store_key = axis2_uuid_gen(env);
property = axis2_property_create(env);
- AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(seq_prop_key, env));
- AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_SESSION);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, seq_prop_key);
sandesha2_msg_ctx_set_property(make_conn_rm_msg_ctx, env,
SANDESHA2_MSG_CTX_PROP_SEQUENCE_PROPERTY_KEY, property);
make_conn_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(make_conn_rm_msg_ctx,
@@ -329,6 +336,10 @@
make_conn_sender_bean = sandesha2_sender_bean_create(env);
if(make_conn_sender_bean)
{
+ long millisecs = 0;
+ millisecs = sandesha2_utils_get_current_time_in_millis(env);
+ sandesha2_sender_bean_set_time_to_send(make_conn_sender_bean, env,
+ millisecs);
sandesha2_sender_bean_set_msg_ctx_ref_key(make_conn_sender_bean, env,
make_conn_msg_store_key);
msg_id = sandesha2_msg_ctx_get_msg_id(make_conn_rm_msg_ctx, env);
@@ -354,15 +365,14 @@
* it is sent through the sandesha2_transport_sender
*/
property = axis2_property_create(env);
- AXIS2_PROPERTY_SET_VALUE(property, env,
- AXIS2_STRDUP(SANDESHA2_VALUE_FALSE, env));
- AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_SESSION);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
+ AXIS2_PROPERTY_SET_VALUE(property, env, SANDESHA2_VALUE_FALSE);
sandesha2_msg_ctx_set_property(make_conn_rm_msg_ctx, env,
SANDESHA2_QUALIFIED_FOR_SENDING, property);
if(sender_bean_mgr)
sandesha2_sender_mgr_insert(sender_bean_mgr, env,
make_conn_sender_bean);
- sandesha2_util_execute_and_store(env, make_conn_rm_msg_ctx,
+ sandesha2_utils_execute_and_store(env, make_conn_rm_msg_ctx,
make_conn_msg_store_key);
}
return NULL;
@@ -391,7 +401,7 @@
const axis2_env_t *env,
axis2_char_t *internal_seq_id)
{
- if(AXIS2_ARRAY_LIST_CONTAINS(polling_mgr->scheduled_polling_reqs, env,
+ if(!AXIS2_ARRAY_LIST_CONTAINS(polling_mgr->scheduled_polling_reqs, env,
internal_seq_id))
{
AXIS2_ARRAY_LIST_ADD(polling_mgr->scheduled_polling_reqs, env,
Modified: webservices/sandesha/trunk/c/src/util/ack_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/ack_mgr.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/util/ack_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/util/ack_mgr.c Wed Dec 6 20:26:47 2006
@@ -21,6 +21,9 @@
#include <sandesha2_seq_property_bean.h>
#include <sandesha2_ack_range.h>
#include <sandesha2_spec_specific_consts.h>
+#include <sandesha2_seq_property_mgr.h>
+#include <sandesha2_sender_mgr.h>
+#include <sandesha2_sender_bean.h>
#include <axis2_string.h>
#include <axis2_uuid_gen.h>
#include <axis2_addr.h>
@@ -80,18 +83,21 @@
ref_op = AXIS2_MSG_CTX_GET_OP(ref_msg, env);
if(ref_op)
{
- axis2_array_list_t *out_flows = NULL;
- axis2_array_list_t *out_fault_flows = NULL;
- out_flows = AXIS2_OP_GET_OUT_FLOW(ref_op, env);
- out_fault_flows = AXIS2_OP_GET_FAULT_OUT_FLOW(ref_op, env);
- if(out_flows)
- {
- AXIS2_OP_SET_OUT_FLOW(ack_op, env, out_flows);
- AXIS2_OP_SET_FAULT_OUT_FLOW(ack_op, env, out_fault_flows);
- }
+ axis2_array_list_t *out_flow = NULL;
+ axis2_array_list_t *out_fault_flow = NULL;
+ axis2_array_list_t *new_out_flow = NULL;
+ axis2_array_list_t *new_out_fault_flow = NULL;
+ out_flow = AXIS2_OP_GET_OUT_FLOW(ref_op, env);
+ new_out_flow = axis2_phases_info_copy_flow(env, out_flow);
+ out_fault_flow = AXIS2_OP_GET_FAULT_OUT_FLOW(ref_op, env);
+ new_out_fault_flow = axis2_phases_info_copy_flow(env, out_fault_flow);
+ if(new_out_flow)
+ AXIS2_OP_SET_OUT_FLOW(ack_op, env, new_out_flow);
+ if(new_out_fault_flow)
+ AXIS2_OP_SET_FAULT_OUT_FLOW(ack_op, env, new_out_fault_flow);
}
ack_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env, ref_rm_msg,
- ack_op);
+ ack_op);
property = AXIS2_MSG_CTX_GET_PROPERTY(ref_msg, env, AXIS2_WSA_VERSION,
AXIS2_FALSE);
if(property)
@@ -130,14 +136,19 @@
storage_mgr);
if(addr_ns_uri)
{
- property = axis2_property_create(env);
+ property = AXIS2_MSG_CTX_GET_PROPERTY(ack_msg_ctx, env, AXIS2_WSA_VERSION,
+ AXIS2_FALSE);
if(property)
{
- AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_APPLICATION);
- AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(addr_ns_uri, env));
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP(addr_ns_uri,
+ env));
+ }
+ else
+ {
+ property = axis2_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0,
+ AXIS2_STRDUP(addr_ns_uri, env));
AXIS2_MSG_CTX_SET_PROPERTY(ack_msg_ctx, env, AXIS2_WSA_VERSION, property,
AXIS2_FALSE);
- property = NULL;
}
}
anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_uri);
@@ -268,7 +279,7 @@
ret_rm_msg = sandesha2_msg_init_init_msg(env, ack_msg_ctx);
sandesha2_utils_start_sender_for_seq(env, conf_ctx, seq_id);
- AXIS2_MSG_CTX_SET_PAUSED(ref_msg, env, AXIS2_TRUE);
+ /*AXIS2_MSG_CTX_SET_PAUSED(ref_msg, env, AXIS2_TRUE);*/
return ret_rm_msg;
}
return NULL;
Modified: webservices/sandesha/trunk/c/src/util/fault_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/fault_mgr.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/util/fault_mgr.c (original)
+++ webservices/sandesha/trunk/c/src/util/fault_mgr.c Wed Dec 6 20:26:47 2006
@@ -14,6 +14,9 @@
* limitations under the License.
*/
#include <sandesha2_fault_mgr.h>
+#include <sandesha2_seq_property_mgr.h>
+#include <sandesha2_create_seq_mgr.h>
+#include <sandesha2_next_msg_mgr.h>
#include <sandesha2_constants.h>
#include <axis2_hash.h>
#include <axis2_core_utils.h>
@@ -182,10 +185,9 @@
{
sandesha2_create_seq_bean_t *find_bean = NULL;
axis2_array_list_t *list = NULL;
- AXIS2_LOG_INFO(env->log, "[sandesha2] came10 .........");
find_bean = sandesha2_create_seq_bean_create(env);
sandesha2_create_seq_bean_set_seq_id(find_bean, env, seq_id);
- list = SANDESHA2_CREATE_SEQ_MGR_FIND(create_seq_mgr, env,
+ list = sandesha2_create_seq_mgr_find(create_seq_mgr, env,
find_bean);
if(list)
{
@@ -251,7 +253,7 @@
detail_ele = axiom_element_create_with_qname(env, NULL, qname,
&detail_node);
sandesha2_fault_data_set_detail(fault_data, env, detail_node);
- sandesha2_fault_data_set_reason(fault_data, env, "A sequence with the"
+ sandesha2_fault_data_set_reason(fault_data, env, "A sequence with the" \
" given sequenceID has NOT been established");
return sandesha2_fault_mgr_get_fault(env, rm_msg_ctx,
fault_data, sandesha2_msg_ctx_get_addr_ns_val(rm_msg_ctx,
Modified: webservices/sandesha/trunk/c/src/util/msg_creator.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/util/msg_creator.c?view=diff&rev=483342&r1=483341&r2=483342
==============================================================================
--- webservices/sandesha/trunk/c/src/util/msg_creator.c (original)
+++ webservices/sandesha/trunk/c/src/util/msg_creator.c Wed Dec 6 20:26:47 2006
@@ -96,9 +96,9 @@
axis2_char_t *temp_action = NULL;
axis2_char_t *temp_soap_action = NULL;
axis2_endpoint_ref_t *to_epr = NULL;
+ axis2_endpoint_ref_t *temp_to = NULL;
axis2_endpoint_ref_t *reply_to_epr = NULL;
axis2_endpoint_ref_t *acks_to_epr = NULL;
- axis2_endpoint_ref_t *temp_to = NULL;
axis2_endpoint_ref_t *temp_reply_to = NULL;
axis2_qname_t *qname = NULL;
sandesha2_create_seq_t *create_seq_part = NULL;
@@ -108,6 +108,7 @@
sandesha2_msg_ctx_t *create_seq_rm_msg = NULL;
sandesha2_address_t *temp_address = NULL;
sandesha2_acks_to_t *temp_acks_to = NULL;
+ axis2_property_t *property = NULL;
application_msg_ctx = sandesha2_msg_ctx_get_msg_ctx(application_rm_msg, env);
if(!application_msg_ctx)
@@ -147,22 +148,42 @@
axis2_array_list_t *out_fault_flow = NULL;
axis2_array_list_t *in_fault_flow = NULL;
axis2_array_list_t *inflow = NULL;
+ axis2_array_list_t *new_outflow = NULL;
+ axis2_array_list_t *new_out_fault_flow = NULL;
+ axis2_array_list_t *new_in_fault_flow = NULL;
+ axis2_array_list_t *new_inflow = NULL;
outflow = AXIS2_OP_GET_OUT_FLOW(app_msg_op_desc, env);
- AXIS2_OP_SET_OUT_FLOW(create_seq_op, env, outflow);
+ new_outflow = axis2_phases_info_copy_flow(env, outflow);
+ AXIS2_OP_SET_OUT_FLOW(create_seq_op, env, new_outflow);
out_fault_flow = AXIS2_OP_GET_FAULT_OUT_FLOW(app_msg_op_desc, env);
- AXIS2_OP_SET_FAULT_OUT_FLOW(create_seq_op, env, out_fault_flow);
+ new_out_fault_flow = axis2_phases_info_copy_flow(env, out_fault_flow);
+ AXIS2_OP_SET_FAULT_OUT_FLOW(create_seq_op, env, new_out_fault_flow);
in_fault_flow = AXIS2_OP_GET_FAULT_IN_FLOW(app_msg_op_desc, env);
- AXIS2_OP_SET_FAULT_IN_FLOW(create_seq_op, env, in_fault_flow);
+ new_in_fault_flow = axis2_phases_info_copy_flow(env, in_fault_flow);
+ AXIS2_OP_SET_FAULT_IN_FLOW(create_seq_op, env, new_in_fault_flow);
inflow = AXIS2_OP_GET_IN_FLOW(app_msg_op_desc, env);
- AXIS2_OP_SET_IN_FLOW(create_seq_op, env, inflow);
+ new_inflow = axis2_phases_info_copy_flow(env, inflow);
+ AXIS2_OP_SET_IN_FLOW(create_seq_op, env, new_inflow);
}
AXIS2_MSG_CTX_SET_OP(create_seq_msg_ctx, env, create_seq_op);
- temp_to = sandesha2_msg_ctx_get_to(application_rm_msg, env);
- to_epr = axis2_endpoint_ref_create(env, AXIS2_ENDPOINT_REF_GET_ADDRESS(
- temp_to, env));
+ property = AXIS2_MSG_CTX_GET_PROPERTY(application_msg_ctx, env,
+ AXIS2_TARGET_EPR, AXIS2_FALSE);
+ if(property)
+ {
+ temp_to = AXIS2_PROPERTY_GET_VALUE(property, env);
+ to_epr = axis2_endpoint_ref_create(env, AXIS2_ENDPOINT_REF_GET_ADDRESS(
+ temp_to, env));
+ }
+ if (!to_epr)
+ {
+ temp_to = sandesha2_msg_ctx_get_to(application_rm_msg, env);
+ to_epr = axis2_endpoint_ref_create(env, AXIS2_ENDPOINT_REF_GET_ADDRESS(
+ temp_to, env));
+ }
AXIS2_MSG_CTX_SET_TO(create_seq_msg_ctx, env, to_epr);
to_epr = NULL;
+
temp_reply_to = sandesha2_msg_ctx_get_reply_to(application_rm_msg, env);
AXIS2_MSG_CTX_SET_REPLY_TO(create_seq_msg_ctx, env, temp_reply_to);
create_seq_rm_msg = sandesha2_msg_ctx_create(env, create_seq_msg_ctx);
@@ -350,10 +371,17 @@
rm_version);
AXIS2_MSG_CTX_SET_SOAP_ACTION(out_msg, env, temp_action);
ctx = AXIS2_MSG_CTX_GET_BASE(out_msg, env);
- prop = axis2_property_create(env);
- AXIS2_PROPERTY_SET_SCOPE(prop, env, AXIS2_SCOPE_APPLICATION);
- AXIS2_PROPERTY_SET_VALUE(prop, env, addressing_ns_value);
- AXIS2_CTX_SET_PROPERTY(ctx, env, AXIS2_WSA_VERSION, prop, AXIS2_FALSE);
+ prop = AXIS2_CTX_GET_PROPERTY(ctx, env, AXIS2_WSA_VERSION, AXIS2_FALSE);
+ if(prop)
+ {
+ AXIS2_PROPERTY_SET_VALUE(prop, env, addressing_ns_value);
+ }
+ else
+ {
+ prop = axis2_property_create_with_args(env, AXIS2_SCOPE_APPLICATION, 0,
+ addressing_ns_value);
+ AXIS2_CTX_SET_PROPERTY(ctx, env, AXIS2_WSA_VERSION, prop, AXIS2_FALSE);
+ }
new_msg_id = axis2_uuid_gen(env);
AXIS2_MSG_CTX_SET_MESSAGE_ID(out_msg, env, new_msg_id);
AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(out_msg, env, envelope);
@@ -410,7 +438,7 @@
response = (sandesha2_iom_rm_part_t *) sandesha2_close_seq_res_create(env, ns);
identifier = sandesha2_identifier_create(env, ns);
sandesha2_identifier_set_identifier(identifier, env, seq_id);
- SANDESHA2_CLOSE_SEQ_RES_SET_IDENTIFIER((sandesha2_close_seq_res_t *) response, env, identifier);
+ sandesha2_close_seq_res_set_identifier((sandesha2_close_seq_res_t *) response, env, identifier);
temp_envelope = sandesha2_msg_ctx_get_soap_envelope(close_seq_msg, env);
soap_version = sandesha2_utils_get_soap_version(env, temp_envelope);
envelope = axiom_soap_envelope_create_default_soap_envelope(env, soap_version);
@@ -505,15 +533,23 @@
axis2_array_list_t *out_fault_flow = NULL;
axis2_array_list_t *in_fault_flow = NULL;
axis2_array_list_t *inflow = NULL;
+ axis2_array_list_t *new_outflow = NULL;
+ axis2_array_list_t *new_out_fault_flow = NULL;
+ axis2_array_list_t *new_in_fault_flow = NULL;
+ axis2_array_list_t *new_inflow = NULL;
outflow = AXIS2_OP_GET_OUT_FLOW(ref_msg_op, env);
- AXIS2_OP_SET_OUT_FLOW(terminate_seq_op, env, outflow);
+ new_outflow = axis2_phases_info_copy_flow(env, outflow);
+ AXIS2_OP_SET_OUT_FLOW(terminate_seq_op, env, new_outflow);
out_fault_flow = AXIS2_OP_GET_FAULT_OUT_FLOW(ref_msg_op, env);
- AXIS2_OP_SET_FAULT_OUT_FLOW(terminate_seq_op, env, out_fault_flow);
+ new_out_fault_flow = axis2_phases_info_copy_flow(env, out_fault_flow);
+ AXIS2_OP_SET_FAULT_OUT_FLOW(terminate_seq_op, env, new_out_fault_flow);
in_fault_flow = AXIS2_OP_GET_FAULT_IN_FLOW(ref_msg_op, env);
- AXIS2_OP_SET_FAULT_IN_FLOW(terminate_seq_op, env, in_fault_flow);
+ new_in_fault_flow = axis2_phases_info_copy_flow(env, in_fault_flow);
+ AXIS2_OP_SET_FAULT_IN_FLOW(terminate_seq_op, env, new_in_fault_flow);
inflow = AXIS2_OP_GET_IN_FLOW(ref_msg_op, env);
- AXIS2_OP_SET_IN_FLOW(terminate_seq_op, env, inflow);
+ new_inflow = axis2_phases_info_copy_flow(env, inflow);
+ AXIS2_OP_SET_IN_FLOW(terminate_seq_op, env, new_inflow);
}
rm_version = sandesha2_utils_get_rm_version(env, internal_seq_id, storage_mgr);
if(!rm_version)
@@ -695,13 +731,17 @@
void *k = NULL;
axis2_char_t *key = NULL;
axis2_property_t *prop = NULL;
+ axis2_property_t *new_prop = NULL;
axis2_ctx_t *ctx = NULL;
axis2_hash_this (hi, (const void **)&k, NULL, &v);
key = (axis2_char_t *) k;
prop = (axis2_property_t *) v;
ctx = AXIS2_OP_CTX_GET_BASE(new_op_ctx, env);
- AXIS2_CTX_SET_PROPERTY(ctx, env, key, prop, AXIS2_FALSE);
+ if(prop)
+ new_prop = AXIS2_PROPERTY_CLONE(prop, env);
+ if(new_prop)
+ AXIS2_CTX_SET_PROPERTY(ctx, env, key, new_prop, AXIS2_FALSE);
}
}
}
@@ -724,13 +764,17 @@
void *k = NULL;
axis2_char_t *key = NULL;
axis2_property_t *prop = NULL;
+ axis2_property_t *new_prop = NULL;
axis2_ctx_t *ctx = NULL;
axis2_hash_this (i, (const void **)&k, NULL, &v);
key = (axis2_char_t *) k;
prop = (axis2_property_t *) v;
ctx = AXIS2_MSG_CTX_GET_BASE(new_msg, env);
- AXIS2_CTX_SET_PROPERTY(ctx, env, key, prop, AXIS2_FALSE);
+ if(prop)
+ new_prop = AXIS2_PROPERTY_CLONE(prop, env);
+ if(new_prop)
+ AXIS2_CTX_SET_PROPERTY(ctx, env, key, new_prop, AXIS2_FALSE);
}
}
}
@@ -921,6 +965,7 @@
axis2_char_t *rm_version = NULL;
axis2_op_t *make_conn_op = NULL;
axis2_char_t *wsa_action = NULL;
+ axis2_qname_t *qname = NULL;
sandesha2_make_connection_t *make_conn = NULL;
sandesha2_msg_ctx_t *make_conn_rm_msg_ctx = NULL;
@@ -930,15 +975,56 @@
rm_ns_value = sandesha2_msg_ctx_get_rm_ns_val(ref_rm_msg_ctx, env);
rm_version = sandesha2_msg_ctx_get_rm_spec_ver(ref_rm_msg_ctx, env);
}
- make_conn_op = axis2_op_create(env);
- if(make_conn_op)
- AXIS2_OP_SET_MSG_EXCHANGE_PATTERN(make_conn_op, env,
- AXIS2_MEP_URI_OUT_IN);
+ qname = axis2_qname_create(env, "MakeConnectionOperation", NULL, NULL);
+ make_conn_op = axis2_op_create_with_qname(env, qname);
+ AXIS2_QNAME_FREE(qname, env);
make_conn_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env,
ref_rm_msg_ctx, make_conn_op);
if(make_conn_msg_ctx)
make_conn_rm_msg_ctx = sandesha2_msg_init_init_msg(env,
make_conn_msg_ctx);
+ /* This if block is an hack to add the addressing handlers to the outflow.
+ * Check whether this is not a hack
+ */
+ if(ref_msg_ctx)
+ {
+ axis2_op_t *op = AXIS2_MSG_CTX_GET_OP(ref_msg_ctx, env);
+ axis2_op_t *make_conn_op = AXIS2_MSG_CTX_GET_OP(make_conn_msg_ctx, env);
+ axis2_array_list_t *out_flow = AXIS2_OP_GET_OUT_FLOW(op, env);
+ axis2_array_list_t *in_flow = AXIS2_OP_GET_IN_FLOW(op, env);
+ int size = AXIS2_ARRAY_LIST_SIZE(out_flow, env);
+ if(size > 0)
+ {
+ int i = 0;
+ axis2_array_list_t *new_flow = axis2_array_list_create(env, 0);
+ for(i = 0; i < size; i++)
+ {
+ const axis2_phase_t *phase = AXIS2_ARRAY_LIST_GET(out_flow, env, i);
+ const axis2_char_t *phase_name = AXIS2_PHASE_GET_NAME(phase, env);
+ if(0 == AXIS2_STRCMP(phase_name, AXIS2_PHASE_MESSAGE_OUT))
+ {
+ AXIS2_ARRAY_LIST_ADD(new_flow, env, phase);
+ }
+ }
+ AXIS2_OP_SET_OUT_FLOW(make_conn_op, env, new_flow);
+ }
+ size = AXIS2_ARRAY_LIST_SIZE(in_flow, env);
+ if(size > 0)
+ {
+ int i = 0;
+ axis2_array_list_t *new_flow = axis2_array_list_create(env, 0);
+ for(i = 0; i < size; i++)
+ {
+ const axis2_phase_t *phase = AXIS2_ARRAY_LIST_GET(in_flow, env, i);
+ const axis2_char_t *phase_name = AXIS2_PHASE_GET_NAME(phase, env);
+ if(0 == AXIS2_STRCMP(phase_name, "RMPhase"))
+ {
+ AXIS2_ARRAY_LIST_ADD(new_flow, env, phase);
+ }
+ }
+ AXIS2_OP_SET_IN_FLOW(make_conn_op, env, new_flow);
+ }
+ }
make_conn = sandesha2_make_connection_create(env, rm_ns_value);
if(make_conn_seq_id)
{
@@ -964,6 +1050,7 @@
if(make_conn_msg_ctx)
{
axis2_endpoint_ref_t *to = NULL;
+ axis2_endpoint_ref_t *reply_to = NULL;
axis2_char_t *address = NULL;
/* Setting the addressing properties */
to = AXIS2_MSG_CTX_GET_TO(ref_msg_ctx, env);
@@ -971,10 +1058,12 @@
(const axis2_endpoint_ref_t *) to, env);
to = axis2_endpoint_ref_create(env, address);
AXIS2_MSG_CTX_SET_TO(make_conn_msg_ctx, env, to);
+ reply_to = axis2_endpoint_ref_create(env, AXIS2_WSA_ANONYMOUS_URL);
+ AXIS2_MSG_CTX_SET_REPLY_TO(make_conn_msg_ctx, env, reply_to);
wsa_action = sandesha2_spec_specific_consts_get_make_connection_action(
env, rm_version);
axis2_msg_ctx_set_wsa_action(make_conn_msg_ctx, env, wsa_action);
- AXIS2_MSG_CTX_SET_MSG_ID(make_conn_msg_ctx, env, axis2_uuid_gen(env));
+ AXIS2_MSG_CTX_SET_MESSAGE_ID(make_conn_msg_ctx, env, axis2_uuid_gen(env));
sandesha2_msg_ctx_set_msg_part(make_conn_rm_msg_ctx, env,
SANDESHA2_MSG_PART_MAKE_CONNECTION,
(sandesha2_iom_rm_part_t *) make_conn);
---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org