From 0425aadc78680e53000fd0108b540d6eca048516 Mon Sep 17 00:00:00 2001 From: gmcdonald Date: Sat, 13 Feb 2010 01:32:03 +0000 Subject: Moving axis svn, part of TLP move INFRA-2441 git-svn-id: http://svn.apache.org/repos/asf/axis/axis2/c/core/trunk@909681 13f79535-47bb-0310-9956-ffa450edef68 --- include/axis2_engine.h | 264 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 include/axis2_engine.h (limited to 'include/axis2_engine.h') diff --git a/include/axis2_engine.h b/include/axis2_engine.h new file mode 100644 index 0000000..9433d48 --- /dev/null +++ b/include/axis2_engine.h @@ -0,0 +1,264 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef AXIS2_ENGINE_H +#define AXIS2_ENGINE_H + +/** + * @defgroup axis2_engine engine + * @ingroup axis2_engine + * engine has the send and receive functions that is the heart when providing + * and consuming services. In Axis2 SOAP engine architecture, all the others + * parts are build around the concept of the engine. There is only one engine + * for both the server side and the client side, and the engine is not aware of + * if it is invoked as an client or a service. engine supports both synchronous + * and asynchronous messaging modes based on send and receive functions. + * @{ + */ + +/** + * @file axis2_engine.h + */ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_engine */ + typedef struct axis2_engine axis2_engine_t; + + struct axiom_soap_fault; + + /** + * This methods represents the out flow of the Axis engine both at the + * server side as well as the client side. In this function, the + * execution chain is created using the phases of the out flow. + * All handlers at each out flow phase, which are ordered in the + * deployment time are invoked in sequence here. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing current state + * that is used when sending message + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_send( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * This methods represents the in flow of the Axis engine, both at the + * server side as well as the client side. In this function, the + * execution chain is created using the phases of the in flow. + * All handlers at each in flow phase, which are ordered in the + * deployment time are invoked in sequence here. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing current state + * that is used in receiving message + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_receive( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Sends a SOAP fault. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context that contains details of + * fault state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_send_fault( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * This is invoked when a SOAP fault is received. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context representing that contains + * the details of receive state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_receive_fault( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Creates a message context that represents the fault state based on + * current processing state. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param processing_context pointer to message context representing + * current processing context + * @param code_value pointer to a string containing fault code + * @param reason_text pointer to a string containing reason of the fault + * @return pointer to message context representing the fault state + */ + AXIS2_EXTERN axis2_msg_ctx_t *AXIS2_CALL + + axis2_engine_create_fault_msg_ctx( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * processing_context, + const axis2_char_t * code_value, + const axis2_char_t * reason_text); + + /** + * Invokes the phases in the given array list of phases. The list of + * phases could be representing one of the flows. The two possible + * flows are in flow and out flow. Both of those flows can also have + * fault related representations, in fault flow and out fault flow. + * Invoking a phase triggers the invocation of handlers the phase + * contain. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param phases pointer to phases + * @param msg_ctx pointer to message context containing current state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_invoke_phases( + axis2_engine_t * engine, + const axutil_env_t * env, + axutil_array_list_t * phases, + axis2_msg_ctx_t * msg_ctx); + + /** + * Resumes phase invocation. While invoking the phases, one of the + * handlers in any phase could determine to pause the invocation. + * Often pausing happens to wait till some state is reached or some + * task is complete. Once paused, the invocation has to be resumed + * using this function, which will resume the invocation from the paused + * handler in the paused phase and will continue till it is paused + * again or it completes invoking all the remaining handlers in the + * remaining phases. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param phases pointer to phases + * @param msg_ctx pointer to message context containing current paused + * state + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_engine_resume_invocation_phases( + axis2_engine_t * engine, + const axutil_env_t * env, + axutil_array_list_t * phases, + axis2_msg_ctx_t * msg_ctx); + + /** + * Gets sender's SOAP fault code. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param soap_namespace pointer to SOAP namespace + * @return pointer to SOAP fault code string + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_engine_get_sender_fault_code( + const axis2_engine_t * engine, + const axutil_env_t * env, + const axis2_char_t * soap_namespace); + + /** + * Gets receiver's SOAP fault code. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param soap_namespace pointer to soap namespace + */ + AXIS2_EXTERN const axis2_char_t *AXIS2_CALL + + axis2_engine_get_receiver_fault_code( + const axis2_engine_t * engine, + const axutil_env_t * env, + const axis2_char_t * soap_namespace); + + /** + * Frees engine struct. + * @param engine pointer to engine + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_engine_free( + axis2_engine_t * engine, + const axutil_env_t * env); + + /** + * Resumes receive operation. It could be the case that receive was + * paused by one of the in flow handlers. In such a situation, this + * method could be used to resume the receive operation. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_resume_receive( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Resumes send operation. It could be the case that send was + * paused by one of the out flow handlers. In such a situation, this + * method could be used to resume the send operation. + * @param engine pointer to engine + * @param env pointer to environment struct + * @param msg_ctx pointer to message context + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_engine_resume_send( + axis2_engine_t * engine, + const axutil_env_t * env, + axis2_msg_ctx_t * msg_ctx); + + /** + * Creates en engine struct instance. + * @param env pointer to environment struct + * @param conf_ctx pointer to configuration context struct + * @return pointer to newly created engine struct + */ + AXIS2_EXTERN axis2_engine_t *AXIS2_CALL + axis2_engine_create( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_ENGINE_H */ -- cgit v1.1-32-gdbae