static axis2_status_t AXIS2_CALL
axis2_addr_disp_invoke(
axis2_handler_t * handler,
const axutil_env_t * env,
struct axis2_msg_ctx *msg_ctx)
{
axis2_relates_to_t *relates_to = NULL;
relates_to = axis2_msg_ctx_get_relates_to(msg_ctx, env);
/** first check if we can dispatch using the relates_to */
if(relates_to)
{
const axis2_char_t *relates_to_value = NULL;
relates_to_value = axis2_relates_to_get_value(relates_to, env);
if(relates_to_value && axutil_strcmp(relates_to_value, "") != 0)
{
axis2_conf_ctx_t *conf_ctx = NULL;
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
if(conf_ctx)
{
axis2_op_ctx_t *op_ctx = NULL;
const axis2_char_t *msg_id = axis2_msg_ctx_get_msg_id(msg_ctx, env);
op_ctx = axis2_conf_ctx_get_op_ctx(conf_ctx, env, msg_id);
if(op_ctx)
{
axis2_op_t *op = NULL;
op = axis2_op_ctx_get_op(op_ctx, env);
if(op)
{
axis2_svc_ctx_t *svc_ctx = NULL;
axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx);
axis2_msg_ctx_set_op(msg_ctx, env, op);
axis2_op_register_op_ctx(op, env, msg_ctx, op_ctx);
svc_ctx = axis2_op_ctx_get_parent(op_ctx, env);
if(svc_ctx)
{
axis2_svc_t *svc = NULL;
axis2_svc_grp_ctx_t *svc_grp_ctx = NULL;
axis2_msg_ctx_set_svc_ctx(msg_ctx, env, svc_ctx);
svc = axis2_svc_ctx_get_svc(svc_ctx, env);
if(svc)
{
axis2_msg_ctx_set_svc(msg_ctx, env, svc);
}
svc_grp_ctx = axis2_svc_ctx_get_parent(svc_ctx, env);
if(svc_grp_ctx)
{
axutil_string_t *svc_grp_ctx_id_str = axutil_string_create(env,
axis2_svc_grp_ctx_get_id(svc_grp_ctx, env));
axis2_msg_ctx_set_svc_grp_ctx_id(msg_ctx, env, svc_grp_ctx_id_str);
axutil_string_free(svc_grp_ctx_id_str, env);
}
return AXIS2_SUCCESS;
}
}
}
}
}
}
axis2_msg_ctx_set_find_svc(msg_ctx, env, axis2_addr_disp_find_svc);
axis2_msg_ctx_set_find_op(msg_ctx, env, axis2_addr_disp_find_op);
return axis2_disp_find_svc_and_op(handler, env, msg_ctx);
}
/* Process a request. If the request has a response the response structure will be populated */
AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_udp_receiver_process_request(
const axutil_env_t * env,
axis2_conf_ctx_t *conf_ctx,
axis2_udp_request_t * request,
axis2_udp_response_t * responce)
{
axis2_transport_out_desc_t *out_desc = NULL;
axis2_transport_in_desc_t *in_desc = NULL;
axis2_msg_ctx_t *msg_ctx = NULL;
axiom_xml_reader_t *reader = NULL;
axiom_stax_builder_t *builder = NULL;
axiom_soap_builder_t *soap_builder = NULL;
axiom_soap_envelope_t *soap_envelope = NULL;
axis2_engine_t *engine = NULL;
axis2_status_t status = AXIS2_FALSE;
axutil_stream_t *out_stream = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"start:axis2_udp_worker_process_request");
if (!conf_ctx)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "conf ctx not available");
return AXIS2_FAILURE;
}
reader = axiom_xml_reader_create_for_memory(env, request->buff,
request->buf_size,
NULL,
AXIS2_XML_PARSER_TYPE_BUFFER);
if (!reader)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Failed to create XML reader");
return AXIS2_FAILURE;
}
builder = axiom_stax_builder_create(env, reader);
if (!builder)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed to create Stax builder");
return AXIS2_FAILURE;
}
soap_builder = axiom_soap_builder_create(env, builder,
AXIOM_SOAP12_SOAP_ENVELOPE_NAMESPACE_URI);
if (!soap_builder)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Failed to create SOAP builder");
return AXIS2_FAILURE;
}
out_desc =
axis2_conf_get_transport_out(axis2_conf_ctx_get_conf(conf_ctx, env),
env, AXIS2_TRANSPORT_ENUM_UDP);
if (!out_desc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport out not set");
return AXIS2_FAILURE;
}
in_desc =
axis2_conf_get_transport_in(axis2_conf_ctx_get_conf(conf_ctx, env), env,
AXIS2_TRANSPORT_ENUM_UDP);
msg_ctx = axis2_msg_ctx_create(env, conf_ctx, in_desc, out_desc);
axis2_msg_ctx_set_server_side(msg_ctx, env, AXIS2_TRUE);
out_stream = axutil_stream_create_basic(env);
axis2_msg_ctx_set_transport_out_stream(msg_ctx, env, out_stream);
soap_envelope = axiom_soap_builder_get_soap_envelope(soap_builder, env);
axis2_msg_ctx_set_soap_envelope(msg_ctx, env, soap_envelope);
if (request->svc)
{
axis2_msg_ctx_set_svc(msg_ctx, env, request->svc);
}
if (request->op)
{
axis2_msg_ctx_set_op(msg_ctx, env, request->op);
}
engine = axis2_engine_create(env, conf_ctx);
status = axis2_engine_receive(engine, env, msg_ctx);
responce->buff = axutil_stream_get_buffer(out_stream, env);
responce->buf_size = axutil_stream_get_len(out_stream, env);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"end:axis2_udp_worker_process_request");
return AXIS2_SUCCESS;
}
static axis2_status_t AXIS2_CALL
sandesha2_ack_req_msg_processor_process_in_msg (
sandesha2_msg_processor_t *msg_processor,
const axutil_env_t *env,
sandesha2_msg_ctx_t *rm_msg_ctx)
{
sandesha2_ack_requested_t *ack_requested = NULL;
axis2_msg_ctx_t *msg_ctx = NULL;
axis2_char_t *seq_id = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
sandesha2_storage_mgr_t *storage_mgr = NULL;
sandesha2_seq_property_mgr_t *seq_prop_mgr = NULL;
sandesha2_seq_property_bean_t *acks_to_bean = NULL;
axis2_endpoint_ref_t *acks_to = NULL;
axis2_char_t *acks_to_str = NULL;
axis2_op_t *ack_op = NULL;
axis2_op_t *rm_msg_op = NULL;
axis2_msg_ctx_t *ack_msg_ctx = NULL;
axutil_property_t *property = NULL;
sandesha2_msg_ctx_t *ack_rm_msg = NULL;
axiom_soap_envelope_t *envelope = NULL;
axis2_char_t *wsa_version = NULL;
axis2_char_t *dbname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[sandesha2]Entry:sandesha2_ack_req_msg_processor_process_in_msg");
AXIS2_PARAM_CHECK(env->error, rm_msg_ctx, AXIS2_FAILURE);
ack_requested = sandesha2_msg_ctx_get_ack_requested(rm_msg_ctx, env);
if(!ack_requested)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2]Ack requested part is missing");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_REQD_MSG_PART_MISSING,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
sandesha2_ack_requested_set_must_understand(ack_requested, env, AXIS2_FALSE);
sandesha2_msg_ctx_add_soap_envelope(rm_msg_ctx, env);
msg_ctx = sandesha2_msg_ctx_get_msg_ctx(rm_msg_ctx, env);
seq_id = sandesha2_identifier_get_identifier(
sandesha2_ack_requested_get_identifier(ack_requested, env), env);
conf_ctx = axis2_msg_ctx_get_conf_ctx(msg_ctx, env);
dbname = sandesha2_util_get_dbname(env, conf_ctx);
storage_mgr = sandesha2_utils_get_storage_mgr(env, dbname);
if(!storage_mgr)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2] Could not create storage manager.");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_COULD_NOT_CREATE_STORAGE_MANAGER,
AXIS2_FAILURE);
return AXIS2_FAILURE;
}
seq_prop_mgr = sandesha2_permanent_seq_property_mgr_create(env, dbname);
acks_to_bean = sandesha2_seq_property_mgr_retrieve(seq_prop_mgr, env, seq_id,
SANDESHA2_SEQ_PROP_ACKS_TO_EPR);
acks_to_str = sandesha2_seq_property_bean_get_value(acks_to_bean, env);
if(!acks_to_str)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[sandesha2]acks_to_str"\
" seqeunce property is not set correctly");
if(seq_prop_mgr)
sandesha2_seq_property_mgr_free(seq_prop_mgr, env);
if(storage_mgr)
sandesha2_storage_mgr_free(storage_mgr, env);
return AXIS2_FAILURE;
}
acks_to = axis2_endpoint_ref_create(env, acks_to_str);
ack_op = axis2_op_create(env);
axis2_op_set_msg_exchange_pattern(ack_op, env, AXIS2_MEP_URI_IN_ONLY);
rm_msg_op = axis2_msg_ctx_get_op(msg_ctx, env);
if(rm_msg_op)
{
axutil_array_list_t *out_flow = NULL;
axutil_array_list_t *new_out_flow = NULL;
axutil_array_list_t *out_fault_flow = NULL;
axutil_array_list_t *new_out_fault_flow = NULL;
out_flow = axis2_op_get_out_flow(rm_msg_op, env);
new_out_flow = axis2_phases_info_copy_flow(env, out_flow);
out_fault_flow = axis2_op_get_out_flow(rm_msg_op, env);
new_out_fault_flow = axis2_phases_info_copy_flow(env, out_fault_flow);
if(new_out_flow)
axis2_op_set_out_flow(ack_op, env, new_out_flow);
if(new_out_fault_flow)
axis2_op_set_fault_out_flow(ack_op, env, new_out_fault_flow);
}
ack_msg_ctx = sandesha2_utils_create_new_related_msg_ctx(env, rm_msg_ctx);
property = axutil_property_create_with_args(env, 0, 0, 0, AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(ack_msg_ctx, env,
SANDESHA2_APPLICATION_PROCESSING_DONE, property);
ack_rm_msg = sandesha2_msg_init_init_msg(env, ack_msg_ctx);
sandesha2_msg_ctx_set_rm_ns_val(ack_rm_msg, env,
sandesha2_msg_ctx_get_rm_ns_val(rm_msg_ctx, env));
axis2_msg_ctx_set_message_id(ack_msg_ctx, env, axutil_uuid_gen(env));
envelope = axiom_soap_envelope_create_default_soap_envelope(env,
sandesha2_utils_get_soap_version(env,
axis2_msg_ctx_get_soap_envelope(msg_ctx, env)));
axis2_msg_ctx_set_soap_envelope(ack_msg_ctx, env, envelope);
axis2_msg_ctx_set_to(ack_msg_ctx, env, acks_to);
axis2_msg_ctx_set_reply_to(ack_msg_ctx, env, axis2_msg_ctx_get_to(msg_ctx,
env));
sandesha2_msg_creator_add_ack_msg(env, ack_rm_msg, seq_id, seq_prop_mgr);
axis2_msg_ctx_set_server_side(ack_msg_ctx, env, AXIS2_TRUE);
property = axis2_msg_ctx_get_property(msg_ctx, env, AXIS2_WSA_VERSION);
if(property)
wsa_version = axutil_property_get_value(property, env);
property = axutil_property_create_with_args(env, 0, 0, 0, wsa_version);
if(property)
{
axis2_msg_ctx_set_property(ack_msg_ctx, env, AXIS2_WSA_VERSION, property);
property = NULL;
}
if(sandesha2_utils_is_anon_uri(env, acks_to_str))
{
axis2_engine_t *engine = NULL;
axis2_op_ctx_t *op_ctx = NULL;
if(!axis2_msg_ctx_get_op(msg_ctx, env))
{
axis2_op_t *operation = NULL;
axis2_op_ctx_t *op_ctx = NULL;
operation = axis2_op_create(env);
axis2_op_set_msg_exchange_pattern(operation, env,
AXIS2_MEP_URI_IN_OUT);
op_ctx = axis2_op_ctx_create(env, operation, NULL);
axis2_msg_ctx_set_op(msg_ctx, env, operation);
axis2_msg_ctx_set_op_ctx(msg_ctx, env, op_ctx);
}
op_ctx = axis2_msg_ctx_get_op_ctx(msg_ctx, env);
axis2_op_ctx_set_response_written(op_ctx, env, AXIS2_TRUE);
property = axutil_property_create_with_args(env, 0, 0, 0,
AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(msg_ctx, env, SANDESHA2_ACK_WRITTEN,
property);
engine = axis2_engine_create(env, conf_ctx);
if(AXIS2_FAILURE == axis2_engine_send(engine, env, ack_msg_ctx))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2]ack sending failed");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_ACK,
AXIS2_FAILURE);
if(engine)
{
axis2_engine_free(engine, env);
engine = NULL;
}
if(seq_prop_mgr)
sandesha2_seq_property_mgr_free(seq_prop_mgr, env);
if(storage_mgr)
sandesha2_storage_mgr_free(storage_mgr, env);
return AXIS2_FAILURE;
}
if(engine)
{
axis2_engine_free(engine, env);
engine = NULL;
}
}
else
{
sandesha2_sender_mgr_t *sender_mgr = NULL;
axis2_char_t *key = NULL;
sandesha2_sender_bean_t *ack_bean = NULL;
sandesha2_sender_bean_t *find_bean = NULL;
sandesha2_property_bean_t *prop_bean = NULL;
long ack_interval = 0;
long time_to_send = 0;
axutil_array_list_t *found_list = NULL;
axis2_msg_ctx_t *msg_ctx = NULL;
axis2_engine_t *engine = NULL;
axis2_transport_out_desc_t *transport_out = NULL;
axis2_svc_t *svc = NULL;
sender_mgr = sandesha2_permanent_sender_mgr_create(env, dbname);
key = axutil_uuid_gen(env);
ack_bean = sandesha2_sender_bean_create(env);
sandesha2_sender_bean_set_msg_ctx_ref_key(ack_bean, env, key);
sandesha2_sender_bean_set_msg_id(ack_bean, env,
(axis2_char_t*)axis2_msg_ctx_get_msg_id(ack_msg_ctx, env));
sandesha2_sender_bean_set_resend(ack_bean, env, AXIS2_FALSE);
sandesha2_sender_bean_set_seq_id(ack_bean, env, seq_id);
sandesha2_sender_bean_set_send(ack_bean, env, AXIS2_TRUE);
sandesha2_sender_bean_set_msg_type(ack_bean, env, SANDESHA2_MSG_TYPE_ACK);
property = axutil_property_create_with_args(env, 0, 0, 0,
AXIS2_VALUE_FALSE);
axis2_msg_ctx_set_property(ack_msg_ctx, env,
SANDESHA2_QUALIFIED_FOR_SENDING, property);
/* Avoid retrieving property bean from operation until it is availbale */
/*prop_bean = sandesha2_utils_get_property_bean_from_op(env,
axis2_msg_ctx_get_op(msg_ctx, env));*/
svc = axis2_msg_ctx_get_svc(ack_msg_ctx, env);
if(!svc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2][ack_req_msg_processor.c] service is NULL");
return AXIS2_FAILURE;
}
prop_bean = sandesha2_utils_get_property_bean(env, svc);
if(!prop_bean)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2][ack_req_msg_processor.c] Property bean is NULL");
return AXIS2_FAILURE;
}
/*prop_bean = sandesha2_utils_get_property_bean(env,
axis2_conf_ctx_get_conf(conf_ctx, env));*/
prop_bean = sandesha2_utils_get_property_bean(env, svc);
ack_interval = sandesha2_property_bean_get_ack_interval(prop_bean, env);
time_to_send = sandesha2_utils_get_current_time_in_millis(env) +
ack_interval;
find_bean = sandesha2_sender_bean_create(env);
sandesha2_sender_bean_set_resend(find_bean, env, AXIS2_FALSE);
sandesha2_sender_bean_set_send(find_bean, env, AXIS2_TRUE);
sandesha2_sender_bean_set_msg_type(find_bean, env,
SANDESHA2_MSG_TYPE_ACK);
found_list = sandesha2_sender_mgr_find_by_sender_bean(sender_mgr, env,
find_bean);
if(find_bean)
sandesha2_sender_bean_free(find_bean, env);
if(found_list)
{
int i = 0;
for(i = 0; i < axutil_array_list_size(found_list, env); i++)
{
axis2_char_t *msg_stored_key = NULL;
sandesha2_sender_bean_t *old_ack_bean = NULL;
old_ack_bean = axutil_array_list_get(found_list, env, i);
time_to_send = sandesha2_sender_bean_get_time_to_send(
old_ack_bean, env);
/*char *msg_id = sandesha2_sender_bean_get_msg_id(old_ack_bean, env);*/
sandesha2_sender_mgr_remove(sender_mgr, env,
sandesha2_sender_bean_get_msg_id(old_ack_bean, env));
/* Removing the message from the storage */
msg_stored_key = sandesha2_sender_bean_get_msg_ctx_ref_key(
old_ack_bean, env);
sandesha2_storage_mgr_remove_msg_ctx(storage_mgr, env,
msg_stored_key, conf_ctx, -1);
}
}
sandesha2_sender_bean_set_time_to_send(ack_bean, env, time_to_send);
/*axis2_msg_ctx_set_keep_alive(ack_msg_ctx, env, AXIS2_TRUE);*/
sandesha2_storage_mgr_store_msg_ctx(storage_mgr, env, key, ack_msg_ctx, AXIS2_FALSE);
sandesha2_sender_mgr_insert(sender_mgr, env, ack_bean);
transport_out = axis2_msg_ctx_get_transport_out_desc(ack_msg_ctx, env);
property = axutil_property_create_with_args(env, 0, 0,
axis2_transport_out_desc_free_void_arg, transport_out);
axis2_msg_ctx_set_property(ack_msg_ctx, env,
SANDESHA2_ORIGINAL_TRANSPORT_OUT_DESC, property);
property = axutil_property_create_with_args(env, 0, 0, 0,
AXIS2_VALUE_TRUE);
axis2_msg_ctx_set_property(ack_msg_ctx, env,
SANDESHA2_SET_SEND_TO_TRUE, property);
property = axutil_property_create_with_args(env, 0, 0, 0, key);
axis2_msg_ctx_set_property(ack_msg_ctx, env,
SANDESHA2_MESSAGE_STORE_KEY, property);
axis2_msg_ctx_set_transport_out_desc(ack_msg_ctx, env,
sandesha2_utils_get_transport_out(env));
engine = axis2_engine_create(env, conf_ctx);
if(AXIS2_FAILURE == axis2_engine_send(engine, env, ack_msg_ctx))
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"[sandesha2]ack sending failed");
AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_SENDING_ACK,
AXIS2_FAILURE);
if(engine)
axis2_engine_free(engine, env);
if(seq_prop_mgr)
sandesha2_seq_property_mgr_free(seq_prop_mgr, env);
if(sender_mgr)
sandesha2_sender_mgr_free(sender_mgr, env);
if(storage_mgr)
sandesha2_storage_mgr_free(storage_mgr, env);
return AXIS2_FAILURE;
}
if(engine)
axis2_engine_free(engine, env);
sandesha2_utils_start_sender_for_seq(env, conf_ctx, seq_id, AXIS2_FALSE);
axis2_msg_ctx_set_paused(msg_ctx, env, AXIS2_TRUE);
if(sender_mgr)
sandesha2_sender_mgr_free(sender_mgr, env);
}
if(seq_prop_mgr)
sandesha2_seq_property_mgr_free(seq_prop_mgr, env);
if(storage_mgr)
sandesha2_storage_mgr_free(storage_mgr, env);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI,
"[sandesha2]Exit:sandesha2_ack_req_msg_processor_process_in_msg");
return AXIS2_SUCCESS;
}
