You are viewing a plain text version of this content. The canonical link for it is here.
Posted to sandesha-dev@ws.apache.org by sa...@apache.org on 2006/07/10 23:00:18 UTC
svn commit: r420631 [2/3] - in /webservices/sandesha/trunk/c: ./
include/sandesha2/ src/ src/msgprocessors/ src/storage/beans/
src/transport/ src/util/ src/workers/
Added: webservices/sandesha/trunk/c/src/msg_ctx.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msg_ctx.c?rev=420631&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/msg_ctx.c (added)
+++ webservices/sandesha/trunk/c/src/msg_ctx.c Mon Jul 10 14:00:16 2006
@@ -0,0 +1,732 @@
+/*
+ * 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_msg_ctx.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <axis2_hash.h>
+#include <axiom_soap_const.h>
+#include <sandesha2/sandesha2_iom_rm_part.h>
+#include <stdio.h>
+
+
+/**
+ * @brief Msg Ctx struct impl
+ * Sandesha2 Message Context
+ */
+typedef struct sandesha2_msg_ctx_impl sandesha2_msg_ctx_impl_t;
+
+struct sandesha2_msg_ctx_impl
+{
+ sandesha2_msg_ctx_t rm_msg_ctx;
+ axis2_msg_ctx_t *msg_ctx;
+ axis2_hash_t *msg_parts;
+ int msg_type;
+ axis2_char_t *rm_ns_val;
+ axis2_char_t *addr_ns_val;
+ axis2_char_t *spec_ver;
+};
+
+#define SANDESHA2_INTF_TO_IMPL(rm_msg_ctx) \
+ ((sandesha2_msg_ctx_impl_t *)(rm_msg_ctx))
+
+/***************************** Function headers *******************************/
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_ctx(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx);
+
+axis2_msg_ctx_t *AXIS2_CALL
+sandesha2_msg_ctx_get_msg_ctx(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_add_soap_envelope(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+int AXIS2_CALL
+sandesha2_msg_ctx_get_msg_type (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_type (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int msg_type);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_part (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int part_id,
+ sandesha2_iom_rm_part_t *part);
+
+sandesha2_iom_rm_part_t *AXIS2_CALL
+sandesha2_msg_ctx_get_msg_part(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int part_id);
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_from(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_from(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *from);
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_to (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *to);
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_reply_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_reply_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *reply_to);
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_fault_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_fault_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *fault_to);
+
+axis2_relates_to_t *AXIS2_CALL
+sandesha2_msg_ctx_get_relates_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_relates_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_relates_to_t *relates_to);
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_msg_id(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_id(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *msg_id);
+
+axiom_soap_envelope_t *AXIS2_CALL
+sandesha2_msg_ctx_get_soap_envelope(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_soap_envelope(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env,
+ axiom_soap_envelope_t *soap_envelope);
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_wsa_action(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_wsa_action(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *action);
+
+void *AXIS2_CALL
+sandesha2_msg_ctx_get_property(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *key);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_property(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *key, void *val);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_soap_action(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *soap_action);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_paused(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_bool_t paused);
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_rm_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_rm_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *ns_val);
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_addr_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_addr_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *ns_val);
+
+int AXIS2_CALL
+sandesha2_msg_ctx_get_flow(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_flow(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int flow);
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_free(sandesha2_msg_ctx_t *rm_msg_ctx, const axis2_env_t *env);
+
+/***************************** End of function headers ************************/
+
+AXIS2_EXTERN sandesha2_msg_ctx_t* AXIS2_CALL
+sandesha2_msg_ctx_create(const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = (sandesha2_msg_ctx_impl_t *)AXIS2_MALLOC
+ (env->allocator, sizeof(sandesha2_msg_ctx_impl_t));
+
+ if(NULL == msg_ctx_impl)
+ {
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ msg_ctx_impl->rm_ns_val = NULL;
+ msg_ctx_impl->addr_ns_val = NULL;
+ msg_ctx_impl->msg_parts = NULL;
+ msg_ctx_impl->spec_ver = NULL;
+ msg_ctx_impl->rm_msg_ctx.ops = NULL;
+
+ msg_ctx_impl->rm_msg_ctx.ops = AXIS2_MALLOC(env->allocator,
+ sizeof(sandesha2_msg_ctx_ops_t));
+ if(NULL == msg_ctx_impl->rm_msg_ctx.ops)
+ {
+ sandesha2_msg_ctx_free((sandesha2_msg_ctx_t*)msg_ctx_impl, env);
+ AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ msg_ctx_impl->msg_parts = axis2_hash_make(env);
+ msg_ctx_impl->msg_type = SANDESHA2_MSG_TYPE_UNKNOWN;
+
+ msg_ctx_impl->rm_msg_ctx.ops->set_msg_ctx = sandesha2_msg_ctx_set_msg_ctx;
+ msg_ctx_impl->rm_msg_ctx.ops->get_msg_ctx = sandesha2_msg_ctx_get_msg_ctx;
+ msg_ctx_impl->rm_msg_ctx.ops->add_soap_envelope =
+ sandesha2_msg_ctx_add_soap_envelope;
+ msg_ctx_impl->rm_msg_ctx.ops->get_msg_type = sandesha2_msg_ctx_get_msg_type;
+ msg_ctx_impl->rm_msg_ctx.ops->set_msg_type = sandesha2_msg_ctx_set_msg_type;
+ msg_ctx_impl->rm_msg_ctx.ops->set_msg_part = sandesha2_msg_ctx_set_msg_part;
+ msg_ctx_impl->rm_msg_ctx.ops->get_msg_part = sandesha2_msg_ctx_get_msg_part;
+ msg_ctx_impl->rm_msg_ctx.ops->get_from = sandesha2_msg_ctx_get_from;
+ msg_ctx_impl->rm_msg_ctx.ops->set_from = sandesha2_msg_ctx_set_from;
+ msg_ctx_impl->rm_msg_ctx.ops->get_to = sandesha2_msg_ctx_get_to;
+ msg_ctx_impl->rm_msg_ctx.ops->set_to = sandesha2_msg_ctx_set_to;
+ msg_ctx_impl->rm_msg_ctx.ops->get_reply_to = sandesha2_msg_ctx_get_reply_to;
+ msg_ctx_impl->rm_msg_ctx.ops->set_reply_to = sandesha2_msg_ctx_set_reply_to;
+ msg_ctx_impl->rm_msg_ctx.ops->get_fault_to = sandesha2_msg_ctx_get_fault_to;
+ msg_ctx_impl->rm_msg_ctx.ops->set_fault_to = sandesha2_msg_ctx_set_fault_to;
+ msg_ctx_impl->rm_msg_ctx.ops->get_relates_to =
+ sandesha2_msg_ctx_get_relates_to;
+ msg_ctx_impl->rm_msg_ctx.ops->set_relates_to =
+ sandesha2_msg_ctx_set_relates_to;
+ msg_ctx_impl->rm_msg_ctx.ops->get_msg_id = sandesha2_msg_ctx_get_msg_id;
+ msg_ctx_impl->rm_msg_ctx.ops->set_msg_id = sandesha2_msg_ctx_set_msg_id;
+ msg_ctx_impl->rm_msg_ctx.ops->get_soap_envelope =
+ sandesha2_msg_ctx_get_soap_envelope;
+ msg_ctx_impl->rm_msg_ctx.ops->set_soap_envelope =
+ sandesha2_msg_ctx_set_soap_envelope;
+ msg_ctx_impl->rm_msg_ctx.ops->get_wsa_action =
+ sandesha2_msg_ctx_get_wsa_action;
+ msg_ctx_impl->rm_msg_ctx.ops->set_wsa_action =
+ sandesha2_msg_ctx_set_wsa_action;
+ msg_ctx_impl->rm_msg_ctx.ops->get_property = sandesha2_msg_ctx_get_property;
+ msg_ctx_impl->rm_msg_ctx.ops->set_property = sandesha2_msg_ctx_set_property;
+ msg_ctx_impl->rm_msg_ctx.ops->set_soap_action =
+ sandesha2_msg_ctx_set_soap_action;
+ msg_ctx_impl->rm_msg_ctx.ops->set_paused = sandesha2_msg_ctx_set_paused;
+ msg_ctx_impl->rm_msg_ctx.ops->get_rm_ns_val =
+ sandesha2_msg_ctx_get_rm_ns_val;
+ msg_ctx_impl->rm_msg_ctx.ops->set_rm_ns_val =
+ sandesha2_msg_ctx_set_rm_ns_val;
+ msg_ctx_impl->rm_msg_ctx.ops->get_addr_ns_val =
+ sandesha2_msg_ctx_get_addr_ns_val;
+ msg_ctx_impl->rm_msg_ctx.ops->set_addr_ns_val =
+ sandesha2_msg_ctx_set_addr_ns_val;
+ msg_ctx_impl->rm_msg_ctx.ops->get_flow = sandesha2_msg_ctx_get_flow;
+ msg_ctx_impl->rm_msg_ctx.ops->set_flow = sandesha2_msg_ctx_set_flow;
+ msg_ctx_impl->rm_msg_ctx.ops->free = sandesha2_msg_ctx_free;
+
+ return &(msg_ctx_impl->rm_msg_ctx);
+}
+
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_free(sandesha2_msg_ctx_t *rm_msg_ctx, const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+
+ if(NULL != msg_ctx_impl->addr_ns_val)
+ {
+ AXIS2_FREE(env->allocator, msg_ctx_impl->addr_ns_val);
+ msg_ctx_impl->addr_ns_val = NULL;
+ }
+ if(NULL != msg_ctx_impl->rm_ns_val)
+ {
+ AXIS2_FREE(env->allocator, msg_ctx_impl->rm_ns_val);
+ msg_ctx_impl->rm_ns_val = NULL;
+ }
+ if(NULL != msg_ctx_impl->spec_ver)
+ {
+ AXIS2_FREE(env->allocator, msg_ctx_impl->spec_ver);
+ msg_ctx_impl->spec_ver = NULL;
+ }
+ if(NULL != msg_ctx_impl->msg_parts)
+ {
+ axis2_hash_free(msg_ctx_impl->msg_parts, env);
+ msg_ctx_impl->msg_parts = NULL;
+ }
+ if(NULL != rm_msg_ctx->ops)
+ {
+ AXIS2_FREE(env->allocator, rm_msg_ctx->ops);
+ rm_msg_ctx->ops = NULL;
+ }
+ AXIS2_FREE(env->allocator, SANDESHA2_INTF_TO_IMPL(rm_msg_ctx));
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_ctx(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_msg_ctx_t *msg_ctx)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ msg_ctx_impl->msg_ctx = msg_ctx;
+ return AXIS2_SUCCESS;
+}
+
+axis2_msg_ctx_t *AXIS2_CALL
+sandesha2_msg_ctx_get_msg_ctx(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ return SANDESHA2_INTF_TO_IMPL(rm_msg_ctx)->msg_ctx;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_add_soap_envelope(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ int soap_ver = AXIOM_SOAP11;
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ axis2_hash_index_t *hi = NULL;
+ axiom_soap_envelope_t *soap_envelope = NULL;
+
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+
+ if(AXIS2_FALSE == AXIS2_MSG_CTX_GET_IS_SOAP_11(msg_ctx_impl->msg_ctx, env))
+ soap_ver = AXIOM_SOAP12;
+ soap_envelope = AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx_impl->msg_ctx, env);
+ if(NULL == soap_envelope)
+ {
+ soap_envelope = axiom_soap_envelope_create_default_soap_envelope(env,
+ soap_ver);
+ AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx_impl->msg_ctx, env,
+ soap_envelope);
+ }
+
+ for(hi = axis2_hash_first(msg_ctx_impl->msg_parts, env); NULL != hi;
+ hi = axis2_hash_next(env, hi))
+ {
+ sandesha2_iom_rm_part_t *part = NULL;
+ void *value = NULL;
+
+ axis2_hash_this(hi, NULL, NULL, &value);
+ part = (sandesha2_iom_rm_part_t*)value;
+ SANDESHA2_IOM_RM_PART_TO_SOAP_ENVELOPE(part, env, soap_envelope);
+ }
+ return AXIS2_SUCCESS;
+}
+
+int AXIS2_CALL
+sandesha2_msg_ctx_get_msg_type (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ AXIS2_ENV_CHECK(env, -1);
+ return SANDESHA2_INTF_TO_IMPL(rm_msg_ctx)->msg_type;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_type (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int msg_type)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ msg_ctx_impl->msg_type = msg_type;
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_part (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int part_id,
+ sandesha2_iom_rm_part_t *part)
+{
+ axis2_char_t *part_id_str = NULL;
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, part, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ part_id_str = AXIS2_MALLOC(env->allocator, 32 * sizeof(axis2_char_t));
+ sprintf(part_id_str, "%d", part_id);
+ axis2_hash_set(msg_ctx_impl->msg_parts, part_id_str, AXIS2_HASH_KEY_STRING,
+ (const void*)part);
+ return AXIS2_SUCCESS;
+}
+
+sandesha2_iom_rm_part_t *AXIS2_CALL
+sandesha2_msg_ctx_get_msg_part(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int part_id)
+{
+ axis2_char_t part_id_str[32];
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ sprintf(part_id_str, "%d", part_id);
+ return axis2_hash_get(msg_ctx_impl->msg_parts, part_id_str,
+ AXIS2_HASH_KEY_STRING);
+}
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_from(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_FROM(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_from(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *from)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, from, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_TO(msg_ctx_impl->msg_ctx, env, from);;
+}
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_to (sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_TO(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *to)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, to, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_TO(msg_ctx_impl->msg_ctx, env, to);
+}
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_reply_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_REPLY_TO(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_reply_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *reply_to)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, reply_to, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_REPLY_TO(msg_ctx_impl->msg_ctx, env, reply_to);
+}
+
+axis2_endpoint_ref_t *AXIS2_CALL
+sandesha2_msg_ctx_get_fault_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_FAULT_TO(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_fault_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_endpoint_ref_t *fault_to)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, fault_to, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_FAULT_TO(msg_ctx_impl->msg_ctx, env, fault_to);
+}
+
+axis2_relates_to_t *AXIS2_CALL
+sandesha2_msg_ctx_get_relates_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_RELATES_TO(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_relates_to(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_relates_to_t *relates_to)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, relates_to, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_RELATES_TO(msg_ctx_impl->msg_ctx, env, relates_to);
+}
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_msg_id(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_WSA_MESSAGE_ID(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_msg_id(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *msg_id)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_MESSAGE_ID(msg_ctx_impl->msg_ctx, env, msg_id);
+}
+
+axiom_soap_envelope_t *AXIS2_CALL
+sandesha2_msg_ctx_get_soap_envelope(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_soap_envelope(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env,
+ axiom_soap_envelope_t *soap_envelope)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, soap_envelope, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx_impl->msg_ctx, env,
+ soap_envelope);
+}
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_wsa_action(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+
+ return AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_wsa_action(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *action)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, action, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+
+ return AXIS2_MSG_CTX_SET_WSA_ACTION(msg_ctx_impl->msg_ctx, env, action);
+}
+
+void *AXIS2_CALL
+sandesha2_msg_ctx_get_property(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *key)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, NULL);
+ AXIS2_PARAM_CHECK(env->error, key, NULL);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx_impl->msg_ctx, env, key,
+ AXIS2_FALSE);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_property(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *key, void *val)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, key, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ return AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx_impl->msg_ctx, env, key, val,
+ AXIS2_FALSE);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_soap_action(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *soap_action)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, soap_action, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ if(NULL == msg_ctx_impl->msg_ctx)
+ return AXIS2_FAILURE;
+
+ return AXIS2_MSG_CTX_SET_SOAP_ACTION(msg_ctx_impl->msg_ctx, env,
+ soap_action);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_paused(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_bool_t paused)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ if(NULL == msg_ctx_impl->msg_ctx)
+ return AXIS2_FAILURE;
+ return AXIS2_MSG_CTX_SET_PAUSED(msg_ctx_impl->msg_ctx, env, paused);
+}
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_rm_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ return SANDESHA2_INTF_TO_IMPL(rm_msg_ctx)->rm_ns_val;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_rm_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *ns_val)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, ns_val, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ if(NULL != msg_ctx_impl->rm_ns_val)
+ {
+ AXIS2_FREE(env->allocator, msg_ctx_impl->rm_ns_val);
+ msg_ctx_impl->rm_ns_val = NULL;
+ }
+ msg_ctx_impl->rm_ns_val = AXIS2_STRDUP(ns_val, env);
+ return AXIS2_SUCCESS;
+}
+
+axis2_char_t *AXIS2_CALL
+sandesha2_msg_ctx_get_addr_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ return SANDESHA2_INTF_TO_IMPL(rm_msg_ctx)->addr_ns_val;
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_addr_ns_val(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, axis2_char_t *ns_val)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, ns_val, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ if(NULL != msg_ctx_impl->addr_ns_val)
+ {
+ AXIS2_FREE(env->allocator, msg_ctx_impl->addr_ns_val);
+ msg_ctx_impl->addr_ns_val = NULL;
+ }
+ msg_ctx_impl->addr_ns_val = AXIS2_STRDUP(ns_val, env);
+ return AXIS2_SUCCESS;
+}
+
+int AXIS2_CALL
+sandesha2_msg_ctx_get_flow(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, -1);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ if(NULL == msg_ctx_impl->msg_ctx)
+ return -1;
+ return AXIS2_MSG_CTX_GET_FLOW(msg_ctx_impl->msg_ctx, env);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_msg_ctx_set_flow(sandesha2_msg_ctx_t *rm_msg_ctx,
+ const axis2_env_t *env, int flow)
+{
+ sandesha2_msg_ctx_impl_t *msg_ctx_impl = NULL;
+ AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+
+ msg_ctx_impl = SANDESHA2_INTF_TO_IMPL(rm_msg_ctx);
+ if(NULL == msg_ctx_impl->msg_ctx)
+ return AXIS2_FAILURE;
+
+ return AXIS2_MSG_CTX_SET_FLOW(msg_ctx_impl->msg_ctx, env, flow);
+}
Modified: webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am?rev=420631&r1=420630&r2=420631&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/Makefile.am Mon Jul 10 14:00:16 2006
@@ -1,8 +1,7 @@
TESTS =
noinst_LTLIBRARIES = libsandesha2_msgprocessors.la
-libsandesha2_msgprocessors_la_SOURCES =
+libsandesha2_msgprocessors_la_SOURCES = app_msg_processor.c
INCLUDES = -I$(top_builddir)/include \
- @AXIOMINC@ \
- @UTILINC@
+ @AXIS2INC@
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?rev=420631&r1=420630&r2=420631&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/msgprocessors/app_msg_processor.c (original)
+++ webservices/sandesha/trunk/c/src/msgprocessors/app_msg_processor.c Mon Jul 10 14:00:16 2006
@@ -15,7 +15,19 @@
*/
#include <sandesha2/sandesha2_app_msg_processor.h>
-#include <sandesha2/sandesa2_seq_ack.h>
+#include <sandesha2/sandesha2_seq_ack.h>
+#include <sandesha2/sandesha2_sequence.h>
+#include <sandesha2/sandesha2_ack_requested.h>
+#include <sandesha2/sandesha2_last_msg.h>
+#include <sandesha2/sandesha2_identifier.h>
+#include <sandesha2/sandesha2_invoker_bean_manager.h>
+#include <sandesha2/sandesha2_next_msg_bean_manager.h>
+#include <sandesha2/sandesha2_seq_property_bean_manager.h>
+#include <sandesha2/sandesha2_storage_manager.h>
+#include <sandesha2/sandesha2_constants.h>
+#include <sandesha2/sandesha2_utils.h>
+#include <axis2_string.h>
+#include <axis2_engine.h>
/**
* @brief Application Message Processor struct impl
* Sandesha2 App Msg Processor
@@ -71,6 +83,7 @@
sandesha2_app_msg_processor_process_response_msg(
sandesha2_msg_processor_t *msg_processor,
const axis2_env_t *env,
+ sandesha2_msg_ctx_t *msg_ctx,
axis2_char_t *internal_seq_id,
long msg_num,
axis2_char_t *storage_key,
@@ -97,7 +110,7 @@
/***************************** End of function headers ************************/
-AXIS2_DECLARE(sandesha2_msg_processor_t*)
+AXIS2_EXTERN sandesha2_msg_processor_t* AXIS2_CALL
sandesha2_app_msg_processor_create(const axis2_env_t *env,
sandesha2_msg_ctx_t *rm_msg_ctx)
{
@@ -128,7 +141,7 @@
msg_proc_impl->msg_processor.ops->process_in_msg =
sandesha2_app_msg_processor_process_in_msg;
msg_proc_impl->msg_processor.ops->process_out_msg =
- sandesha2_app_msg_processor_fprocess_out_msg;
+ sandesha2_app_msg_processor_process_out_msg;
msg_proc_impl->msg_processor.ops->free = sandesha2_app_msg_processor_free;
return &(msg_proc_impl->msg_processor);
@@ -141,7 +154,7 @@
{
sandesha2_app_msg_processor_impl_t *msg_proc_impl = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- msg_proc_impl = SANDESHA2_INTF_TO_IMPL(element);
+ msg_proc_impl = SANDESHA2_INTF_TO_IMPL(msg_processor);
if(NULL != msg_processor->ops)
AXIS2_FREE(env->allocator, msg_processor->ops);
@@ -176,21 +189,27 @@
axis2_char_t *str_key = NULL;
axis2_char_t *msgs_str = "";
axis2_char_t msg_num_str[32];
+ sandesha2_invoker_bean_manager_t *storage_map_mgr = NULL;
+ sandesha2_next_msg_bean_manager_t *next_bean_mgr = NULL;
+ sandesha2_next_msg_bean_t *next_msg_bean = NULL;
+ axis2_bool_t in_order_invoke = AXIS2_FALSE;
+ sandesha2_invoker_bean_t *invoker_bean = NULL;
+ sandesha2_seq_property_manager_t *next_bean_mgr = NULL;
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
seq_ack = SANDESHA2_MSG_CTX_GET_MSG_PART(msg_ctx, env,
SANDESHA2_MSG_PART_SEQ_ACKNOWLEDGEMENT);
if(NULL != seq_ack)
{
- sandesha2_ack_processor_t ack_proc = NULL;
+ sandesha2_ack_processor_t *ack_proc = NULL;
ack_proc = sandesha2_ack_processor_create(env);
SANDESHA2_MSG_PROCESSOR_PROCESS_IN_MSG(ack_proc, env, msg_ctx);
}
- ack_requested = SANDESHA2_MSG_CTX_GET_MSG_PART(msg_ctx, env,
- SANDESHA2_MSG_PART_ACK_REQUEST);
+ ack_requested = (sandesha2_ack_requested_t*)SANDESHA2_MSG_CTX_GET_MSG_PART(
+ msg_ctx, env, SANDESHA2_MSG_PART_ACK_REQUEST);
if(NULL != ack_requested)
{
SANDESHA2_ACK_REQUESTED_SET_MUST_UNDERSTAND(ack_requested, env,
@@ -217,7 +236,7 @@
return AXIS2_SUCCESS;
}
- op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
+ op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx1, env);
if (NULL != op_ctx)
{
ctx = AXIS2_OP_CTX_GET_BASE(op_ctx, env);
@@ -252,13 +271,13 @@
AXIS2_MSG_CTX_PAUSE(msg_ctx1, env);
return AXIS2_SUCCESS;
}
- seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_MANAGER(
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
storage_man, env);
sequence = SANDESHA2_MSG_CTX_GET_MSG_PART(msg_ctx, env,
SANDESHA2_MSG_PART_SEQUENCE);
SANDESHA2_SEQUNCE_SET_MUST_UNDERSTAND(sequence, env, AXIS2_FALSE);
str_seq_id = SANDESHA2_IDENTIFIER_GET_IDENTIFIER(
- SANDESHA2_SEQUENCE_GET_IDENTIFIER(sequence, env));
+ SANDESHA2_SEQUENCE_GET_IDENTIFIER(sequence, env), env);
fault_ctx = SANDESHA2_FAULT_MANAGER_CHECK_FOR_UNKNOWN_SEQ(fault_man, env,
msg_ctx, str_seq_id, storage_man);
if(NULL != fault_ctx)
@@ -278,7 +297,7 @@
SANDESHA2_MSG_CTX_ADD_SOAP_ENVELOPE(msg_ctx, env);
fault_ctx = SANDESHA2_FAULT_MANAGER_CHECK_FOR_SEQ_CLOSED(fault_man, env,
str_seq_id, storage_man);
- if(NULL != fault_code)
+ if(NULL != fault_ctx)
{
axis2_engine_t *engine = axis2_engine_create(env, conf_ctx);
if(AXIS2_FAILURE == AXIS2_ENGINE_SEND_FAULT(engine, env,
@@ -293,7 +312,7 @@
}
sandesha2_seq_manager_update_last_activated_time(env, str_seq_id,
storage_man);
- msgs_bean = SANDESHA2_SEQUENCE_PROPERTY_MANAGER_RETRIEVE(seq_prop_mgr, env,
+ msgs_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr, env,
str_seq_id,
SANDESHA2_SEQ_PROP_SERVER_COMPLETED_MESSAGES);
msg_no = SANDESHA2_MSG_NUMBER_GET_MSG_NUM(SANDESHA2_SEQUENCE_GET_MSG_NUM(
@@ -336,24 +355,22 @@
highest_in_msg_key_str, msg_ctx1);
if(NULL != highest_in_msg_no_str)
{
- SANDESHA2_SEQ_PROPERTY_MANAGER_UPDATE(seq_prop_mgr, env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_UPDATE(seq_prop_mgr, env,
highest_msg_no_bean);
- SANDESHA2_SEQ_PROPERTY_MANAGER_UPDATE(seq_prop_mgr, env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_UPDATE(seq_prop_mgr, env,
highest_msg_key_bean);
}
else
{
- SANDESHA2_SEQ_PROPERTY_MANAGER_INSERT(seq_prop_mgr, env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
highest_msg_no_bean);
- SANDESHA2_SEQ_PROPERTY_MANAGER_INSERT(seq_prop_mgr, env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
highest_msg_key_bean);
}
}
if(NULL != msgs_bean)
- {
msgs_str = SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(msgs_bean, env);
- }
else
{
msgs_bean = sandesha2_seq_property_bean_create(env);
@@ -370,13 +387,10 @@
SANDESHA2_MSG_CTX_PAUSE(msg_ctx, env);
}
if(NULL != msgs_str && 0 < AXIS2_STRLEN(msgs_str))
- {
msgs_str = axis2_strcat(env, msgs_str, ",", msg_num_str);
- }
else
- {
msgs_str = AXIS2_STRDUP(msg_num_str, env);
- }
+
SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(msgs_bean, env, msgs_str);
SANDESHA2_SEQ_PROPERY_MANAGER_UPDATE(seq_prop_mgr, env, msgs_bean);
@@ -390,7 +404,70 @@
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
-
+ storage_map_mgr = SANDESHA2_STORAGE_MANAGER_GET_STORAGE_MAP_BEAN_MANAGER(
+ storage_man, 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(AXIS2_TRUE == in_order_invoke)
+ {
+ sandesha2_seq_property_bean_t *incoming_seq_list_bean = NULL;
+ axis2_array_list_t *incoming_seq_list = NULL;
+
+ incoming_seq_list_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(
+ seq_prop_mgr, env, SANDESHA2_SEQ_PROP_ALL_SEQUENCES,
+ SANDESHA2_SEQ_PROP_INCOMING_SEQUENCE_LIST);
+ if(NULL == incoming_seq_list_bean)
+ {
+ /**
+ * Our array to_string format is [ele1,ele2,ele3]
+ * here we don't have a list so [] should be passed
+ */
+ incoming_seq_list_bean = sandesha2_seq_property_bean_create(env);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_SEQ_ID(incoming_seq_list_bean, env,
+ SANDESHA2_SEQ_PROP_ALL_SEQUENCES);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_NAME(incoming_seq_list_bean, env,
+ SANDESHA2_SEQ_PROP_INCOMING_SEQUENCE_LIST);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(incoming_seq_list_bean,
+ env, "[]");
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ incoming_seq_list_bean);
+ }
+ incoming_seq_list = sandesha2_utils_get_array_list_from_string(env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(
+ incoming_seq_list_bean, env));
+ /* Adding current sequence to the incoming sequence List */
+ if(AXIS2_FALSE == sandesha2_utils_array_list_contains(env,
+ incoming_seq_list, str_seq_id))
+ {
+ axis2_char_t *str_seq_list = NULL;
+ AXIS2_ARRAY_LIST_ADD(incoming_seq_list, env, str_seq_id);
+ str_seq_list = sandesha2_utils_array_list_to_string(env,
+ incoming_seq_list);
+ /* saving the property. */
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_VALUE(incoming_seq_list_bean,
+ env, str_seq_list);
+ AXIS2_FREE(env->allocator, str_seq_list);
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_UPDATE(seq_prop_mgr, env,
+ incoming_seq_list_bean);
+ }
+ /* save the message */
+ SANDESHA2_STORAGE_MANAGER_STORE_MSG_CTX(storage_man, env, str_key,
+ msg_ctx1);
+ invoker_bean = sandesha2_invoker_bean_create_with_data(env, str_key,
+ msg_no, str_seq_id, AXIS2_FALSE);
+ SANDESHA2_STORAGE_MAP_MANAGER_INSERT(storage_map_mgr, env, invoker_bean);
+ /* To avoid performing application processing more than once. */
+ SANDESHA2_MSG_CTX_SET_PROPERTY(msg_ctx, env,
+ SANDESHA2_APPLICATION_PROCESSING_DONE,
+ SANDESHA2_VALUE_TRUE);
+ SANDESHA2_MSG_CTX_PAUSE(msg_ctx, env);
+ /* Start the invoker if stopped */
+ sandesha2_utils_start_invoker_for_seq(env, conf_ctx, str_seq_id);
+ }
+ sandesha2_app_msg_processor_send_ack_if_reqd(msg_processor, env, msg_ctx,
+ msgs_str, storage_man);
+ return AXIS2_SUCCESS;
}
@@ -400,10 +477,393 @@
const axis2_env_t *env,
sandesha2_msg_ctx_t *msg_ctx)
{
+ axis2_msg_ctx_t *msg_ctx1 = NULL;
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ sandesha2_storage_manager_t *storage_man = NULL;
+ sandesha2_seq_property_bean_manager_t *seq_prop_mgr = NULL;
+ axis2_bool_t *is_svr_side = AXIS2_FALSE;
+ axis2_char_t *internal_seq_id = NULL;
+ axis2_char_t *storage_key = NULL;
+ axis2_bool_t last_msg = AXIS2_FALSE;
+ axis2_property_t *property = NULL;
+ long msg_num_lng = -1;
+ long system_msg_num = -1;
+ long msg_number = -1;
+ axis2_char_t *dummy_msg_str = NULL;
+ axis2_bool_t dummy_msg = AXIS2_FALSE;
+ sandesha2_seq_property_bean_t *res_highest_msg_bean = NULL;
+ axis2_char_t *msg_number_str[32];
+ axis2_bool_t send_create_seq = AXIS2_FALSE;
+ axis2_char_t *spec_ver = NULL;
+ axiom_soap_envelope_t *soap_env = NULL;
+ axis2_endpoint_ref_t *to_epr = NULL;
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ msg_ctx1 = SANDESHA2_MSG_CTX_GET_MSG_CTX(msg_ctx, env);
+ conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx1, env);
+ /* TODO setting up fault callback */
+ storage_man = sandesha2_utils_get_storage_manager(env, conf_ctx,
+ AXIS2_CONF_CTX_GET_CONF(conf_ctx, env));
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ storage_man, env);
+ is_svr_side = AXIS2_MSG_CTX_IS_SERVER_SIDE(msg_ctx1, env);
+
+ to_epr = AXIS2_MSG_CTX_GET_TO(msg_ctx1, env);
+ if(NULL == to_epr || NULL == 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");
+ return AXIS2_FAILURE;
+ }
+
+ if(NULL == AXIS2_MSG_CTX_GET_MSG_ID(msg_ctx1, env))
+ AXIS2_MSG_CTX_SET_MSG_ID(axis2_uuid_gen(env));
+ storage_key = axis2_uuid_gen(env);
+
+ if(AXIS2_TRUE == is_svr_side)
+ {
+ axis2_msg_ctx_t *req_msg_ctx = NULL;
+ sandesha2_msg_ctx_t *req_rm_msg_ctx = NULL;
+ sandesha2_sequence_t *req_sequence = NULL;
+ long request_msg_no = NULL;
+ axis2_char_t *req_last_msg_num_str = NULL;
+
+ req_msg_ctx = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(
+ msg_ctx1, env), env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
+ req_rm_msg_ctx = sandesha2_msg_initilizer_initilize_msg(env, req_msg_ctx);
+ req_sequence = SANDESHA2_MSG_CTX_GET_MSG_PART(req_rm_msg_ctx, env,
+ SANDESHA2_MSG_PART_SEQUENCE);
+ if(NULL == req_sequence)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sequence is NULL");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SEQ_NOT_EXIST,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ incoming_seq_id = SANDESHA2_IDENTIFIER_GET_IDENTIFIER(
+ SANDESHA2_SEQUENCE_GET_IDENTIFIER(sequence, env), env);
+ if(NULL == incoming_seq_id)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sequence ID is NULL");
+ return AXIS2_FAILURE;
+ }
+ request_msg_no = SANDESHA2_MSG_NUMBER_GET_MSG_NUM(
+ SANDESHA2_SEQUENCE_GET_MSG_NUM(sequence, env), env);
+ internal_seq_id = sandesha2_utils_get_outgoing_internal_seq_id(env,
+ incoming_seq_id);
+ req_last_msg_num_str = sandesha2_utils_get_seq_property(env,
+ incoming_seq_id, SANDESHA2_SEQ_PROP_LAST_IN_MESSAGE_NO,
+ storage_man);
+ if(NULL != req_last_msg_num)
+ {
+ long req_last_msg_num = atol(req_last_msg_num_str);
+ if(req_last_msg_num_str == request_msg_no)
+ last_msg = AXIS2_TRUE;
+ }
+ }
+ else
+ {
+ axis2_char_t *to = NULL;
+ axis2_char_t *seq_key = NULL;
+ axis2_char_t *last_app_msg = NULL;
+
+ to = AXIS2_ENDPOINT_REF_GET_ADDRESS(to_epr, env);
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx1, env,
+ SANDESHA2_CLIENT_CONST_SEQUENCE_KEY, AXIS2_FALSE);
+ if(NULL != property)
+ seq_key = AXIS2_PROPERTY_GET_VALUE(property, env);
+ internal_seq_id = sandesha2_utils_get_internal_seq_id(env, to, seq_key);
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx, env,
+ SANDESHA2_CLIENT_CONST_LAST_MESSAGE, AXIS2_FALSE);
+ if(NULL != property)
+ last_app_msg = AXIS2_PROPERTY_GET_VALUE(property, env);
+ if(NULL != last_app_msg && 0 == AXIS2_STRCMP(last_app_msg,
+ SANDESHA2_VALUE_TRUE))
+ last_msg = AXIS2_TRUE;
+ }
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx1, env,
+ SANDESHA2_CLIENT_CONST_MESSAGE_NUMBER, AXIS2_FALSE);
+ if(NULL != property)
+ msg_num_lng = *(AXIS2_PROPERTY_GET_VALUE(property, env));
+ if(msg_num_lng <= 0)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid message number");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_MSG_NUM,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ system_msg_num = sandesha2_app_msg_processor_get_prev_msg_no(msg_processor,
+ env, internal_seq_id, storage_man);
+ if(msg_num_lng => 0 && msg_num_lng <= system_msg_num)
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_MSG_NUM,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ if(msg_num_lng > 0)
+ msg_number = msg_num_lng;
+ else if(system_msg_num > 0)
+ msg_number = system_msg_num + 1;
+ else
+ msg_number = 1;
+
+ /* A dummy message is a one which will not be processed as a actual
+ * application message. The RM handlers will simply let these go.
+ */
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx1, env,
+ SANDESHA2_CLIENT_CONST_DUMMY_MESSAGE, AXIS2_FALSE);
+ if(NULL != property)
+ dummy_msg_str = AXIS2_PROPERTY_GET_VALUE(property, env);
+ if(NULL != dummy_msg_str && 0 == AXIS2_STRCMP(dummy_msg_str,
+ SANDESHA2_VALUE_TRUE))
+ dummy_msg = AXIS2_TRUE;
+ if(AXIS2_FALSE == dummy_msg)
+ sandesha2_app_msg_processor_set_next_msg_no(msg_processor, env,
+ internal_seq_id, msg_number, storage_man);
+
+ sprintf(msg_number_str, "%ld", msg_number);
+ res_highest_msg_bean = sandesha2_seq_property_bean_create_with_data(env,
+ internal_seq_id,
+ SANDESHA2_SEQ_PROP_HIGHEST_OUT_MSG_NUMBER,
+ msg_number_str);
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ res_highest_msg_bean);
+ if(AXIS2_TRUE == last_msg)
+ {
+ sandesha2_seq_property_bean_t *res_highest_msg_key_bean = NULL;
+ sandesha2_seq_property_bean_t *res_last_msg_key_bean = NULL;
+
+ res_highest_msg_key_bean = sandesha2_seq_property_bean_create_with_data(
+ env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_HIGHEST_OUT_MSG_KEY,
+ storage_key);
+ res_last_msg_key_bean = sandesha2_seq_property_bean_create_with_data(
+ env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_LAST_OUT_MESSAGE_NO,
+ msg_number_str);
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ res_highest_msg_key_bean);
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ res_last_msg_key_bean);
+ }
+ if(AXIS2_TRUE == is_svr_side)
+ {
+ axis2_char_t *incoming_seq_id = NULL;
+ sandesha2_seq_property_bean_t *incoming_to_bean = NULL;
+ incoming_seq_id = sandesha2_utils_get_incoming_seq_id(env,
+ internal_seq_id);
+ incoming_to_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(
+ seq_prop_mgr, env, incoming_seq_id,
+ SANDESHA2_SEQ_PROP_TO_EPR);
+ if(NULL != incoming_to_bean)
+ {
+ axis2_char_t *incoming_to = NULL;
+ incoming_to = SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(incoming_to_bean,
+ env);
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, incoming_to);
+ AXIS2_MSG_CTX_SET_PROPERTY(msg_ctx1, env, SANDESHA2_SEQ_PROP_TO_EPR,
+ property, AXIS2_FALSE);
+ }
+ }
+ if(AXIS2_TRUE == is_svr_side)
+ {
+ axis2_msg_ctx_t *req_msg_ctx = NULL;
+ sandesha2_msg_ctx_t *req_rm_msg_ctx = NULL
+ sandesha2_sequence_t *sequence = NULL;
+ axis2_char_t *req_seq_id = NULL;
+ sandesha2_seq_property_bean_t *spec_ver_bean = NULL;
+
+ req_msg_ctx = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx1,
+ env), env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
+ if(NULL == req_msg_ctx)
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_MSG_CTX,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ req_rm_msg_ctx = sandesha2_msg_initilizer_initilize_msg(env, req_msg_ctx);
+ sequence = SANDESHA2_MSG_CTX_GET_MSG_PART(req_rm_msg_ctx, env,
+ SANDESHA2_MSG_PART_SEQUENCE);
+ req_seq_id = SANDESHA2_IDENTIFIER_GET_IDENTIFIER(
+ SANDESHA2_SEQUNCE_GET_IDENTIFIER(sequence, env), env);
+ spec_ver_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr,
+ env, req_seq_id, SANDESHA2_SEQ_PROP_RM_SPEC_VERSION);
+ if(NULL == spec_ver_bean)
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_SPEC_VERSION,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ spec_ver = SANDEHSA2_SEQ_PROPERTY_BEAN_GET_VALUE(spec_ver_bean, env);
+ }
+ else
+ {
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx1, env,
+ SANDESHA2_CLIENT_CONST_RM_SPEC_VERSION, AXIS2_FALSE);
+ if(NULL != property)
+ spec_ver = AXIS2_PROPERTY_GET_VALUE(property, env);
+ }
+ if(NULL == spec_ver)
+ spec_ver = sandesha2_spec_specific_consts_get_default_spec_version(env);
+ if(1 == msg_number)
+ {
+ if(NULL == out_seq_bean)
+ send_create_seq = AXIS2_TRUE;
+ sandesha2_seq_manager_setup_new_client_seq(env, msg_ctx1,
+ internal_seq_id, spec_ver, storage_man);
+ }
+ if(AXIS2_TRUE == send_create_seq)
+ {
+ sandesha2_seq_property_bean_t *res_create_seq_added = NULL;
+ axis2_char_t *addr_ns_uri = NULL;
+ axis2_char_t *anon_uri = NULL;
+
+ res_create_seq_added = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(
+ seq_prop_mgr, env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_OUT_CREATE_SEQUENCE_SENT);
+ addr_ns_uri = sandesha2_utils_get_seq_property(env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_ADDRESSING_NAMESPACE_VALUE);
+ anon_uri = sandesha2_spec_specific_consts_get_anon_uri(env, addr_ns_uri);
+ if(NULL == res_create_seq_added)
+ {
+ axis2_char_t *acks_to = NULL;
+
+ res_create_seq_added = sandesha2_seq_property_bean_create_with_data(
+ env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_OUT_CREATE_SEQUENCE_SENT,
+ SANDESHA2_VALUE_TRUE);
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ res_create_seq_added);
+ if(NULL != AXIS2_MSG_CTX_GET_SVC_CTX(msg_ctx1, env))
+ {
+ property = AXIS2_MSG_CTX_GET_PROPERTY(msg_ctx1, env,
+ SANDESHA2_CLIENT_CONSTS_ACKS_TO, AXIS2_FALSE);
+ if(NULL != property)
+ acks_to = AXIS2_PROPERTY_GET_VALUE(property, env);
+ }
+ if(AXIS2_TRUE == is_svr_side)
+ {
+ axis2_msg_ctx_t *req_msg_ctx = NULL;
+ req_msg_ctx = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(
+ msg_ctx1, env), env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
+ if(NULL == req_msg_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Request message is"
+ "NULL");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_MSG_CTX,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ acks_to = AXIS2_ENDPOINT_REF_GET_ADDRESS(AXIS2_MSG_CTX_GET_TO(
+ msg_ctx1, env), env);
+ }
+ else if(NULL == acks_to)
+ acks_to = anon_uri;
+
+ if(NULL == acks_to && is_svr_side)
+ {
+ axis2_char_t *incoming_seq_id = NULL;
+ sandesha2_seq_property_bean_t *reply_to_epr_bean = NULL;
+
+ incoming_seq_id = sandesha2_utils_get_incoming_seq_id(env,
+ internal_seq_id);
+ reply_to_epr_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(
+ seq_prop_mgr, env, incoming_seq_id,
+ SANDESHA2_SEQ_PROP_REPLY_TO_EPR);
+ if(NULL != reply_to_epr_bean)
+ {
+ axis2_endpoint_ref_t *acks_epr = NULL;
+ acks_epr = axis2_endpoint_ref_create(env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(reply_to_epr_bean,
+ env));
+ if(NULL != acks_epr)
+ acks_to = AXIS2_ENDPOINT_REF_GET_ADDRESS(acks_epr, env);
+ }
+ }
+ /**
+ * else if()
+ * TODO handle acks_to == anon_uri case
+ */
+ sandesha2_app_msg_processor_add_create_seq_msg(msg_processor, env,
+ msg_ctx, internal_seq_id, acks_to, storage_man);
+ }
+ }
+ soap_env = SANDESHA2_MSG_CTX_GET_SOAP_ENVELOPE(msg_ctx, env);
+ if(NULL == soap_env)
+ {
+ soap_env = axiom_soap_envelope_create_default_soap_envelope(env,
+ AXIOM_SOAP12);
+ SANDESHA2_MSG_CTX_SET_SOAP_ENVELOPE(msg_ctx, env, soap_env);
+ }
+ msg_id1 = axis2_uuid_gen(env);
+ if(NULL == SANDESHA2_MSG_CTX_GET_MSG_ID(msg_ctx, env))
+ SANDESHA2_MSG_CTX_SET_MSG_ID(msg_ctx, env, msg_id1);
+
+ if(AXIS2_TRUE == is_svr_side)
+ {
+ /* let the request end with 202 if a ack has not been
+ * written in the incoming thread
+ */
+ axis2_msg_ctx_t *req_msg_ctx = NULL;
+ axis2_char_t *written = NULL;
+
+ req_msg_ctx = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(
+ msg_ctx1, env), env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
+ if(NULL == req_msg_ctx)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Request message is"
+ "NULL");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_MSG_CTX,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ property = AXIS2_MSG_CTX_GET_PROPERTY(req_msg_ctx, env,
+ SANDESHA2_ACK_WRITTEN, AXIS2_FALSE);
+ if(NULL != property)
+ written = AXIS2_PROPERTY_GET_VALUE(property, env);
+ if(NULL == written || 0 != AXIS2_STRCMP(written, SANDESHA2_VALUE_TRUE))
+ {
+ axis2_op_ctx_t *op_ctx = NULL;
+ axis2_ctx_t *ctx = NULL;
+ op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx, env);
+ if (NULL != op_ctx)
+ {
+ ctx = AXIS2_OP_CTX_GET_BASE(op_ctx, env);
+ if (NULL != ctx)
+ {
+ property = axis2_property_create(env);
+ AXIS2_PROPERTY_SET_SCOPE(property, env, AXIS2_SCOPE_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, AXIS2_STRDUP("TRUE",
+ env));
+ AXIS2_CTX_SET_PROPERTY(req_msg_ctx, env,
+ AXIS2_RESPONSE_WRITTEN, property, AXIS2_FALSE);
+ }
+ }
+ }
+ }
+ op_name = AXIS2_QNAME_GET_LOCALPART(AXIS2_OP_GET_QNAME(AXIS2_OP_CTX_GET_OP(
+ AXIS2_MSG_CTX_GET_OP_CTX(msg_ctx1, env), env), env),
+ env);
+ to_addr = AXIS2_ENDPOINT_REF_GET_ADDRESS(to_epr, env);
+ if(NULL == AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx1, env))
+ AXIS2_MSG_CTX_SET_WSA_ACTION(msg_ctx1, env, axis2_strcat(env, to_addr,
+ "/", op_name, NULL));
+ if(NULL == AXIS2_MSG_CTX_GET_SOAP_ACTION(msg_ctx1, env))
+ AXIS2_MSG_CTX_SET_SOAP_ACTION(msg_ctx1, env, axis2_strcat(env, "\"",
+ to_addr, "/", op_name, "\"", NULL));
+
+ if(AXIS2_FALSE == dummy_msg)
+ sandesha2_app_msg_processor_process_response_msg(msg_processor, env,
+ msg_ctx, internal_seq_id, msg_number, storage_key,
+ storage_man);
+ AXIS2_MSG_CTX_PAUSE(msg_ctx1, env);
}
axis2_bool_t AXIS2_CALL
@@ -413,12 +873,19 @@
axis2_char_t *list,
long num)
{
- AXIS2_ENV_CHECK(env, AXIS2_FALSE);
- AXIS2_PARAM_CHECK(env->allocator, list, AXIS2_FALSE);
+ axis2_char_t *str_long[32];
+ AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+ AXIS2_PARAM_CHECK(env->error, list, AXIS2_FALSE);
+ sprintf(str_long, "%ld", num);
+ if(NULL != strstr(list, str_long))
+ return AXIS2_TRUE;
+
+ return AXIS2_FALSE;
}
-
+
+
axis2_status_t AXIS2_CALL
sandesha2_app_msg_processor_send_ack_if_reqd(
sandesha2_msg_processor_t *msg_processor,
@@ -427,10 +894,46 @@
axis2_char_t *msg_str,
sandesha2_storage_manager_t *manager)
{
+ sandesha2_sequence_t *sequence = NULL;
+ axis2_char_t *seq_id = NULL;
+ axis2_conf_ctx_t *conf_ctx = NULL;
+ sandesha2_ack_requested_t *ack_requested = NULL;
+ sandesha2_msg_ctx_t *ack_rm_msg = NULL;
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, msg_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, msg_str, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, manager, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_ctx, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, msg_str, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, manager, AXIS2_FAILURE);
+
+ sequence = SANDESHA2_MSG_CTX_GET_MSG_PART(msg_ctx, env,
+ SANDESHA2_MSG_PART_SEQUENCE);
+ seq_id = SANDESHA2_IDENTIFIER_GET_IDENTIFIER(
+ SANDESHA2_SEQUENCE_GET_IDENTIFIER(sequence, env), env);
+ conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(SANDESHA2_MSG_CTX_GET_MSG_CTX(msg_ctx,
+ env), env);
+ if(NULL == conf_ctx)
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_CONF_CTX, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ ack_requested = SANDESHA2_MSG_CTX_GET_MSG_PART(msg_ctx, env,
+ SANDESHA2_MSG_PART_ACK_REQUEST);
+ if(NULL != ack_requested)
+ {
+ SANDESHA2_ACK_REQUESTED_SET_MUST_UNDERSTAND(ack_requested, env,
+ AXIS2_FALSE);
+ SANDESHA2_MSG_CTX_ADD_SOAP_ENVELOPE(msg_ctx, env);
+ }
+ ack_rm_msg = sandesha2_ack_manager_generate_ack_msg(env, msg_ctx, seq_id,
+ manager);
+ engine = axis2_engine_create(env, conf_ctx);
+ if(AXIS2_SUCCESS != AXIS2_ENGINE_SEND(engine, env,
+ SANDESHA2_MSG_CTX_GET_MSG_CTX(ack_rm_msg, env)))
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_ACK, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
@@ -442,30 +945,351 @@
axis2_char_t *acks_to,
sandesha2_storage_manager_t *manager)
{
+ axis2_msg_ctx_t *msg_ctx1 = NULL;
+ sandesha2_create_seq_t *create_seq_part = NULL;
+ sandesha2_msg_ctx_t *create_seq_rm_msg = NULL;
+ sandesha2_seq_property_bean_manager_t *seq_prop_mgr = NULL;
+ sandesha2_create_seq_bean_manager_t *create_seq_man = NULL;
+ sandesha2_sender_bean_manager_t *retransmitter_man = NULL;
+ sandesha2_seq_offer_t *seq_offer = NULL;
+ axis2_msg_ctx_t *create_seq_msg = NULL;
+ sandesha2_create_seq_bean_t *create_seq_bean = NULL;
+ axis2_char_t *addr_ns_uri = NULL;
+ axis2_char_t *anon_uri = NULL;
+ axis2_char_t *str_key = NULL;
+ sandesha2_sender_bean_t *create_seq_entry = NULL;
+ struct AXIS2_PLATFORM_TIMEB t1;
+ long millisecs = 0;
+ axis2_transport_out_desc_t *orig_trans_out = NULL;
+ axis2_transport_out_desc_t *trans_out = NULL;
+ axis2_engine_t *engine = NULL;
+
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, msg_ctx, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, internal_seq_id, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, acks_to, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, manager, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, 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, manager, AXIS2_FAILURE);
+ msg_ctx1 = SANDESHA2_MSG_CTX_GET_MSG_CTX(msg_ctx, env);
+ create_seq_rm_msg = sandesha2_msg_creator_create_create_seq_msg(env,
+ msg_ctx, internal_seq_id, acks_to, manager);
+ SANDESHA2_MSG_CTX_SET_FLOW(create_seq_rm_msg, env,
+ SANDESHA2_MSG_CTX_OUT_FLOW);
+
+ create_seq_part = SANDESHA2_MSG_CTX_GET_MSG_PART(create_seq_rm_msg, env,
+ SANDESHA2_MSG_PART_CREATE_SEQ);
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ manager, env);
+ create_seq_man = SANDESHA2_STORAGE_MANAGER_GET_CREATE_SEQ_BEAN_MANAGER(
+ manager, env);
+ retransmitter_man = SANDESHA2_STORAGE_MANAGER_GET_RETRANSMITTER_BEAN_MANAGER
+ (manager, env);
+ seq_offer = SANDESHA2_CREATE_SEQ_GET_SEQ_OFFER(create_seq_part, env);
+ if(NULL != seq_offer)
+ {
+ axis2_char_t *seq_offer_id = NULL;
+ sandesha2_sequece_property_bean_t *offer_seq_bean = NULL;
+
+ seq_offer_id = SANDESHA2_SEQ_OFFER_GET_IDENTIFIER(seq_offer, env);
+ offer_seq_bean = sandesha2_sequence_property_bean_create(env);
+ SANDESHA2_SEQUENCE_PROPERTY_BEAN_SET_NAME(offer_seq_bean, env,
+ SANDESHA2_SEQ_PROP_OFFERED_SEQUENCE);
+ SANDESHA2_SEQUENCE_PROPERTY_BEAN_SET_SEQUENCE_ID(offer_seq_bean, env,
+ internal_seq_id);
+ SANDESHA2_SEQUENCE_PROPERTY_BEAN_SET_VALUE(offer_seq_bean, env,
+ seq_offer_id);
+ SANDESHA2_SEQUNCE_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ 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_MSG_CTX_GET_WSA_MESSAGE_ID(
+ create_seq_msg, env), NULL);
+ SANDESHA2_CREATE_SEQ_BEAN_MANAGER_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,
+ storage_man);
+ 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))
+ {
+ axis2_endpoint_ref_t *cs_epr = NULL;
+ cs_epr = axis2_endpoint_ref_create(env, anon_uri);
+ AXIS2_MSG_CTX_SET_REPLY_TO(create_seq_msg, env, cs_epr);
+ }
+ str_key = axis2_uuid_gen(env);
+ create_seq_entry = sandesha2_sender_bean_create(env);
+ SANDESHA2_SENDER_BEAN_SET_MSG_CONTEXT_REF_KEY(create_seq_entry, env,
+ str_key);
+ AXIS2_PLATFORM_GET_TIME_IN_MILLIS(&t1);
+ millisecs = 1000 * (t1.time) + t1.millitm;
+ SANDESHA2_SENDER_BEAN_SET_TIME_TO_SEND(create_seq_entry, env, millisecs);
+ SANDESHA2_SENDER_BEAN_SET_MSG_ID(create_seq_entry, env,
+ SANDESHA2_MSG_CTX_GET_MSG_ID(create_seq_rm_msg, env));
+ SANDESHA2_SENDER_BEAN_SET_INTERNAL_SEQ_ID(create_seq_entry, env,
+ 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_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
+ SANDESHA2_QUALIFIED_FOR_SENDING, property,
+ AXIS2_FALSE);
+ SANDESHA2_SENDER_BEAN_SET_MSG_TYPE(create_seq_entry, env,
+ SANDESHA2_MSG_TYPE_CREATE_SEQ);
+ SANDESHA2_SENDER_BEAN_MANAGER_INSERT(retransmitter_man, env,
+ create_seq_entry);
+ SANDESHA2_STORAGE_MANAGER_STORE_MSG_CTX(manager, env, 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);
+ 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_REQUEST);
+ AXIS2_PROPERTY_SET_VALUE(property, env, orig_trans_out);
+ AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
+ 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_MSG_CTX_SET_PROPERTY(create_seq_msg, env, SANDESHA2_SET_SEND_TO_TRUE,
+ 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))
+ return AXIS2_FAILURE;
+
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
sandesha2_app_msg_processor_process_response_msg(
sandesha2_msg_processor_t *msg_processor,
const axis2_env_t *env,
+ sandesha2_msg_ctx_t *msg_ctx,
axis2_char_t *internal_seq_id,
long msg_num,
axis2_char_t *storage_key,
sandesha2_storage_manager_t *manager)
{
+ axis2_msg_ctx_t *msg = NULL;
+ sandesha2_seq_property_bean_manager_t *seq_prop_mgr = NULL;
+ sandesha2_sender_bean_manager_t *retransmitter_man = NULL;
+ sandesha2_seq_property_bean_t *to_bean = NULL;
+ sandesha2_seq_property_bean_t *reply_to_bean = NULL;
+ sandesha2_seq_property_bean_t *out_seq_bean = NULL;
+ axis2_endpoint_ref_t *to_epr = NULL;
+ axis2_endpoint_ref_t *reply_to_epr = NULL;
+ axis2_char_t *new_to_str = NULL;
+ sandesha2_msg_ctx_t *req_rm_msg = NULL;
+ sandesha2_sequence_t *sequence = NULL;
+ sandesha2_sequence_t *req_sequence = NULL;
+ axis2_char_t *rm_version = NULL;
+ axis2_char_t *rm_ns_val = NULL;
+ sandesha2_msg_number_t *msg_number = NULL;
+ axis2_msg_ctx_t *req_msg = NULL;
+ sandesha2_ack_requested_t *ack_requested = NULL;
+ axis2_char_t *str_identifier = NULL;
+ sandesha2_sender_bean_t *app_msg_entry = NULL;
+ struct AXIS2_PLATFORM_TIMEB t1;
+ long millisecs = 0;
+ axis2_property_t *property = NULL;
+ axis2_transport_sender_t *trs_sender = NULL;
+ axis2_engine_t *engine = NULL;
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, internal_seq_id, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, storage_key, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, manager, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, internal_seq_id, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, storage_key, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, manager, AXIS2_FAILURE);
+
+ msg = SANDESHA2_MSG_CTX_GET_MSG_CTX(msg_ctx, env);
+
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ manager, env);
+ retransmitter_man = SANDESHA2_STORAGE_MANAGER_GET_RETRANS_BEAN_MANAGER
+ (manager, env);
+ to_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr, env,
+ internal_seq_id, SANDESHA2_SEQ_PROP_TO_EPR);
+ reply_to_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr, env,
+ internal_seq_id, SANDESHA2_SEQ_PROP_REPLY_TO_EPR);
+ out_seq_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr, env,
+ internal_seq_id, SANDESHA2_SEQ_PROP_OUT_SEQUENCE_ID);
+ if(NULL != to_bean)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] To is NULL");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_TO, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ to_epr = axis2_endpoint_ref_create(env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(to_bean, env));
+ if(NULL != reply_to_bean)
+ reply_to_epr = axis2_endpoint_ref_create(env,
+ SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(reply_to_bean,
+ env));
+
+ req_msg = AXIS2_OP_CTX_GET_MSG_CTX(AXIS2_MSG_CTX_GET_OP_CTX(msg, env),
+ env, AXIS2_WSDL_MESSAGE_LABEL_IN_VALUE);
+ if(AXIS2_TRUE == AXIS2_MSG_CTX_IS_SERVER_SIDE(msg, env))
+ {
+ axis2_endpoint_ref_t *reply_to = NULL;
+
+ reply_to = AXIS2_MSG_CTX_GET_REPLY_TO(req_msg, env);
+ new_to_str = AXIS2_ENDPOINT_REF_GET_ADDRESS(reply_to, env);
+ }
+ if(NULL != new_to_str)
+ SANDESHA2_MSG_CTX_SET_TO(msg_ctx, env, axis2_endpoint_ref_create(env,
+ new_to_str));
+ else
+ SANDESHA2_MSG_CTX_SET_TO(msg_ctx, env, axis2_endpoint_ref_create(env,
+ to_epr));
+
+ if(NULL != reply_to_epr)
+ SANDESHA2_MSG_CTX_SET_REPLY_TO(msg_ctx, env, reply_to_epr);
+
+ rm_version = sandesha2_utils_get_rm_version(env, internal_seq_id, manager);
+ if(NULL == rm_version)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to fine RM spec version");
+ return AXIS2_FAILURE;
+ }
+ rm_ns_val = sandesha2_spec_specific_consts_get_rm_ns_val(env, rm_version);
+ sequence = sandesha2_sequence_create(env, rm_ns_val);
+ msg_number = sandesha2_msg_number_create(env, rm_ns_val);
+ SANDESHA2_MSG_NUMBER_SET_MSG_NUM(msg_number, env, msg_num);
+ SANDESHA2_SEQUENCE_SET_MSG_NUM(sequence, env, msg_num);
+
+ if(AXIS2_TRUE == AXIS2_MSG_CTX_IS_SERVER_SIDE(msg, env))
+ {
+ req_rm_msg = sandesha2_msg_initilizer_initilize_msg(env, req_msg);
+ req_sequence = SANDESHA2_MSG_CTX_GET_MSG_PART(req_rm_msg, env,
+ SANDESHA2_MSG_PART_SEQUENCE);
+ if(NULL == sequence)
+ {
+ AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Sequence not found");
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NULL_SEQUENCE,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ if(NULL != SANDESHA2_SEQUENCE_GET_LAST_MSG(sequence, env))
+ SANDESHA2_SEQUENCE_SET_LAST_MSG(sequence, env,
+ sandesha2_last_msg_create(env, rm_ns_val));
+ }
+ else
+ {
+ axis2_op_ctx_t *op_ctx = NULL;
+ axis2_property_t *property = NULL;
+ axis2_ctx_t *ctx = NULL;
+
+ op_ctx = AXIS2_MSG_CTX_GET_OP_CTX(msg, env);
+ if(NULL != op_ctx)
+ {
+ ctx = AXIS2_OP_CTX_GET_BASE(op_ctx, env);
+ property = AXIS2_CTX_GET_PROPERTY(ctx, env,
+ SANDESHA2_CLIENT_CONST_LAST_MESSAGE, AXIS2_FALSE);
+ if(NULL != property)
+ {
+ axis2_char_t *value = AXIS2_PROPERTY_GET_VALUE(property, env);
+ if(NULL != 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, manager);
+ if(AXIS2_TRUE ==
+ sandesha2_spec_specific_consts_is_last_msg_indicator_reqd
+ (env, spec_ver))
+ {
+ SANDESHA2_SEQUENCE_SET_LAST_MSG(sequence, env,
+ sandesha2_last_msg_create(env, rm_ns_val));
+ }
+ }
+ }
+ }
+ }
+ if(NULL == out_seq_bean || NULL == SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(
+ out_seq_bean, env))
+ str_identifier = SANDESHA2_TEMP_SEQUENCE_ID;
+ else
+ str_identifier = SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(out_seq_bean, env);
+
+ identifier = sandesha2_identifier_create(env, rm_ns_val);
+ SANDESHA2_IDENTIFIER_SET_IDENTIFIER(identifier, env, str_identifier);
+ SANDESHA2_SEQUENCE_SET_IDENTIFIER(sequence, env, identifier);
+ SANDESHA2_MSG_CTX_SET_MSG_PART(msg_ctx, env, SANDESHA2_MSG_PART_SEQUENCE,
+ sequence);
+ /* TODO add_ack_requested */
+ SANDESHA2_MSG_CTX_ADD_SOAP_ENVELOPE(msg_ctx, env);
+ app_msg_entry = sandesha2_sender_bean_create(env);
+ SANDESHA2_SENDER_BEAN_SET_MSG_CONTEXT_REF_KEY(app_msg_entry, env,
+ storage_key);
+ AXIS2_PLATFORM_GET_TIME_IN_MILLIS(&t1);
+ millisecs = 1000 * (t1.time) + t1.millitm;
+ SANDESHA2_SENDER_BEAN_SET_TIME_TO_SEND(app_msg_entry, env, millisecs);
+ SANDESHA2_SENDER_BEAN_SET_MSG_ID(app_msg_entry, env,
+ SANDESHA2_MSG_CTX_GET_MSG_ID(msg_ctx, env));
+ SANDESHA2_MSG_CTX_SET_MSG_NUMBER(app_msg_entry, env, msg_num);
+ SANDESHA2_MSG_CTX_SET_MSG_TYPE(app_msg_entry, env,
+ SANDESHA2_MSG_TYPE_APPLICATION);
+ if(NULL == out_seq_bean || NULL == SANDESHA2_SEQ_PROPERTY_BEAN_GET_VALUE(
+ out_seq_bean, env))
+ SANDESHA2_MSG_CTX_SET_SEND(app_msg_entry, env, AXIS2_FALSE);
+ else
+ {
+ SANDESHA2_MSG_CTX_SET_SEND(app_msg_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_TRUE, env));
+ AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
+ SANDESHA2_SET_SEND_TO_TRUE, property, AXIS2_FALSE);
+ }
+ SANDESHA2_MSG_CTX_SET_INTERNAL_SEQ_ID(app_msg_entry, env, internal_seq_id);
+ SANDESHA2_STORAGE_MANAGER_STORE_MSG_CTX(manager, env, storage_key, msg);
+ SANDESHA2_SENDER_BEAN_MANAGER_INSERT(retransmitter_man, env, app_msg_entry);
+
+ 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_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
+ SANDESHA2_QUALIFIED_FOR_SENDING, property, AXIS2_FALSE);
+ trs_sender = AXIS2_TRANSPORT_OUT_DESC_GET_SENDER(
+ AXIS2_MSG_CTX_GET_TRANSPORT_OUT_DESC(msg, env), env);
+ if(NULL != trs_sender)
+ {
+ property = axis2_property_create(env);
+ 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(create_seq_msg, 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, trs_sender);
+ AXIS2_MSG_CTX_SET_PROPERTY(create_seq_msg, env,
+ SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property,
+ AXIS2_FALSE);
+ AXIS2_MSG_CTX_SET_TRANSPORT_OUT_DESC(msg, env,
+ sandesha2_utils_get_transport_out(env));
+ }
+ AXIS2_MSG_CTX_SET_CURRENT_HANDLER_INDEX(msg, env,
+ AXIS2_MSG_CTX_GET_CURRENT_HANDLER_INDEX(msg, env) + 1);
+ engine = axis_engine_create(env, AXIS2_MSG_CTX_GET_CONF_CTX(msg, env));
+ return AXIS2_ENGINE_RESUME_SEND(engine, env, msg);
}
+
long AXIS2_CALL
sandesha2_app_msg_processor_get_prev_msg_no(
sandesha2_msg_processor_t *msg_processor,
@@ -473,10 +1297,31 @@
axis2_char_t *internal_seq_id,
sandesha2_storage_manager_t *manager)
{
+ sandesha2_seq_property_bean_manager_t *seq_prop_mgr = NULL;
+ sandesha2_seq_property_bean_t *next_msg_no_bean = NULL;
+ long next_msg_no = -1;
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, internal_seq_id, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, manager, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, internal_seq_id, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, manager, AXIS2_FAILURE);
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ manager, env);
+ next_msg_no_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr,
+ env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
+
+ if(NULL != 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)
+ {
+ next_msg_no = atol(str_value);
+ }
+ }
+ return next_msg_no;
}
axis2_status_t AXIS2_CALL
@@ -487,8 +1332,46 @@
long msg_num,
sandesha2_storage_manager_t *manager)
{
+ sandesha2_seq_property_bean_manager_t *seq_prop_mgr = NULL;
+ sandesha2_seq_property_bean_t *next_msg_no_bean = NULL;
+ axis2_bool_t update = AXIS2_TRUE;
+ axis2_char_t str_long[32];
+
AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, internal_seq_id, AXIS2_FAILURE);
- AXIS2_PARAM_CHECK(env->allocator, manager, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, internal_seq_id, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK(env->error, manager, AXIS2_FAILURE);
+ if(msg_num <= 0)
+ {
+ AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_INVALID_MSG_NUM,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ seq_prop_mgr = SANDESHA2_STORAGE_MANAGER_GET_SEQ_PROPERTY_BEAN_MANAGER(
+ manager, env);
+ next_msg_no_bean = SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_RETRIEVE(seq_prop_mgr,
+ env, internal_seq_id,
+ SANDESHA2_SEQ_PROP_NEXT_MESSAGE_NUMBER);
+ if(NULL == 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);
+ SANDESHA2_SEQ_PROPERTY_BEAN_SET_NAME(next_msg_no_bean, env,
+ 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)
+ {
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_UPDATE(seq_prop_mgr, env,
+ next_msg_no_bean);
+ }
+ else
+ {
+ SANDESHA2_SEQ_PROPERTY_BEAN_MANAGER_INSERT(seq_prop_mgr, env,
+ next_msg_no_bean);
+ }
+ return AXIS2_SUCCESS;
}
Modified: webservices/sandesha/trunk/c/src/storage/beans/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/beans/Makefile.am?rev=420631&r1=420630&r2=420631&view=diff
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/beans/Makefile.am (original)
+++ webservices/sandesha/trunk/c/src/storage/beans/Makefile.am Mon Jul 10 14:00:16 2006
@@ -5,7 +5,7 @@
create_seq_bean.c \
next_msg_bean.c \
sender_bean.c \
- sequence_property_bean.c
+ seq_property_bean.c
INCLUDES = -I$(top_builddir)/include \
@AXIS2INC@
Added: webservices/sandesha/trunk/c/src/transport/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/transport/Makefile.am?rev=420631&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/transport/Makefile.am (added)
+++ webservices/sandesha/trunk/c/src/transport/Makefile.am Mon Jul 10 14:00:16 2006
@@ -0,0 +1,7 @@
+noinst_LTLIBRARIES = libsandesha2_transport.la
+
+libsandesha2_transport_la_SOURCES = sandesha2_transport_sender.c
+
+INCLUDES = -I$(top_builddir)/include \
+ @AXIS2INC@
+
---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org