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