axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sam...@apache.org
Subject svn commit: r356102 - /webservices/axis2/trunk/c/modules/core/engine/src/addr_disp.c
Date Mon, 12 Dec 2005 01:54:44 GMT
Author: samisa
Date: Sun Dec 11 17:54:36 2005
New Revision: 356102

URL: http://svn.apache.org/viewcvs?rev=356102&view=rev
Log:
Initial compiling version of addressing based dispatcher.
This is not a class like implemetation, but a fuctional implemetation as the state is captured
in message context and addressing dispatcher does not have any state.

Added:
    webservices/axis2/trunk/c/modules/core/engine/src/addr_disp.c

Added: webservices/axis2/trunk/c/modules/core/engine/src/addr_disp.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/engine/src/addr_disp.c?rev=356102&view=auto
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/src/addr_disp.c (added)
+++ webservices/axis2/trunk/c/modules/core/engine/src/addr_disp.c Sun Dec 11 17:54:36 2005
@@ -0,0 +1,239 @@
+/*
+ * 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 <axis2_disp.h>
+#include <axis2_handler_desc.h>
+#include <axis2_qname.h>
+#include <axis2_relates_to.h>
+#include <axis2_svc.h>
+#include <axis2.h>
+#include <axis2_conf_ctx.h>
+#include <axis2_addr.h>
+#include <axis2_utils.h>
+
+axis2_status_t AXIS2_CALL axis2_addr_disp_invoke (struct axis2_handler * handler, 
+                                                axis2_env_t **env,
+                                                struct axis2_msg_ctx *msg_ctx);
+axis2_svc_t* AXIS2_CALL axis2_addr_disp_find_svc(axis2_msg_ctx_t *msg_ctx,
+                    axis2_env_t **env);
+axis2_operation_t* AXIS2_CALL axis2_addr_disp_find_operation(axis2_msg_ctx_t *msg_ctx, 
+                                axis2_env_t **env,
+                                axis2_svc_t *svc);
+
+
+axis2_disp_t* AXIS2_CALL axis2_addr_disp_create(axis2_env_t **env) 
+{
+    axis2_disp_t *disp = NULL;
+    axis2_handler_t *handler = NULL;
+    axis2_qname_t *qname = NULL;
+    
+    AXIS2_ENV_CHECK(env, NULL);
+
+    qname = axis2_qname_create(env, "addressing_based_dispatcher", 
+                                                "http://axis.ws.apache.org",
+                                                NULL);
+    
+    disp = axis2_disp_create(env, qname);
+    if (!disp)
+    { 
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        return NULL;        
+    }
+    
+    handler = AXIS2_DISP_GET_BASE(disp, env);
+    if (!handler)
+    {
+        AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE);
+        return NULL;        
+    }
+
+    handler->ops->invoke = axis2_addr_disp_invoke;
+    
+    AXIS2_QNAME_FREE(qname, env);
+    
+    return disp;
+}
+
+    
+/** The struct that inherits from this struct
+    should implement the find_service and find_operation methods and assing the 
+    respective function pointers in the base struct.
+    Here we have only the dummy implementation to gauard against erros due to 
+    the failure to provide an impl version by mistake.
+ */
+    
+/**
+ * finds the service
+ *
+ * @param messageContext
+ * @return
+ */
+axis2_svc_t* AXIS2_CALL axis2_disp_find_svc(axis2_msg_ctx_t *msg_ctx, 
+                    axis2_env_t **env) 
+{    
+    axis2_endpoint_ref_t *endpoint_ref = NULL;
+    
+    AXIS2_FUNC_PARAM_CHECK(msg_ctx, env, NULL);    
+    
+    endpoint_ref = AXIS2_MSG_CTX_GET_TO(msg_ctx, env);
+    
+    if (endpoint_ref)
+    {
+        axis2_char_t *address = NULL;        
+
+        address = AXIS2_ENDPOINT_REF_GET_ADDRESS(endpoint_ref, env);
+        if (address)
+        {
+            axis2_char_t **url_tokens = NULL;
+            
+            AXIS2_LOG(env, "Checking for Operation using WSAAction : ");
+            AXIS2_LOG(env, address);
+            
+            if ( (AXIS2_STRCMP(AXIS2_WSA_ANONYMOUS_URL, address) == 0 ) || 
+                  (AXIS2_STRCMP(AXIS2_WSA_NAMESPACE_SUBMISSION, address) == 0 ))
+            {
+                return NULL;
+            }
+            
+            url_tokens = axis2_parse_request_url_for_svc_and_operation(env, address);
+            
+            if (url_tokens)
+            {                
+                if (url_tokens[0])
+                {                    
+                    axis2_conf_ctx_t *conf_ctx = NULL;
+                    
+                    conf_ctx = AXIS2_MSG_CTX_GET_CONF_CTX(msg_ctx, env);
+                    if (conf_ctx)
+                    {
+                        axis2_engine_config_t *engine_config = NULL;
+                        engine_config = AXIS2_CONF_CTX_GET_ENGINE_CONFIG(conf_ctx, env);
+                        if (engine_config)
+                        {
+                            axis2_svc_t *svc = NULL;
+                            axis2_qname_t *qname = axis2_qname_create(env, url_tokens[0],
NULL, NULL);
+                            svc = AXIS2_ENGINE_CONFIG_GET_SVC(engine_config, env, AXIS2_QNAME_GET_LOCALPART(qname,
env));
+                            
+                            AXIS2_QNAME_FREE(qname, env);
+                            return svc;
+                        }
+                    }                    
+                }
+            }
+        }
+    }
+        
+    return NULL;
+}
+
+/**
+ * finds the operation
+ *
+ * @param service
+ * @param msg_ctx
+ * @return
+ */
+axis2_operation_t* AXIS2_CALL axis2_addr_disp_find_operation(axis2_msg_ctx_t *msg_ctx, 
+                                axis2_env_t **env,
+                                axis2_svc_t *svc)
+{
+    axis2_char_t *action = NULL;
+    axis2_qname_t *qname = NULL;
+    
+    AXIS2_FUNC_PARAM_CHECK(msg_ctx, env, NULL);
+    AXIS2_PARAM_CHECK((*env)->error, svc, NULL);
+    
+    action = AXIS2_MSG_CTX_GET_WSA_ACTION(msg_ctx, env);
+    
+    if (action)
+    {
+        AXIS2_LOG(env, "Checking for Operation using WSAAction : ");
+        AXIS2_LOG(env, action );
+        
+        qname = axis2_qname_create(env, action, NULL, NULL);
+        return AXIS2_SVC_GET_OPERATION_WITH_QNAME(svc, env, qname);
+    }
+    
+    return NULL;
+}
+
+
+axis2_status_t AXIS2_CALL axis2_addr_disp_invoke(struct axis2_handler * handler, 
+                                                axis2_env_t **env,
+                                                struct axis2_msg_ctx *msg_ctx)
+{
+    axis2_relates_to_t *relates_to = NULL;
+    
+    AXIS2_FUNC_PARAM_CHECK(msg_ctx, env, AXIS2_FAILURE);    
+    
+    relates_to = AXIS2_MSG_CTX_GET_RELATES_TO(msg_ctx, env);
+    
+    /** first check if we can dispatch using the relates_to */
+    if (relates_to)
+    {
+        axis2_char_t *relates_to_value = NULL;
+        relates_to_value = AXIS2_RELATES_TO_GET_VALUE(relates_to, env);
+        if (relates_to_value && AXIS2_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_operation_ctx_t *operation_ctx = NULL;
+                axis2_char_t *msg_id = AXIS2_MSG_CTX_GET_MSG_ID(msg_ctx, env);
+                operation_ctx = AXIS2_CONF_CTX_GET_OPERATION_CTX(conf_ctx, env, msg_id);
+                if (operation_ctx)
+                {
+                    axis2_operation_t *operation = NULL;
+                    operation = AXIS2_OPERATION_CTX_GET_OPERATION(operation_ctx, env);
+                    if (operation)
+                    {
+                        axis2_svc_ctx_t *svc_ctx = NULL;
+                        AXIS2_MSG_CTX_SET_OPERATION_CTX(msg_ctx, env, operation_ctx);
+                        AXIS2_MSG_CTX_SET_OPERATION(msg_ctx, env, operation);
+                        /*TODO : AXIS2_OPERATION_REGISTER_OPERATION_CTX(operation, env, operation_ctx);*/
+                        
+                        svc_ctx = AXIS2_OPERATION_CTX_GET_PARENT(operation_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)
+                            {
+                                AXIS2_MSG_CTX_SET_SVC_GRP_CTX_ID(msg_ctx, env, AXIS2_SVC_GRP_CTX_GET_ID(svc_grp_ctx,
env) );
+                            }
+                        }                      
+                        
+                    }
+                }
+            }            
+        }
+        return AXIS2_SUCCESS;
+    }
+    
+    msg_ctx->ops->find_svc = axis2_addr_disp_find_svc;
+    msg_ctx->ops->find_operation = axis2_addr_disp_find_operation;
+    
+    return axis2_disp_invoke(handler, env, msg_ctx);
+}



Mime
View raw message