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 --- src/core/deployment/Makefile.am | 38 + src/core/deployment/arch_file_data.c | 369 +++++ src/core/deployment/arch_reader.c | 313 +++++ src/core/deployment/axis2_arch_file_data.h | 265 ++++ src/core/deployment/axis2_arch_reader.h | 152 ++ src/core/deployment/axis2_conf_builder.h | 116 ++ src/core/deployment/axis2_dep_engine.h | 418 ++++++ src/core/deployment/axis2_deployment.h | 119 ++ src/core/deployment/axis2_desc_builder.h | 292 ++++ src/core/deployment/axis2_module_builder.h | 101 ++ src/core/deployment/axis2_repos_listener.h | 144 ++ src/core/deployment/axis2_svc_builder.h | 149 ++ src/core/deployment/axis2_svc_grp_builder.h | 122 ++ src/core/deployment/axis2_ws_info.h | 144 ++ src/core/deployment/axis2_ws_info_list.h | 192 +++ src/core/deployment/conf_builder.c | 1337 ++++++++++++++++++ src/core/deployment/conf_init.c | 460 +++++++ src/core/deployment/dep_engine.c | 1988 +++++++++++++++++++++++++++ src/core/deployment/desc_builder.c | 1148 ++++++++++++++++ src/core/deployment/module_builder.c | 514 +++++++ src/core/deployment/phases_info.c | 564 ++++++++ src/core/deployment/repos_listener.c | 398 ++++++ src/core/deployment/svc_builder.c | 840 +++++++++++ src/core/deployment/svc_grp_builder.c | 264 ++++ src/core/deployment/ws_info.c | 158 +++ src/core/deployment/ws_info_list.c | 370 +++++ 26 files changed, 10975 insertions(+) create mode 100644 src/core/deployment/Makefile.am create mode 100644 src/core/deployment/arch_file_data.c create mode 100644 src/core/deployment/arch_reader.c create mode 100644 src/core/deployment/axis2_arch_file_data.h create mode 100644 src/core/deployment/axis2_arch_reader.h create mode 100644 src/core/deployment/axis2_conf_builder.h create mode 100644 src/core/deployment/axis2_dep_engine.h create mode 100644 src/core/deployment/axis2_deployment.h create mode 100644 src/core/deployment/axis2_desc_builder.h create mode 100644 src/core/deployment/axis2_module_builder.h create mode 100644 src/core/deployment/axis2_repos_listener.h create mode 100644 src/core/deployment/axis2_svc_builder.h create mode 100644 src/core/deployment/axis2_svc_grp_builder.h create mode 100644 src/core/deployment/axis2_ws_info.h create mode 100644 src/core/deployment/axis2_ws_info_list.h create mode 100644 src/core/deployment/conf_builder.c create mode 100644 src/core/deployment/conf_init.c create mode 100644 src/core/deployment/dep_engine.c create mode 100644 src/core/deployment/desc_builder.c create mode 100644 src/core/deployment/module_builder.c create mode 100644 src/core/deployment/phases_info.c create mode 100644 src/core/deployment/repos_listener.c create mode 100644 src/core/deployment/svc_builder.c create mode 100644 src/core/deployment/svc_grp_builder.c create mode 100644 src/core/deployment/ws_info.c create mode 100644 src/core/deployment/ws_info_list.c (limited to 'src/core/deployment') diff --git a/src/core/deployment/Makefile.am b/src/core/deployment/Makefile.am new file mode 100644 index 0000000..7099839 --- /dev/null +++ b/src/core/deployment/Makefile.am @@ -0,0 +1,38 @@ +noinst_LTLIBRARIES = libaxis2_deployment.la + +noinst_HEADERS = axis2_deployment.h \ + axis2_arch_file_data.h \ + axis2_arch_reader.h \ + axis2_conf_builder.h \ + axis2_dep_engine.h \ + axis2_desc_builder.h \ + axis2_module_builder.h \ + axis2_repos_listener.h \ + axis2_svc_builder.h \ + axis2_svc_grp_builder.h \ + axis2_ws_info.h \ + axis2_ws_info_list.h + +libaxis2_deployment_la_SOURCES =phases_info.c \ + desc_builder.c \ + arch_reader.c \ + dep_engine.c \ + arch_file_data.c \ + ws_info.c \ + ws_info_list.c \ + svc_builder.c \ + svc_grp_builder.c \ + module_builder.c \ + conf_builder.c \ + repos_listener.c \ + conf_init.c + +INCLUDES = -I$(top_builddir)/include \ + -I$(top_builddir)/src/core/description \ + -I$(top_builddir)/src/core/engine \ + -I$(top_builddir)/src/core/phaseresolver \ + -I$(top_builddir)/src/core/deployment \ + -I$(top_builddir)/src/core/util \ + -I$(top_builddir)/axiom/include \ + -I$(top_builddir)/neethi/include \ + -I$(top_builddir)/util/include diff --git a/src/core/deployment/arch_file_data.c b/src/core/deployment/arch_file_data.c new file mode 100644 index 0000000..b785399 --- /dev/null +++ b/src/core/deployment/arch_file_data.c @@ -0,0 +1,369 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_arch_file_data +{ + axutil_file_t *file; + int type; + axis2_char_t *msg_recv; + axis2_char_t *module_name; + axis2_char_t *module_dll_name; + axis2_char_t *name; + /* + * To store services in a service group. Those services are temporarily + * stored in this table + */ + axutil_hash_t *svc_map; + axutil_array_list_t *deployable_svcs; + +}; + +AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL +axis2_arch_file_data_create( + const axutil_env_t * env) +{ + axis2_arch_file_data_t *arch_file_data = NULL; + arch_file_data = (axis2_arch_file_data_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_arch_file_data_t)); + + if(!arch_file_data) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + memset((void *)arch_file_data, 0, sizeof(axis2_arch_file_data_t)); + + arch_file_data->deployable_svcs = axutil_array_list_create(env, 0); + if(!arch_file_data->deployable_svcs) + { + axis2_arch_file_data_free(arch_file_data, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return arch_file_data; +} + +AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL +axis2_arch_file_data_create_with_type_and_file( + const axutil_env_t * env, + int type, + axutil_file_t * file) +{ + axis2_arch_file_data_t *arch_file_data = NULL; + arch_file_data = (axis2_arch_file_data_t *)axis2_arch_file_data_create(env); + if(!arch_file_data) + { + axis2_char_t *file_name = axutil_file_get_name(file, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create arch_file_data for file %s", + file_name); + return NULL; + } + + arch_file_data->type = type; + arch_file_data->file = axutil_file_clone(file, env); + return arch_file_data; +} + +AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL +axis2_arch_file_data_create_with_type_and_name( + const axutil_env_t * env, + int type, + const axis2_char_t * name) +{ + axis2_arch_file_data_t *arch_file_data = NULL; + arch_file_data = (axis2_arch_file_data_t *)axis2_arch_file_data_create(env); + if(!arch_file_data) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create arch_file_data for %s", name); + return NULL; + } + arch_file_data->type = type; + arch_file_data->name = axutil_strdup(env, name); + return arch_file_data; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_arch_file_data_free( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + if(arch_file_data->file) + { + axutil_file_free(arch_file_data->file, env); + } + if(arch_file_data->msg_recv) + { + AXIS2_FREE(env->allocator, arch_file_data->msg_recv); + } + if(arch_file_data->module_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_name); + } + if(arch_file_data->module_dll_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_dll_name); + } + if(arch_file_data->name) + { + AXIS2_FREE(env->allocator, arch_file_data->name); + } + + if(arch_file_data->svc_map) + { + axutil_hash_index_t *hi = NULL; + void *val = NULL; + + for(hi = axutil_hash_first(arch_file_data->svc_map, env); hi; hi + = axutil_hash_next(env, hi)) + { + axis2_svc_t *svc = NULL; + axutil_hash_this(hi, NULL, NULL, &val); + svc = (axis2_svc_t *)val; + if(svc) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Service name :%s", axis2_svc_get_name(svc, + env)); + axis2_svc_free(svc, env); + } + } + axutil_hash_free(arch_file_data->svc_map, env); + } + if(arch_file_data->deployable_svcs) + { + axutil_array_list_free(arch_file_data->deployable_svcs, env); + } + + if(arch_file_data) + { + AXIS2_FREE(env->allocator, arch_file_data); + } + + return; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_msg_recv( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->msg_recv; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_msg_recv( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * msg_recv) +{ + AXIS2_PARAM_CHECK(env->error, msg_recv, AXIS2_FAILURE); + + if(arch_file_data->msg_recv) + { + AXIS2_FREE(env->allocator, arch_file_data->msg_recv); + arch_file_data->msg_recv = NULL; + } + arch_file_data->msg_recv = axutil_strdup(env, msg_recv); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return axutil_file_get_name(arch_file_data->file, env); +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_svc_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + axis2_char_t *svc_name = NULL; + + if(arch_file_data->file) + { + svc_name = axutil_file_get_name(arch_file_data->file, env); + } + else + { + svc_name = arch_file_data->name; + } + + return svc_name; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_arch_file_data_get_type( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->type; +} + +AXIS2_EXTERN axutil_file_t *AXIS2_CALL +axis2_arch_file_data_get_file( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->file; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_module_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + axis2_char_t *module_name = NULL; + + if(arch_file_data->file) + { + module_name = axutil_file_get_name(arch_file_data->file, env); + } + else + { + module_name = arch_file_data->module_name; + } + return module_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_module_name( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * module_name) +{ + AXIS2_PARAM_CHECK(env->error, module_name, AXIS2_FAILURE); + + if(arch_file_data->module_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_name); + arch_file_data->module_name = NULL; + } + arch_file_data->module_name = axutil_strdup(env, module_name); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_arch_file_data_get_module_dll_name( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->module_dll_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_module_dll_name( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * module_dll_name) +{ + AXIS2_PARAM_CHECK(env->error, module_dll_name, AXIS2_FAILURE); + + if(arch_file_data->module_dll_name) + { + AXIS2_FREE(env->allocator, arch_file_data->module_dll_name); + arch_file_data->module_dll_name = NULL; + } + arch_file_data->module_dll_name = axutil_strdup(env, module_dll_name); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_add_svc( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_svc_t * svc_desc) +{ + const axutil_qname_t *svc_qname = NULL; + axis2_char_t *svc_name = NULL; + AXIS2_PARAM_CHECK(env->error, svc_desc, AXIS2_FAILURE); + + svc_qname = axis2_svc_get_qname(svc_desc, env); + svc_name = axutil_qname_to_string((axutil_qname_t *)svc_qname, env); + if(!arch_file_data->svc_map) + { + arch_file_data->svc_map = axutil_hash_make(env); + if(!arch_file_data->svc_map) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + axutil_hash_set(arch_file_data->svc_map, svc_name, AXIS2_HASH_KEY_STRING, svc_desc); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN struct axis2_svc *AXIS2_CALL +axis2_arch_file_data_get_svc( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axis2_char_t * svc_name) +{ + axis2_svc_t *svc = NULL; + + AXIS2_PARAM_CHECK(env->error, svc_name, NULL); + + if(arch_file_data->svc_map) + { + svc = (axis2_svc_t *)axutil_hash_get(arch_file_data->svc_map, svc_name, + AXIS2_HASH_KEY_STRING); + } + else + { + return NULL; + } + return svc; +} + +AXIS2_EXTERN axutil_hash_t *AXIS2_CALL +axis2_arch_file_data_get_svc_map( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->svc_map; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_arch_file_data_get_deployable_svcs( + const axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env) +{ + return arch_file_data->deployable_svcs; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_file_data_set_deployable_svcs( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env, + axutil_array_list_t * deployable_svcs) +{ + AXIS2_PARAM_CHECK(env->error, deployable_svcs, AXIS2_FAILURE); + if(arch_file_data->deployable_svcs) + { + AXIS2_FREE(env->allocator, arch_file_data->deployable_svcs); + arch_file_data->deployable_svcs = NULL; + } + arch_file_data->deployable_svcs = deployable_svcs; + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/arch_reader.c b/src/core/deployment/arch_reader.c new file mode 100644 index 0000000..3403d8e --- /dev/null +++ b/src/core/deployment/arch_reader.c @@ -0,0 +1,313 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include + +struct axis2_arch_reader +{ + axis2_desc_builder_t *desc_builder; +}; + +AXIS2_EXTERN axis2_arch_reader_t *AXIS2_CALL +axis2_arch_reader_create( + const axutil_env_t * env) +{ + axis2_arch_reader_t *arch_reader = NULL; + + arch_reader = (axis2_arch_reader_t *)AXIS2_MALLOC(env-> allocator, sizeof(axis2_arch_reader_t)); + + if(!arch_reader) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + arch_reader->desc_builder = NULL; + + return arch_reader; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_arch_reader_free( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env) +{ + /* Description builder is owned by dep_engine, so do not free it here */ + + if(arch_reader) + { + AXIS2_FREE(env->allocator, arch_reader); + } + + return; +} + +AXIS2_EXTERN struct axis2_svc *AXIS2_CALL +axis2_arch_reader_create_svc( + const axutil_env_t * env, + struct axis2_arch_file_data *file) +{ + axis2_svc_t *svc = NULL; + svc = axis2_svc_create(env); + return svc; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_reader_process_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine * dep_engine, + axis2_svc_grp_t * svc_grp) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *svc_grp_xml = NULL; + axis2_char_t *repos_path = NULL; + axis2_bool_t file_flag = AXIS2_FALSE; + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + file_flag = axis2_dep_engine_get_file_flag(dep_engine, env); + + if(!file_flag) + { + + repos_path = axis2_dep_engine_get_repos_path(dep_engine, env); + + svc_grp_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, AXIS2_SERVICE_FOLDER, + AXIS2_PATH_SEP_STR, file_name, AXIS2_PATH_SEP_STR, AXIS2_SVC_XML, NULL); + } + else + { + repos_path = axis2_dep_engine_get_svc_dir(dep_engine, env); + svc_grp_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, file_name, + AXIS2_PATH_SEP_STR, AXIS2_SVC_XML, NULL); + } + + if(!svc_grp_xml) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service xml file not found for %s", file_name); + return AXIS2_FAILURE; + } + status = axutil_file_handler_access(svc_grp_xml, AXIS2_F_OK); + if(AXIS2_SUCCESS == status) + { + struct axis2_arch_file_data *arch_file_data = NULL; + axis2_char_t *svc_name = NULL; + + status + = axis2_arch_reader_build_svc_grp(arch_reader, env, svc_grp_xml, dep_engine, svc_grp); + if(AXIS2_SUCCESS != status) + { + return status; + } + arch_file_data = axis2_dep_engine_get_current_file_item(dep_engine, env); + svc_name = axis2_arch_file_data_get_svc_name(arch_file_data, env); + axis2_svc_grp_set_name(svc_grp, env, svc_name); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SERVICE_XML_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Access to service configuration file %s failed", + file_name); + status = AXIS2_FAILURE; + } + AXIS2_FREE(env->allocator, svc_grp_xml); + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_reader_build_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * svc_xml, + axis2_dep_engine_t * dep_engine, + axis2_svc_grp_t * svc_grp) +{ + axis2_char_t *root_element_name = NULL; + axiom_node_t *svc_grp_node = NULL; + axiom_element_t *svc_grp_element = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, svc_xml, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + arch_reader->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, svc_xml, + dep_engine); + if(!arch_reader->desc_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating description builder for service file %s failed", svc_xml); + return AXIS2_FAILURE; + } + axis2_dep_engine_add_desc_builder(dep_engine, env, arch_reader->desc_builder); + + svc_grp_node = axis2_desc_builder_build_om(arch_reader->desc_builder, env); + + if(svc_grp_node) + { + svc_grp_element = axiom_node_get_data_element(svc_grp_node, env); + if(svc_grp_element) + { + root_element_name = axiom_element_get_localname(svc_grp_element, env); + } + } + + if(root_element_name && 0 == axutil_strcmp(AXIS2_SVC_ELEMENT, root_element_name)) + { + /* If service group is actually a service. In this case service group + * contain only single service */ + axis2_svc_t *svc = NULL; + axis2_svc_builder_t *svc_builder = NULL; + axis2_arch_file_data_t *file_data = NULL; + axutil_array_list_t *dep_svcs = NULL; + axis2_char_t *svc_name = NULL; + + file_data = axis2_dep_engine_get_current_file_item(dep_engine, env); + svc_name = axis2_arch_file_data_get_name(file_data, env); + svc = axis2_arch_file_data_get_svc(file_data, env, svc_name); + if(!svc) + { + axutil_qname_t *svc_qname = NULL; + + svc_qname = axutil_qname_create(env, svc_name, NULL, NULL); + svc = axis2_svc_create_with_qname(env, svc_qname); + status = axis2_arch_file_data_add_svc(file_data, env, svc); + axutil_qname_free(svc_qname, env); + if(AXIS2_SUCCESS != status) + { + axis2_svc_free(svc, env); + return status; + } + } + axis2_svc_set_parent(svc, env, svc_grp); + + svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env, dep_engine, svc); + status = axis2_svc_builder_populate_svc(svc_builder, env, svc_grp_node); + axis2_dep_engine_add_svc_builder(dep_engine, env, svc_builder); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Populating service failed for %s", svc_name); + return AXIS2_FAILURE; + } + + dep_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env); + if(!dep_svcs) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Deployable services list is NULL within arch file data"); + return AXIS2_FAILURE; + } + status = axutil_array_list_add(dep_svcs, env, svc); + if(AXIS2_SUCCESS != status) + { + return AXIS2_FAILURE; + } + + } + else if(root_element_name && 0 == axutil_strcmp(AXIS2_SVC_GRP_ELEMENT, root_element_name)) + { + axis2_svc_grp_builder_t *grp_builder = NULL; + grp_builder = axis2_svc_grp_builder_create_with_svc_and_dep_engine(env, svc_grp_node, + dep_engine); + status = axis2_svc_grp_builder_populate_svc_grp(grp_builder, env, svc_grp); + axis2_dep_engine_add_svc_grp_builder(dep_engine, env, grp_builder); + } + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_arch_reader_read_module_arch( + const axutil_env_t * env, + axis2_char_t * file_name, + axis2_dep_engine_t * dep_engine, + axis2_module_desc_t * module_desc) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *module_xml = NULL; + axis2_char_t *repos_path = NULL; + axis2_bool_t file_flag; + + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + + file_flag = axis2_dep_engine_get_file_flag(dep_engine, env); + if(!file_flag) + { + repos_path = axis2_dep_engine_get_repos_path(dep_engine, env); + module_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, AXIS2_MODULE_FOLDER, + AXIS2_PATH_SEP_STR, file_name, AXIS2_PATH_SEP_STR, AXIS2_MODULE_XML, NULL); + } + else + { + repos_path = axis2_dep_engine_get_module_dir(dep_engine, env); + module_xml = axutil_strcat(env, repos_path, AXIS2_PATH_SEP_STR, file_name, + AXIS2_PATH_SEP_STR, AXIS2_MODULE_XML, NULL); + } + + if(!module_xml) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + status = axutil_file_handler_access(module_xml, AXIS2_F_OK); + + if(AXIS2_SUCCESS == status) + { + axis2_module_builder_t *module_builder = NULL; + module_builder = axis2_module_builder_create_with_file_and_dep_engine_and_module(env, + module_xml, dep_engine, module_desc); + status = axis2_module_builder_populate_module(module_builder, env); + axis2_dep_engine_add_module_builder(dep_engine, env, module_builder); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_XML_NOT_FOUND_FOR_THE_MODULE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module configuration file access failed for module file %s", module_xml); + status = AXIS2_FAILURE; + } + AXIS2_FREE(env->allocator, module_xml); + return status; +} + +AXIS2_EXTERN axutil_file_t *AXIS2_CALL +axis2_arch_reader_create_module_arch( + const axutil_env_t * env, + axis2_char_t * module_name) +{ + axutil_file_t *file = NULL; + + file = axutil_file_create(env); + if(!file) + { + return NULL; + } + axutil_file_set_name(file, env, module_name); + return file; +} + diff --git a/src/core/deployment/axis2_arch_file_data.h b/src/core/deployment/axis2_arch_file_data.h new file mode 100644 index 0000000..d27d065 --- /dev/null +++ b/src/core/deployment/axis2_arch_file_data.h @@ -0,0 +1,265 @@ + +/* + * 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_ARCH_FILE_DATA_H +#define AXIS2_ARCH_FILE_DATA_H + +/** @defgroup axis2_arch_file_data Arch File Data + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_arch_file_data.h + * @brief Axis2 Arch File Data interface. arch_file_data construct contain + * deployment information retrieved from a module or service configuration file. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + + /** Type name for struct axis2_arch_fila_data */ + typedef struct axis2_arch_file_data axis2_arch_file_data_t; + + /** + * De-allocate memory + * @param arch_file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_arch_file_data_free( + axis2_arch_file_data_t * arch_file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_arch_file_data_get_msg_recv( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @param msg_recv pointer to message receiver + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_file_data_set_msg_recv( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * msg_recv); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return the name of the contained file. + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_arch_file_data_get_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return the service name. If contained file is not null this is the + * file name. else this is the name property + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_arch_file_data_get_svc_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_arch_file_data_get_type( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_file_t *AXIS2_CALL + axis2_arch_file_data_get_file( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_arch_file_data_get_module_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @param module_name pointer to module_name + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_file_data_set_module_name( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * module_name); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_arch_file_data_get_module_dll_name( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_file_data_set_module_dll_name( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * module_dll_name); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_file_data_add_svc( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + struct axis2_svc *svc_desc); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_arch_file_data_get_svc( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axis2_char_t * svc_name); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_hash_t *AXIS2_CALL + axis2_arch_file_data_get_svc_map( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + */ + AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL + + axis2_arch_file_data_get_deployable_svcs( + const axis2_arch_file_data_t * file_data, + const axutil_env_t * env); + + /** + * @param file_data pointer to arch_file_data + * @param env pointer to environment struct + * @param deployable_svcs pointer to deployable services + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_file_data_set_deployable_svcs( + axis2_arch_file_data_t * file_data, + const axutil_env_t * env, + axutil_array_list_t * deployable_svcs); + + /** + * Creates arch file data struct + * @param env pointer to environment struct + * @return pointer to newly created arch file data + */ + AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL + + axis2_arch_file_data_create( + const axutil_env_t * env); + + /** + * Creates arch file data struct + * @param env pointer to environment struct + * @param type type + * @param file folder name of service or module + * @return pointer to newly created arch file data + */ + AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL + + axis2_arch_file_data_create_with_type_and_file( + const axutil_env_t * env, + int type, + axutil_file_t * file); + + /** + * Creates arch file data struct + * @param env pointer to environment struct + * @param type type + * @param name pointer to name + * @return pointer to newly created arch file data + */ + AXIS2_EXTERN axis2_arch_file_data_t *AXIS2_CALL + + axis2_arch_file_data_create_with_type_and_name( + const axutil_env_t * env, + int type, + const axis2_char_t * name); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_ARCH_FILE_DATA_H */ diff --git a/src/core/deployment/axis2_arch_reader.h b/src/core/deployment/axis2_arch_reader.h new file mode 100644 index 0000000..274ded2 --- /dev/null +++ b/src/core/deployment/axis2_arch_reader.h @@ -0,0 +1,152 @@ + +/* + * 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_ARCH_READER_H +#define AXIS2_ARCH_READER_H + +/** @defgroup axis2_arch_reader Arch Reader + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + struct axis2_arch_file_data; + struct axis2_dep_engine; + + /** Type name for struct axis2_arch_reader */ + typedef struct axis2_arch_reader axis2_arch_reader_t; + + /** + * De-allocate memory + * @param arch_reader pointer to arch reader + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_arch_reader_free( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env); + + /** + * To create a service descrption axis2_svc_t using given + * deployment info file. + * @param env pointer to environment struct + * @param file pointer to file + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_arch_reader_create_svc( + const axutil_env_t * env, + struct axis2_arch_file_data *file); + + /** + * Construct the path to the service group configuration file(services.xml) + * using the passed file name and populate the passed service group + * description. + * @param arch_reader pointer to arch reader + * @param env pointer to environment struct + * @param file_name pointer to service group configuration file. + * @param dep_engine pointer to deployment engine + * @param svc_grp pointer to service group to be populated. + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_reader_process_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *dep_engine, + axis2_svc_grp_t * svc_grp); + + /** + * Populate the passed service group description using the service group + * configuration file(services.xml). + * @param arch_reader pointer to arch reader + * @param env pointer to environment struct + * @param file_path path to the service group configuration file(services.xml) + * @param dep_engine pointer to deployment engine + * @param svc_grp pointer to service group + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_arch_reader_build_svc_grp( + axis2_arch_reader_t * arch_reader, + const axutil_env_t * env, + axis2_char_t * file_path, + struct axis2_dep_engine *dep_engine, + struct axis2_svc_grp *svc_grp); + + /** + * Construct the path to the module configuration file(module.xml) + * using the passed file name and populate the passed module description. + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_arch_reader_read_module_arch( + const axutil_env_t * env, + axis2_char_t * file_path, + struct axis2_dep_engine *dep_engine, + axis2_module_desc_t * module); + + /** + * Create an axis2 file using the passed module name. + * @param env pointer to environment struct + * @param module_name pointer to module name + */ + AXIS2_EXTERN axutil_file_t *AXIS2_CALL + + axis2_arch_reader_create_module_arch( + const axutil_env_t * env, + axis2_char_t * module_name); + + /** + * Creates arch reader struct + * @param env pointer to environment struct + * @return pointer to newly created arch reader + */ + AXIS2_EXTERN axis2_arch_reader_t *AXIS2_CALL + axis2_arch_reader_create( + const axutil_env_t * env); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_ARCH_READER_H */ diff --git a/src/core/deployment/axis2_conf_builder.h b/src/core/deployment/axis2_conf_builder.h new file mode 100644 index 0000000..9a0aa91 --- /dev/null +++ b/src/core/deployment/axis2_conf_builder.h @@ -0,0 +1,116 @@ + +/* + * 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_CONF_BUILDER_H +#define AXIS2_CONF_BUILDER_H + +/** + * @defgroup axis2_conf_builder Conf Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include "axis2_desc_builder.h" +#include +#include "axis2_dep_engine.h" +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_desc_builder; + struct axis2_dep_engine; + + /** Type name for struct axis2_conf_builder */ + typedef struct axis2_conf_builder axis2_conf_builder_t; + + /** + * De-allocate memory + * @param conf_builder pointer to configuration builder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_conf_builder_free( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env); + + /** + * @param conf_builder pointer to configuration builder + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_conf_builder_populate_conf( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env); + + /** + * To get the list og modules that is requird to be engage globally + * @param conf_builder pointer to configuration builder + * @param env pointer to environment struct + * @param module_refs pointer to module refs + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_conf_builder_process_module_refs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs); + + /** + * Creates conf builder struct + * @param env pointer to environment struct + * @return pointer to newly created conf builder + */ + AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL + axis2_conf_builder_create( + const axutil_env_t * env); + + /** + * Creates conf builder struct + * @param env pointer to environment struct + * @param file This is the full path to the server xml file + * @param dep_engine pointer to dep engine + * @param conf pointer to conf + * @return pointer to newly created conf builder + */ + + AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL + + axis2_conf_builder_create_with_file_and_dep_engine_and_conf( + const axutil_env_t * env, + axis2_char_t * file, + struct axis2_dep_engine *dep_engine, + axis2_conf_t * conf); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_CONF_BUILDER_H */ diff --git a/src/core/deployment/axis2_dep_engine.h b/src/core/deployment/axis2_dep_engine.h new file mode 100644 index 0000000..a9130af --- /dev/null +++ b/src/core/deployment/axis2_dep_engine.h @@ -0,0 +1,418 @@ + +/* + * 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_DEP_ENGINE_H +#define AXIS2_DEP_ENGINE_H + +/** + * @defgroup axis2_dep_engine Deployment Engine + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_dep_engine.h + * @brief Axis2 Deployment Engine interface + */ + +#include +#include +#include +#include +#include +#include "axis2_arch_file_data.h" +#include "axis2_ws_info.h" +#include "axis2_conf_builder.h" +#include "axis2_repos_listener.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + struct axis2_arch_file_data; + struct axis2_arch_reader; + struct axis2_ws_info; + struct axis2_phases_info; + struct axis2_svc; + + /** Type name for struct axis2_dep_engine */ + typedef struct axis2_dep_engine axis2_dep_engine_t; + struct axis2_desc_builder; + struct axis2_module_builder; + struct axis2_svc_builder; + struct axis2_grp_builder; + struct axis2_svc_grp_builder; + + /** + * De-allocate memory + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_dep_engine_free( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * while parsing the axis2.xml the module refferences have to be stored some + * where , since at that time none of module availble (they load after parsing + * the document) + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param module_qname QName + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_qname); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param module_name pointer to module name + */ + AXIS2_EXTERN struct axis2_module_desc *AXIS2_CALL + + axis2_dep_engine_get_module( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_name); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_arch_file_data *AXIS2_CALL + + axis2_dep_engine_get_current_file_item( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param file pointer to file + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_ws_to_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_arch_file_data *file); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param file pointer to file + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_dep_engine_add_ws_to_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_ws_info *file); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_phases_info *AXIS2_CALL + axis2_dep_engine_get_phases_info( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return AxisConfiguration AxisConfiguration + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_dep_engine_get_axis_conf( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_dep_engine_load( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_conf *AXIS2_CALL + axis2_dep_engine_load_client( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param dll_name pointer to dll_name + */ + AXIS2_EXTERN void *AXIS2_CALL + axis2_dep_engine_get_handler_dll( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * dll_name); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_do_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_dep_engine_is_hot_update( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param phases_info pointer to phases info + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_phases_info( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_phases_info *phases_info); + + /** + * This method is used to fill a axisservice object using services.xml , first it should create + * an axisservice object using WSDL and then fill that using given servic.xml and load all the requed + * class and build the chains , finally add the servicecontext to EngineContext and axisservice into + * EngineConfiguration + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param svc pointer to service + * @param file_name pointer to file name + */ + AXIS2_EXTERN struct axis2_svc *AXIS2_CALL + axis2_dep_engine_build_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_svc *svc, + axis2_char_t * file_name); + + /** + * This method can be used to build ModuleDescription for a given module archiev file + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param module_archive pointer to module archive + * @param conf pointer to conf + */ + AXIS2_EXTERN struct axis2_module_desc *AXIS2_CALL + axis2_dep_engine_build_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_file_t * module_archive, + struct axis2_conf *conf); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_dep_engine_get_repos_path( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to module directory + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_dep_engine_get_file_flag( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + + /** + * @param dep_engine pointer to module directory + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_dep_engine_get_module_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + /** + * @param dep_engine pointer to module directory + * @param env pointer to environment struct + * @param module_dir pointer of the directory path + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_module_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *module_dir); + + + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_dep_engine_get_svc_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_svc_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *svc_dir); + + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param file_data pointer to file data + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_current_file_item( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_arch_file_data *file_data); + + /** + * @param dep_engine pointer to deployment engine + * @param env pointer to environment struct + * @param arch_reader pointer to arch reader + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_set_arch_reader( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_arch_reader *arch_reader); + + /** + * No param constructor is need to deploye module and service programatically + * @param env pointer to environment struct + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create( + const axutil_env_t * env); + + /** + * Creates description builder struct + * This the constructor which is used by Engine in order to start + * Deployment module, + * @param env pointer to environment struct + * @param repos_path is the path to which Repositary Listner should listen. + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create_with_repos_name( + const axutil_env_t * env, + const axis2_char_t * repos_path); + + + /** + * Creates description builder struct using axis2 xml + * This the constructor which is used by Engine in order to start + * Deployment module, + * @param env pointer to environment struct + * @param axis2_xml is the path of the axis2.xml . + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create_with_axis2_xml( + const axutil_env_t * env, + const axis2_char_t * axis2_xml); + + + /** + * Creates deployment engine struct + * @param env pointer to environment struct + * @param repos_path is the path to which Repositary Listner should listen. + * @param svr_xml_file pointer to service xml file + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + + axis2_dep_engine_create_with_repos_name_and_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * repos_path, + const axis2_char_t * svr_xml_file); + + AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL + axis2_dep_engine_create_with_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * svr_xml_file); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_desc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_desc_builder *desc_builder); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_module_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_module_builder *module_builder); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_dep_engine_add_svc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_svc_builder *svc_builder); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_dep_engine_add_svc_grp_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_svc_grp_builder *svc_grp_builder); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_DEP_ENGINE_H */ diff --git a/src/core/deployment/axis2_deployment.h b/src/core/deployment/axis2_deployment.h new file mode 100644 index 0000000..044f10f --- /dev/null +++ b/src/core/deployment/axis2_deployment.h @@ -0,0 +1,119 @@ + +/* + * 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_DEPLOYMENT_H +#define AXIS2_DEPLOYMENT_H + +/** + * @file axis2_axis2_deployment.h + * @brief axis2 deployment + */ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/*********************************** Constansts********************************/ + +/** + * DeployCons interface is to keep constent value required for Deployemnt + */ + +#define AXIS2_SVC 0 /* if it is a service */ +#define AXIS2_MODULE 1 /* if it is a module */ + +#define AXIS2_SVC_XML "services.xml" +#define AXIS2_MODULE_XML "module.xml" +#define AXIS2_PARAMETERST "parameter" /* paramater start tag */ +#define AXIS2_HANDLERST "handler" +#define AXIS2_MODULEST "module" +#define AXIS2_PHASEST "phase" +#define AXIS2_PHASE_ORDER "phaseOrder" +#define AXIS2_OPERATIONST "operation" /* operation start tag */ +#define AXIS2_IN_FLOW_START "inflow" /* inflow start tag */ +#define AXIS2_OUT_FLOW_START "outflow" /* outflowr start tag */ +#define AXIS2_IN_FAILTFLOW "INfaultflow" /* faultflow start tag */ +#define AXIS2_OUT_FAILTFLOW "Outfaultflow" /* faultflow start tag */ + +#define AXIS2_MODULE_PATH "modules" +#define AXIS2_SVC_PATH "services" + +/* for parameters */ +#define AXIS2_ATTNAME "name" +#define AXIS2_ATTLOCKED "locked" +#define AXIS2_TYPE "type" + +/* for operations */ +#define AXIS2_MEP "mep" + +/* for messages */ +#define AXIS2_MESSAGE "message" +#define AXIS2_LABEL "label" + +/* for handlers */ +#define AXIS2_REF "ref" +#define AXIS2_CLASSNAME "class" +#define AXIS2_BEFORE "before" +#define AXIS2_AFTER "after" +#define AXIS2_PHASE "phase" +#define AXIS2_PHASEFIRST "phaseFirst" +#define AXIS2_PHASELAST "phaseLast" +#define AXIS2_ORDER "order" /* to resolve the order tag */ +#define AXIS2_DESCRIPTION "description" + +#define AXIS2_TRANSPORTSENDER "transportSender" +#define AXIS2_TRANSPORTRECEIVER "transportReceiver" + +#define AXIS2_MESSAGERECEIVER "messageReceiver" + +#define AXIS2_HOTDEPLOYMENT "hotdeployment" +#define AXIS2_HOTUPDATE "hotupdate" +#define AXIS2_DISPATCH_ORDER "dispatchOrder" +#define AXIS2_DISPATCHER "dispatcher" + +/* element in a services.xml */ +#define AXIS2_SVC_ELEMENT "service" +#define AXIS2_SVC_WSDL_PATH "wsdl_path" +#define AXIS2_SVC_GRP_ELEMENT "serviceGroup" + +#define AXIS2_SERVER_XML_FILE "axis2.xml" + +#define AXIS2_MODULE_FOLDER "modules" +#define AXIS2_SERVICE_FOLDER "services" +#define AXIS2_LIB_FOLDER "lib" +#define AXIS2_LIB_DIR "libDir" + +#define AXIS2_ATTRIBUTE_DEFAULT_VERSION "version" +#define AXIS2_DEFAULT_MODULE_VERSION "defaultModuleVersions" + +/*********************************** Constants*********************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* AXIS2_DEPLOYMENT_H */ diff --git a/src/core/deployment/axis2_desc_builder.h b/src/core/deployment/axis2_desc_builder.h new file mode 100644 index 0000000..347f592 --- /dev/null +++ b/src/core/deployment/axis2_desc_builder.h @@ -0,0 +1,292 @@ + +/* + * 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_DESC_BUILDER_H +#define AXIS2_DESC_BUILDER_H + +/** @defgroup axis2_desc_builder Description Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include "axis2_deployment.h" +#include "axis2_dep_engine.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_flow; + struct axis2_phase; + struct axis2_dep_engine; + + /** Type name for struct axis2_desc_builder */ + typedef struct axis2_desc_builder axis2_desc_builder_t; + + /** + * De-allocate memory + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_desc_builder_free( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env); + + /** + * This will creat OMElemnt for a given descrition document (axis2.xml , + * services.xml and module.xml) + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @return OMElement OMElement + */ + AXIS2_EXTERN axiom_node_t *AXIS2_CALL + axis2_desc_builder_build_om( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env); + + /** + * To process Flow elements in services.xml + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param flow_element axiom_element_t + * @param parent pointer to parent + * @param node pointer to node + * @return flow + */ + AXIS2_EXTERN axis2_flow_t *AXIS2_CALL + axis2_desc_builder_process_flow( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_element_t * flow_element, + axutil_param_container_t * parent, + axiom_node_t * node); + + /** + * To process Handler element + * @param handler_element OMElement + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param handler_element pointer to handler element + * @param parent pointer to parent + */ + AXIS2_EXTERN axis2_handler_desc_t *AXIS2_CALL + + axis2_desc_builder_process_handler( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * handler_element, + axutil_param_container_t * parent); + + /** + * To get the Param out from the OM + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param params axutil_param_t + * @param param_container axutil_param_container_t + * @param parent axutil_param_container_t + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_builder_process_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * params, + axutil_param_container_t * param_container, + axutil_param_container_t * parent); + + /** + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param module_refs pointer to module refs + * @param op pointer to op + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_desc_builder_process_op_module_refs( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_op_t * op); + + /** + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param recv_element pointer to recv element + */ + AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL + + axis2_desc_builder_load_msg_recv( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_element_t * recv_element); + + /** + * This method is used to retrive service name form the arechive file name + * if the archive file name is service1.aar , then axis service name would be service1 + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_desc_builder_get_short_file_name( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param short_file_name pointer to short file name + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + + axis2_desc_builder_get_file_name_without_prefix( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * short_file_name); + + /** + * this method is to get the value of attribue + * eg xsd:anyVal --> anyVal + * @param desc_builder pointer to desc builder + * @param env pointer to environment struct + * @param in pointer to in + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_desc_builder_get_value( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * in); + + /** + * Populate the Axis2 Operation with details from the actionMapping, + * outputActionMapping and faultActionMapping elements from the operation + * element. + * @param operation + * @param op_desc + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_builder_process_action_mappings( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc); + + /** + * Populate the Axis2 Operation with details from the RESTLocation, + * RESTMethod elements from the operation element. + * @param operation + * @param op_desc + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_desc_builder_process_rest_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc); + + /** + * @param env pointer to environment struct + */ + AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL + axis2_desc_builder_load_default_msg_recv( + const axutil_env_t * env); + + AXIS2_EXTERN struct axis2_dep_engine *AXIS2_CALL + axis2_desc_builder_get_dep_engine( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env); + + /** + * Creates description builder struct + * @param env pointer to environment struct + * @return pointer to newly created description builder + */ + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + axis2_desc_builder_create( + const axutil_env_t * env); + + /** + * Creates description builder struct + * @param env pointer to environment struct + * @param engine pointer to engine + * @return pointer to newly created description builder + */ + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + + axis2_desc_builder_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine *engine); + + /** + * Creates description builder struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param engine pointer to engine + * @return pointer to newly created description builder + */ + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + + axis2_desc_builder_create_with_file_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *engine); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_process_policy_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_process_policy_reference_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_DESC_BUILDER_H */ diff --git a/src/core/deployment/axis2_module_builder.h b/src/core/deployment/axis2_module_builder.h new file mode 100644 index 0000000..cd713d6 --- /dev/null +++ b/src/core/deployment/axis2_module_builder.h @@ -0,0 +1,101 @@ + +/* + * 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_MODULE_BUILDER_H +#define AXIS2_MODULE_BUILDER_H + +/** @defgroup axis2_module_builder Module Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_module_builder */ + typedef struct axis2_module_builder axis2_module_builder_t; + + /** + * De-allocate memory + * @param module_builder pointer to module builder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_module_builder_free( + axis2_module_builder_t * module_builder, + const axutil_env_t * env); + + /** + * @param module_builder pointer to module builder + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_module_builder_populate_module( + axis2_module_builder_t * module_builder, + const axutil_env_t * env); + + /** + * Creates module builder struct + * @param env pointer to environment struct + * @return pointer to newly created module builder + */ + AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL + + axis2_module_builder_create( + const axutil_env_t * env); + + /** + * Creates module builder struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param dep_engine pointer to deployment engine + * @return pointer to newly created module builder + */ + AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL + + axis2_module_builder_create_with_file_and_dep_engine_and_module( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *dep_engine, + axis2_module_desc_t * module); + + /** Populates the module. + #define AXIS2_MODULE_BUILDER_POPULATE_MODULE(module_builder, env) \ + axis2_module_builder_populate_module (module_builder, env)*/ + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_MODULE_BUILDER_H */ diff --git a/src/core/deployment/axis2_repos_listener.h b/src/core/deployment/axis2_repos_listener.h new file mode 100644 index 0000000..56a37c8 --- /dev/null +++ b/src/core/deployment/axis2_repos_listener.h @@ -0,0 +1,144 @@ + +/* + * 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_REPOS_LISTENER_H +#define AXIS2_REPOS_LISTENER_H + +/** @defgroup axis2_repos_listener Repos Listener + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include "axis2_ws_info_list.h" +#include "axis2_dep_engine.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_dep_engine; + + /** Type name for struct axis2_repos_listener */ + typedef struct axis2_repos_listener axis2_repos_listener_t; + + /** + * De-allocate memory + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_repos_listener_free( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env); + + /** + * + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_repos_listener_check_modules( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_check_svcs( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_update( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * + * then it call to check_modules to load all the modules. + * and then it call to update() method inorder to update the deployment engine and engine. + * @param repos_listener pointer to repos listener + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_init( + axis2_repos_listener_t * listener, + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL + axis2_repos_listener_create( + const axutil_env_t * env); + + /** + * @param env pointer to environment struct + * @param folder_name this is the axis2 deployment root directory(repository path) + * @param dep_engine pointer to deployment engine + * @return pointer to newly created deployment engine + */ + AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL + axis2_repos_listener_create_with_folder_name_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * folder_name, + struct axis2_dep_engine *dep_engine); + + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_repos_listener_set_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env, + axis2_conf_t *conf); + + AXIS2_EXTERN axis2_conf_t *AXIS2_CALL + axis2_repos_listener_get_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env); + + + + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_REPOS_LISTENER_H */ diff --git a/src/core/deployment/axis2_svc_builder.h b/src/core/deployment/axis2_svc_builder.h new file mode 100644 index 0000000..c71e7dc --- /dev/null +++ b/src/core/deployment/axis2_svc_builder.h @@ -0,0 +1,149 @@ + +/* + * 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_SVC_BUILDER_H +#define AXIS2_SVC_BUILDER_H + +/** + * @defgroup axis2_svc_builder Service Builder + * @ingroup axis2_deployment + * @{ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_dep_engine; + + /** Type name for struct axis2_svc_builder */ + typedef struct axis2_svc_builder axis2_svc_builder_t; + + /** + * De-allocate memory + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_builder_free( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env); + + /** + * top most method that is used to populate service from corresponding OM + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + * @param svc_node pointer to service node + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_svc_builder_populate_svc( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_node_t * svc_node); + + /** + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + * @param module_confs pointer to module configurations + * @param parent pointer to parent + * @param svc pointer to service + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_builder_process_svc_module_conf( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_confs, + axutil_param_container_t * parent, + axis2_svc_t * svc); + + /** + * To get the list og modules that is requird to be engage globally + * @param svc_builder pointer to service builder + * @param env pointer to environment struct + * @param module_refs pointer to module refs + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_builder_process_module_refs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs); + + AXIS2_EXTERN struct axis2_desc_builder *AXIS2_CALL + + axis2_svc_builder_get_desc_builder( + const axis2_svc_builder_t * svc_builder, + const axutil_env_t * env); + + /** + * Creates svc builder struct + * @param env pointer to environment struct + * @return pointer to newly created service builder + */ + AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL + axis2_svc_builder_create( + const axutil_env_t * env); + + /** + * Creates svc builder struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param dep_engine pointer to deployment engine + * @param svc pointer to service + * @return pointer to newly created service builder + */ + AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL + + axis2_svc_builder_create_with_file_and_dep_engine_and_svc( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine *dep_engine, + axis2_svc_t * svc); + + /** + * Creates svc builder struct + * @param env pointer to environment struct + * @param dep_engine pointer to deployment engine + * @param svc pointer to service + * @return pointer to newly created service builder + */ + AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL + + axis2_svc_builder_create_with_dep_engine_and_svc( + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine, + axis2_svc_t * svc); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SVC_BUILDER_H */ diff --git a/src/core/deployment/axis2_svc_grp_builder.h b/src/core/deployment/axis2_svc_grp_builder.h new file mode 100644 index 0000000..852c9a7 --- /dev/null +++ b/src/core/deployment/axis2_svc_grp_builder.h @@ -0,0 +1,122 @@ + +/* + * Copyright 2004,2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not svc_grp 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_SVC_GRP_BUILDER_H +#define AXIS2_SVC_GRP_BUILDER_H + +/** @defgroup axis2_svc_grp_builder Service Group Builder + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_svc_grp_builder.h + * @brief Axis2 Service Group Builder interface + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type name for struct axis2_svc_grp_builder */ + typedef struct axis2_svc_grp_builder axis2_svc_grp_builder_t; + + /** + * De-allocate memory + * @param svc_grp_builder pointer to service group builder + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_svc_grp_builder_free( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env); + + /** + * @param grp_builder pointer to group builder + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_grp_builder_populate_svc_grp( + axis2_svc_grp_builder_t * grp_builder, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp); + + /** + * To get the list og modules that is requird to be engage globally + * @param grp_builder pointer to group builder + * @param env pointer to environment struct + * @param module_refs axiom_children_qname_iterator_t + * @param svc_group pointer to service group + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_svc_grp_builder_process_module_refs( + axis2_svc_grp_builder_t * grp_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_svc_grp_t * svc_grp); + + AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL + + axis2_svc_grp_builder_get_desc_builder( + const axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env); + + /** + * Creates svc_grp builder struct + * @param env pointer to environment struct + * @return pointer to newly created service group builder + */ + AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL + + axis2_svc_grp_builder_create( + const axutil_env_t * env); + + /** + * Creates svc_grp builder struct + * @param env pointer to environment strut + * @param svc pointer to service + * @param dep_engine pointer to deployment engine + * @return pointer to newly created service group builder + */ + AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL + + axis2_svc_grp_builder_create_with_svc_and_dep_engine( + const axutil_env_t * env, + axiom_node_t * svc, + axis2_dep_engine_t * dep_engine); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_SVC_GRP_BUILDER_H */ diff --git a/src/core/deployment/axis2_ws_info.h b/src/core/deployment/axis2_ws_info.h new file mode 100644 index 0000000..d6fd117 --- /dev/null +++ b/src/core/deployment/axis2_ws_info.h @@ -0,0 +1,144 @@ + +/* + * 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_WS_INFO_H +#define AXIS2_WS_INFO_H + +/** + * @defgroup axis2_ws_info Ws Info + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_ws_info.h + * @brief Axis2 Ws Info interface. ws_info construct contain file information + * for module or service configuration file. + */ +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_conf; + + /** Type name for struct axis2_ws_info */ + typedef struct axis2_ws_info axis2_ws_info_t; + + /** + * De-allocate memory + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_ws_info_free( + axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN axis2_char_t *AXIS2_CALL + axis2_ws_info_get_file_name( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ws_info_set_file_name( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN long AXIS2_CALL + axis2_ws_info_get_last_modified_date( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + * @param modified_data pointer to modified date + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_ws_info_set_last_modified_date( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + long last_modified_date); + + /** + * @param ws_info pointer to ws info + * @param env pointer to environment struct + */ + AXIS2_EXTERN int AXIS2_CALL + axis2_ws_info_get_type( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env); + + /** + * Creates ws_info struct + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param last_modified_date pointer to last modified date + * @return pointer to newly created ws info + */ + AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL + + axis2_ws_info_create_with_file_name_and_last_modified_date( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date); + + /** + * @param env pointer to environment struct + * @param file_name pointer to file name + * @param last_modifile_date last modified date + * @param type type + */ + AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL + + axis2_ws_info_create_with_file_name_and_last_modified_date_and_type( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date, + int type); + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_WS_INFO_H */ diff --git a/src/core/deployment/axis2_ws_info_list.h b/src/core/deployment/axis2_ws_info_list.h new file mode 100644 index 0000000..3ffb68d --- /dev/null +++ b/src/core/deployment/axis2_ws_info_list.h @@ -0,0 +1,192 @@ + +/* + * 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_WS_INFO_LIST_H +#define AXIS2_WS_INFO_LIST_H + +/** @defgroup axis2_ws_info_list Ws Info List + * @ingroup axis2_deployment + * @{ + */ + +/** + * @file axis2_ws_info_list.h + * @brief Axis2 Ws Info List interface. Ws Info List is the list of ws_info structs. + * Each ws_info construct contain file information for module or service configuration file. + */ + +#include +#include +#include +#include +#include +#include +#include +#include "axis2_deployment.h" +#include +#include +#include "axis2_ws_info.h" +#include "axis2_arch_file_data.h" +#include "axis2_dep_engine.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + struct axis2_ws_info; + struct axis2_dep_engine; + + /** Type name for struct axis2_ws_info_list */ + typedef struct axis2_ws_info_list axis2_ws_info_list_t; + + /** + * De-allocate memory + * @param ws_info_list pointer to ws info list + * @param env pointer to environment struct + * @return void + */ + AXIS2_EXTERN void AXIS2_CALL + axis2_ws_info_list_free( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env); + + /** + * This method is used to initialize the ws info list. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ws_info_list_init( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env); + + /** + * This will add the deployment info struct(ws_info) into the deployment info + * list and deployment info file to the deployment engine as new + * service or module deployment info struct/file. + * In doing this, it first create an deployment info struct called ws_info + * to keep the file info that will be added to deployment info file + * list and then create deployment info file called arch_file_data that will + * be added to deployment engine for actual deployment of the service/module. + * + * This will add two entries to deployment engine one for new Deployment and + * other for undeployment. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file actual axis2 configuration file for module/service. + * @param type indicate either service or module + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_ws_info_list_add_ws_info_item( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axutil_file_t * file, + int type); + + /** + * This method is used to check whether the service/module configuration + * file exist and if so it will return related ws_info object to the file, + * else return NULL; + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL + + axis2_ws_info_list_get_file_item( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * Compare the last update dates of both files and if those differ + * it will be assumed as the file has been modified. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file pointer to servie/module configuration file. + * @param ws_info pointer to ws info struct. + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_ws_info_list_is_modified( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axutil_file_t * file, + struct axis2_ws_info *ws_info); + + /** + * To check whether the deployment info file is alredy in the list. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @param file_name pointer to file name + */ + AXIS2_EXTERN axis2_bool_t AXIS2_CALL + axis2_ws_info_list_is_file_exist( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env, + axis2_char_t * file_name); + + /** + * This is to check whether to undeploy ws info struct. + * What this realy does is, it check ws_info list and current deployment + * info name list. If ws_info exists in the ws_info_list but it's + * corresponding file name does not exist in the current deploymet file + * name list then, struct is deemed non existant. ie. that is hot + * undeployment. + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + + axis2_ws_info_list_check_for_undeploy( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env); + + /** + * @param info_list pointer to ws info list + * @param env pointer to environment struct + * @return AXIS2_SUCCESS on success, else AXIS2_FAILURE + */ + AXIS2_EXTERN axis2_status_t AXIS2_CALL + axis2_ws_info_list_update( + axis2_ws_info_list_t * info_list, + const axutil_env_t * env); + + /** + * Creates ws info list struct + * @param env pointer to environment struct + * @param dep_engine pointer to deployment engine + * @return pointer to newly created ws info list + */ + AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALL + + axis2_ws_info_list_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine); + + + /** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* AXIS2_WS_INFO_LIST_H */ diff --git a/src/core/deployment/conf_builder.c b/src/core/deployment/conf_builder.c new file mode 100644 index 0000000..15485b0 --- /dev/null +++ b/src/core/deployment/conf_builder.c @@ -0,0 +1,1337 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_conf_builder +{ + axis2_conf_t *conf; + struct axis2_desc_builder *desc_builder; +}; + +static axis2_status_t +axis2_conf_builder_process_disp_order( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * disp_order_node); + +static axis2_status_t +axis2_conf_builder_process_phase_orders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * phase_orders); + +static axutil_array_list_t * +axis2_conf_builder_get_phase_list( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * phase_orders_node); + +static axis2_status_t +axis2_conf_builder_process_transport_senders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_senders); + +static axis2_status_t +axis2_conf_builder_process_transport_recvs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_recvs); + +static axis2_status_t AXIS2_CALL +axis2_conf_builder_process_default_module_versions( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_versions); + +AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL +axis2_conf_builder_create( + const axutil_env_t * env) +{ + axis2_conf_builder_t *conf_builder = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + conf_builder = (axis2_conf_builder_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_conf_builder_t)); + + if(!conf_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + conf_builder->conf = NULL; + + return conf_builder; +} + +AXIS2_EXTERN axis2_conf_builder_t *AXIS2_CALL +axis2_conf_builder_create_with_file_and_dep_engine_and_conf( + const axutil_env_t * env, + axis2_char_t * file, + axis2_dep_engine_t * engine, + axis2_conf_t * conf) +{ + axis2_conf_builder_t *conf_builder = NULL; + + conf_builder = (axis2_conf_builder_t *)axis2_conf_builder_create(env); + if(!conf_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + conf_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, file, + engine); + conf_builder->conf = conf; + + return conf_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_conf_builder_free( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env) +{ + if(conf_builder->desc_builder) + { + axis2_desc_builder_free(conf_builder->desc_builder, env); + } + + if(conf_builder) + { + AXIS2_FREE(env->allocator, conf_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_builder_populate_conf( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env) +{ + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmsgrecv = NULL; + axutil_qname_t *qdisporder = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qtransportsender = NULL; + axutil_qname_t *qtransportrecv = NULL; + axutil_qname_t *qphaseorder = NULL; + axutil_qname_t *qdefmodver = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *msg_recvs = NULL; + axiom_children_qname_iterator_t *module_itr = NULL; + axiom_children_qname_iterator_t *trs_senders = NULL; + axiom_children_qname_iterator_t *trs_recvs = NULL; + axiom_children_qname_iterator_t *phase_orders = NULL; + axiom_children_qname_iterator_t *def_mod_versions = NULL; + axiom_element_t *conf_element = NULL; + axiom_node_t *conf_node = NULL; + axiom_element_t *disp_order_element = NULL; + axiom_node_t *disp_order_node = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_param_t *param = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_populate_conf"); + conf_node = axis2_desc_builder_build_om(conf_builder->desc_builder, env); + if(!conf_node) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Building om tree failed. Unable to continue"); + return AXIS2_FAILURE; + } + conf_element = axiom_node_get_data_element(conf_node, env); + /* processing Paramters */ + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(conf_element, env, qparamst, conf_node); + axutil_qname_free(qparamst, env); + axis2_desc_builder_process_params(conf_builder->desc_builder, env, itr, + axis2_conf_get_param_container(conf_builder->conf, env), axis2_conf_get_param_container( + conf_builder->conf, env)); + /* process Message Reciver */ + qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL); + msg_recvs = axiom_element_get_children_with_qname(conf_element, env, qmsgrecv, conf_node); + axutil_qname_free(qmsgrecv, env); + while(axiom_children_qname_iterator_has_next(msg_recvs, env)) + { + axiom_node_t *msg_recv_node = NULL; + axiom_element_t *msg_recv_element = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axiom_attribute_t *recv_name = NULL; + axutil_qname_t *class_qname = NULL; + axis2_char_t *class_name = NULL; + + msg_recv_node = (axiom_node_t *)axiom_children_qname_iterator_next(msg_recvs, env); + msg_recv_element = (axiom_element_t *)axiom_node_get_data_element(msg_recv_node, env); + msg_recv = axis2_desc_builder_load_msg_recv(conf_builder->desc_builder, env, + msg_recv_element); + if(!msg_recv) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Message receiver loading failed. Unable to continue"); + return AXIS2_FAILURE; + } + + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + recv_name = axiom_element_get_attribute(msg_recv_element, env, class_qname); + axutil_qname_free(class_qname, env); + class_name = axiom_attribute_get_value(recv_name, env); + axis2_conf_add_msg_recv(conf_builder->conf, env, class_name, msg_recv); + } + + /* processing Dispatching Order */ + qdisporder = axutil_qname_create(env, AXIS2_DISPATCH_ORDER, NULL, NULL); + disp_order_element = axiom_element_get_first_child_with_qname(conf_element, env, qdisporder, + conf_node, &disp_order_node); + axutil_qname_free(qdisporder, env); + if(disp_order_element) + { + axis2_conf_builder_process_disp_order(conf_builder, env, disp_order_node); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Found the custom disptaching" + " order and continue with that order"); + } + else + { + status = axis2_conf_set_default_dispatchers(conf_builder->conf, env); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting default dispatchers to configuration failed, " + "unable to continue."); + return AXIS2_FAILURE; + } + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No custom dispatching order" + " found. Continue with the default dispatching order"); + } + + /* Process Module refs */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_itr = axiom_element_get_children_with_qname(conf_element, env, qmodulest, conf_node); + axutil_qname_free(qmodulest, env); + status = axis2_conf_builder_process_module_refs(conf_builder, env, module_itr); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing module ref's failed, unable to continue."); + return AXIS2_FAILURE; + } + /* Proccessing Transport Sennders */ + qtransportsender = axutil_qname_create(env, AXIS2_TRANSPORTSENDER, NULL, NULL); + trs_senders = axiom_element_get_children_with_qname(conf_element, env, qtransportsender, + conf_node); + axutil_qname_free(qtransportsender, env); + status = axis2_conf_builder_process_transport_senders(conf_builder, env, trs_senders); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing transport senders failed, unable to continue"); + return AXIS2_FAILURE; + } + + /* Proccessing Transport Recivers */ + qtransportrecv = axutil_qname_create(env, AXIS2_TRANSPORTRECEIVER, NULL, NULL); + trs_recvs = axiom_element_get_children_with_qname(conf_element, env, qtransportrecv, conf_node); + axutil_qname_free(qtransportrecv, env); + status = axis2_conf_builder_process_transport_recvs(conf_builder, env, trs_recvs); + + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing transport receivers failed, unable to continue"); + return AXIS2_FAILURE; + } + + /* processing Phase orders */ + qphaseorder = axutil_qname_create(env, AXIS2_PHASE_ORDER, NULL, NULL); + phase_orders = axiom_element_get_children_with_qname(conf_element, env, qphaseorder, conf_node); + axutil_qname_free(qphaseorder, env); + status = axis2_conf_builder_process_phase_orders(conf_builder, env, phase_orders); + + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing phase orders failed, unable to continue"); + return AXIS2_FAILURE; + } + + /* Processing default module versions */ + qdefmodver = axutil_qname_create(env, AXIS2_DEFAULT_MODULE_VERSION, NULL, NULL); + def_mod_versions = axiom_element_get_children_with_qname(conf_element, env, qdefmodver, + conf_node); + axutil_qname_free(qdefmodver, env); + if(def_mod_versions) + { + status = axis2_conf_builder_process_default_module_versions(conf_builder, env, + def_mod_versions); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing default module versions failed, unable to continue"); + return AXIS2_FAILURE; + } + } + + param = axutil_param_container_get_param( + axis2_conf_get_param_container(conf_builder->conf, env), env, AXIS2_ENABLE_MTOM); + if(param) + { + axis2_char_t *value = NULL; + value = axutil_param_get_value(param, env); + if(value) + { + axis2_conf_set_enable_mtom(conf_builder->conf, env, (!axutil_strcmp(value, + AXIS2_VALUE_TRUE))); + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_populate_conf"); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_conf_builder_process_module_refs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs) +{ + axis2_status_t status = AXIS2_SUCCESS; + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_module_refs"); + AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_node_t *module_ref_node = NULL; + axiom_element_t *module_ref_element = NULL; + axutil_qname_t *qref = NULL; + + axiom_attribute_t *module_ref_att = NULL; + module_ref_node = (axiom_node_t *)axiom_children_qname_iterator_next(module_refs, env); + if(!module_ref_node) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Module ref node is empty. Unable to continue"); + return AXIS2_FAILURE; + } + module_ref_element = axiom_node_get_data_element(module_ref_node, env); + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref); + if(qref) + { + axutil_qname_free(qref, env); + } + + if(module_ref_att) + { + axutil_qname_t *qrefname = NULL; + axis2_char_t *ref_name = NULL; + + ref_name = axiom_attribute_get_value(module_ref_att, env); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Module %s found in axis2.xml", ref_name); + qrefname = axutil_qname_create(env, ref_name, NULL, NULL); + status = axis2_dep_engine_add_module(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env, qrefname); + if(qrefname) + { + axutil_qname_free(qrefname, env); + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_module_refs"); + return status; +} + +static axis2_status_t +axis2_conf_builder_process_disp_order( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * disp_order_node) +{ + axiom_element_t *disp_order_element = NULL; + axiom_children_qname_iterator_t *disps = NULL; + axutil_qname_t *qdisp = NULL; + axis2_bool_t found_disp = AXIS2_FALSE; + axis2_phase_t *disp_phase = NULL; + int count = 0; + axis2_bool_t qname_itr_has_next = AXIS2_FALSE; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_disp_order"); + AXIS2_PARAM_CHECK(env->error, disp_order_node, AXIS2_FAILURE); + + disp_order_element = axiom_node_get_data_element(disp_order_node, env); + qdisp = axutil_qname_create(env, AXIS2_DISPATCHER, NULL, NULL); + disps = axiom_element_get_children_with_qname(disp_order_element, env, qdisp, disp_order_node); + axutil_qname_free(qdisp, env); + disp_phase = axis2_phase_create(env, AXIS2_PHASE_DISPATCH); + if(!disp_phase) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Dispatch phase creation failed. Unable to continue"); + return AXIS2_FAILURE; + } + if(disps) + { + qname_itr_has_next = axiom_children_qname_iterator_has_next(disps, env); + } + while(qname_itr_has_next) + { + axiom_node_t *disp_node = NULL; + axiom_element_t *disp_element = NULL; + axiom_attribute_t *disp_att = NULL; + axis2_char_t *class_name = NULL; + axis2_char_t *dll_name = NULL; + axutil_qname_t *class_qname = NULL; + axis2_disp_t *disp_dll = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axis2_handler_desc_t *handler_desc = NULL; + axis2_handler_t *handler = NULL; + + found_disp = AXIS2_TRUE; + disp_node = (axiom_node_t *)axiom_children_qname_iterator_next(disps, env); + disp_element = (axiom_element_t *) axiom_node_get_data_element(disp_node, env); + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + disp_att = axiom_element_get_attribute(disp_element, env, class_qname); + axutil_qname_free(class_qname, env); + if(!disp_att) + { + qname_itr_has_next = axiom_children_qname_iterator_has_next(disps, env); + continue; + } + class_name = axiom_attribute_get_value(disp_att, env); + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + axutil_dll_desc_set_name(dll_desc, env, dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_HANDLER_DLL); + impl_info_param = axutil_param_create(env, class_name, NULL); + if(!impl_info_param) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Parameter creation failed for %s. Unable to continue", class_name); + + axis2_phase_free(disp_phase, env); + + return AXIS2_FAILURE; + } + + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + disp_dll = (axis2_disp_t *)axutil_class_loader_create_dll(env, impl_info_param); + + handler = axis2_disp_get_base(disp_dll, env); + handler_desc = axis2_handler_get_handler_desc(handler, env); + axis2_handler_desc_add_param(handler_desc, env, impl_info_param); + + axis2_phase_add_handler_at(disp_phase, env, count, handler); + count++; + qname_itr_has_next = axiom_children_qname_iterator_has_next(disps, env); + + } + + if(!found_disp) + { + axis2_phase_free(disp_phase, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_DISPATCHER_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No dispatcher found. Unable to continue"); + + return AXIS2_FAILURE; + } + else + { + status = axis2_conf_set_dispatch_phase(conf_builder->conf, env, disp_phase); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting dispatch phase failed. Unable to continue"); + + axis2_phase_free(disp_phase, env); + + return status; + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_disp_order"); + return AXIS2_SUCCESS; +} + +/** + * To process all the phase orders which are defined in axis2.xml retrieve each phase order node + * from the iterator passed as parameter and from each phase order node retrieve phases list + * defined for that phase order. Add the phases names into a array list and set it into the + * dep_engine->phases_info with the corresponding phase order name. + * @param phase_orders + */ +static axis2_status_t +axis2_conf_builder_process_phase_orders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * phase_orders) +{ + axis2_phases_info_t *info = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_phase_orders"); + + AXIS2_PARAM_CHECK(env->error, phase_orders, AXIS2_FAILURE); + + info = axis2_dep_engine_get_phases_info(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env); + + while(axiom_children_qname_iterator_has_next(phase_orders, env)) + { + axiom_node_t *phase_orders_node = NULL; + axiom_element_t *phase_orders_element = NULL; + axiom_attribute_t *phase_orders_att = NULL; + axutil_qname_t *qtype = NULL; + axis2_char_t *flow_type = NULL; + axutil_array_list_t *phase_list = NULL; + + phase_orders_node = (axiom_node_t *)axiom_children_qname_iterator_next(phase_orders, env); + if(phase_orders_node) + { + phase_orders_element = axiom_node_get_data_element(phase_orders_node, env); + } + if(phase_orders_element) + { + qtype = axutil_qname_create(env, AXIS2_TYPE, NULL, NULL); + phase_orders_att = axiom_element_get_attribute(phase_orders_element, env, qtype); + axutil_qname_free(qtype, env); + } + + if(phase_orders_att) + { + flow_type = axiom_attribute_get_value(phase_orders_att, env); + } + + phase_list = axis2_conf_builder_get_phase_list(conf_builder, env, phase_orders_node); + if(!phase_list) + { + axis2_status_t status_code = AXIS2_FAILURE; + + status_code = AXIS2_ERROR_GET_STATUS_CODE(env->error); + if(AXIS2_SUCCESS != status_code) + { + return status_code; + } + + return AXIS2_SUCCESS; + } + + if(flow_type && !axutil_strcmp(AXIS2_IN_FLOW_START, flow_type)) + { + axis2_phases_info_set_in_phases(info, env, phase_list); + } + else if(flow_type && !axutil_strcmp(AXIS2_IN_FAILTFLOW, flow_type)) + { + axis2_phases_info_set_in_faultphases(info, env, phase_list); + } + else if(flow_type && !axutil_strcmp(AXIS2_OUT_FLOW_START, flow_type)) + { + axis2_phases_info_set_out_phases(info, env, phase_list); + } + else if(flow_type && !axutil_strcmp(AXIS2_OUT_FAILTFLOW, flow_type)) + { + axis2_phases_info_set_out_faultphases(info, env, phase_list); + } + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_phase_orders"); + + return AXIS2_SUCCESS; +} + +/* From the phase order node passed as parameter retrieve all phase element nodes. From them extract + * the phase name and add it to a array list. Return the array list. + */ +static axutil_array_list_t * +axis2_conf_builder_get_phase_list( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_node_t * phase_orders_node) +{ + axutil_array_list_t *phase_list = NULL; + axiom_children_qname_iterator_t *phases = NULL; + axutil_qname_t *qphase = NULL; + axiom_element_t *phase_orders_element; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_get_phase_list"); + + AXIS2_PARAM_CHECK(env->error, phase_orders_node, NULL); + + phase_orders_element = axiom_node_get_data_element(phase_orders_node, env); + if(!phase_orders_element) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_DATA_ELEMENT_IS_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving phase orders data element from phase orders node failed. Unable to continue"); + + return NULL; + } + + phase_list = axutil_array_list_create(env, 0); + qphase = axutil_qname_create(env, AXIS2_PHASE, NULL, NULL); + phases = axiom_element_get_children_with_qname(phase_orders_element, env, qphase, + phase_orders_node); + + axutil_qname_free(qphase, env); + if(!phases) + { + axutil_array_list_free(phase_list, env); + + /* I guess this is not an error. So adding debug message*/ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No phase node found in the phase orders node"); + + return NULL; + } + + while(axiom_children_qname_iterator_has_next(phases, env)) + { + axiom_node_t *phase_node = NULL; + axiom_element_t *phase_element = NULL; + axiom_attribute_t *phase_att = NULL; + axutil_qname_t *qattname = NULL; + axis2_char_t *att_value = NULL; + + phase_node = (axiom_node_t *)axiom_children_qname_iterator_next(phases, env); + if(phase_node) + { + phase_element = (axiom_element_t *)axiom_node_get_data_element(phase_node, env); + } + + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + if(phase_element) + { + phase_att = axiom_element_get_attribute(phase_element, env, qattname); + } + + if(phase_att) + { + att_value = axiom_attribute_get_value(phase_att, env); + } + + if(att_value) + { + axutil_array_list_add(phase_list, env, att_value); + } + + axutil_qname_free(qattname, env); + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_get_phase_list"); + + return phase_list; +} + +static axis2_status_t +axis2_conf_builder_process_transport_senders( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_senders) +{ + axis2_status_t status = AXIS2_FAILURE; + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_transport_senders"); + while(axiom_children_qname_iterator_has_next(trs_senders, env)) + { + axis2_transport_out_desc_t *transport_out = NULL; + axiom_node_t *transport_node = NULL; + axiom_element_t *transport_element = NULL; + axiom_attribute_t *trs_name = NULL; + axutil_qname_t *qattname = NULL; + + transport_node = (axiom_node_t *)axiom_children_qname_iterator_next(trs_senders, env); + + if(transport_node) + { + transport_element = (axiom_element_t *)axiom_node_get_data_element(transport_node, env); + if(!transport_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving data element failed from the transport node." + " Unable to continue"); + return AXIS2_FAILURE; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport node is empty. Unable to continue"); + return AXIS2_FAILURE; + } + + /* getting trsnport Name */ + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + if(transport_element) + { + trs_name = axiom_element_get_attribute(transport_element, env, qattname); + } + + axutil_qname_free(qattname, env); + if(trs_name) + { + axis2_char_t *name = NULL; + axiom_attribute_t *trs_dll_att = NULL; + axis2_char_t *dll_name = NULL; + axis2_char_t *class_name = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qinfaultflowst = NULL; + axutil_qname_t *qoutfaultflowst = NULL; + axutil_qname_t *qdllname = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *in_fault_flow_element = NULL; + axiom_node_t *in_fault_flow_node = NULL; + axiom_element_t *out_fault_flow_element = NULL; + axiom_node_t *out_fault_flow_node = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + void *transport_sender = NULL; + axis2_char_t *path_qualified_dll_name = NULL; + axis2_char_t *repos_name = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + /* AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP + * set to avoid C4701 on Windows + */ + axis2_bool_t axis2_flag = AXIS2_FALSE; + axutil_param_t *libparam; + axis2_char_t *libdir = NULL; + axis2_conf_t *conf; + + conf = conf_builder->conf; + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + + name = axiom_attribute_get_value(trs_name, env); + + if(name) + { + if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_SMTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_SMTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_XMPP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_XMPP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_TCP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_TCP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTPS)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTPS; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_AMQP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_AMQP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_UDP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_UDP; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport name %s doesn't match with transport enum. " + "Unable to continue", name); + return AXIS2_FAILURE; + } + + transport_out = axis2_transport_out_desc_create(env, transport_enum); + } + + if(!transport_out) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport_out value is NULL for transport %s", name); + return AXIS2_FAILURE; + } + + /* transport impl class */ + qdllname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + trs_dll_att = axiom_element_get_attribute(transport_element, env, qdllname); + axutil_qname_free(qdllname, env); + if(!trs_dll_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_TRANSPORT_SENDER_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport dll name attribute is not set in the " + "%s transport element node", name); + return AXIS2_FAILURE; + } + class_name = axiom_attribute_get_value(trs_dll_att, env); + impl_info_param = axutil_param_create(env, class_name, NULL); + if(!impl_info_param) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating module dll name parameter failed for %s. Unable " + "to continue", class_name); + axis2_transport_out_desc_free(transport_out, env); + return AXIS2_FAILURE; + } + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + if(!axis2_flag) + { + repos_name = axis2_dep_engine_get_repos_path(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env); + temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + path_qualified_dll_name = axutil_stracat(env, temp_path3, dll_name); + AXIS2_FREE(env->allocator, temp_path); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + } + else + { + libparam = axis2_conf_get_param(conf, env, AXIS2_LIB_DIR); + if(libparam) + { + libdir = axutil_param_get_value(libparam, env); + } + + if(!libdir) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Specifying" + "services and modules directories using axis2.xml but" + " path of the library directory is not present"); + return AXIS2_FAILURE; + } + path_qualified_dll_name = axutil_strcat(env, libdir, AXIS2_PATH_SEP_STR, dll_name, + NULL); + } + + axutil_dll_desc_set_name(dll_desc, env, path_qualified_dll_name); + AXIS2_FREE(env->allocator, path_qualified_dll_name); + + axutil_dll_desc_set_type(dll_desc, env, AXIS2_TRANSPORT_SENDER_DLL); + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + transport_sender = axutil_class_loader_create_dll(env, impl_info_param); + axis2_transport_out_desc_add_param(transport_out, env, impl_info_param); + + if(!transport_sender) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport sender is NULL for transport %s, unable to " + "continue", name); + axis2_transport_out_desc_free(transport_out, env); + return status; + } + + status = axis2_transport_out_desc_set_sender(transport_out, env, transport_sender); + if(!status) + { + axis2_transport_out_desc_free(transport_out, env); + return status; + } + + /* Process Parameters */ + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(transport_element, env, qparamst, + transport_node); + axutil_qname_free(qparamst, env); + + if(itr) + { + status = axis2_desc_builder_process_params(conf_builder->desc_builder, env, itr, + axis2_transport_out_desc_param_container(transport_out, env), + axis2_conf_get_param_container(conf_builder->conf, env)); + } + if(!status) + { + axis2_transport_out_desc_free(transport_out, env); + return status; + } + /* process IN_FLOW */ + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qinflowst, transport_node, &in_flow_node); + axutil_qname_free(qinflowst, env); + if(in_flow_element) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_IN_FLOW_NOT_ALLOWED_IN_TRS_OUT, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport in flow element is not allowed in the out path"); + return AXIS2_FAILURE; + } + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qoutflowst, transport_node, &out_flow_node); + axutil_qname_free(qoutflowst, env); + if(out_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + out_flow_element, axis2_conf_get_param_container(conf_builder->conf, env), + out_flow_node); + status = axis2_transport_out_desc_set_out_flow(transport_out, env, flow); + if(!status) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting the out flow failed on the trasnport out " + "description for the transport %s", name); + return status; + } + } + + /* process IN FAULT FLOW */ + qinfaultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qinfaultflowst, transport_node, &in_fault_flow_node); + axutil_qname_free(qinfaultflowst, env); + if(in_fault_flow_element) + { + axis2_transport_out_desc_free(transport_out, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_IN_FLOW_NOT_ALLOWED_IN_TRS_OUT, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "A soap fault has occured in the in flow while " + "processing transport senders. Unable to continue"); + return AXIS2_FAILURE; + } + + qoutfaultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qoutfaultflowst, transport_node, &out_fault_flow_node); + axutil_qname_free(qoutfaultflowst, env); + if(out_fault_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + out_fault_flow_element, + axis2_conf_get_param_container(conf_builder->conf, env), out_fault_flow_node); + status = axis2_transport_out_desc_set_fault_out_flow(transport_out, env, flow); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting the fault out flow into the transport out " + "failed"); + axis2_transport_out_desc_free(transport_out, env); + return status; + } + } + + /* adding to axis config */ + status = axis2_conf_add_transport_out(conf_builder->conf, env, transport_out, + transport_enum); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding transport out for %s into main configuration failed", name); + axis2_transport_out_desc_free(transport_out, env); + return status; + } + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_transport_senders"); + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_conf_builder_process_transport_recvs( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * trs_recvs) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_conf_t *conf; + axis2_bool_t axis2_flag = AXIS2_FALSE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_conf_builder_process_transport_recvs"); + AXIS2_PARAM_CHECK(env->error, trs_recvs, AXIS2_FAILURE); + + conf = conf_builder->conf; + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + + while(axiom_children_qname_iterator_has_next(trs_recvs, env)) + { + axis2_transport_in_desc_t *transport_in = NULL; + axiom_node_t *transport_node = NULL; + axiom_element_t *transport_element = NULL; + axiom_attribute_t *trs_name = NULL; + axutil_qname_t *qattname = NULL; + + transport_node = (axiom_node_t *)axiom_children_qname_iterator_next(trs_recvs, env); + if(transport_node) + { + transport_element = axiom_node_get_data_element(transport_node, env); + if(!transport_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving data element from the transport node failed."); + return AXIS2_FAILURE; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Transport node is NULL. Unable to continue"); + return AXIS2_FAILURE; + } + + /* getting transport Name */ + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + trs_name = axiom_element_get_attribute(transport_element, env, qattname); + axutil_qname_free(qattname, env); + + if(trs_name) + { + axis2_char_t *name = NULL; + axiom_attribute_t *trs_class_name = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *class_qname = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qinfaultflowst = NULL; + axutil_qname_t *qoutfaultflowst = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *in_fault_flow_element = NULL; + axiom_node_t *in_fault_flow_node = NULL; + axiom_element_t *out_fault_flow_element = NULL; + axiom_node_t *out_fault_flow_node = NULL; + AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + /* AXIS2_TRANSPORT_ENUMS transport_enum = AXIS2_TRANSPORT_ENUM_HTTP + * set to avoid C4701 on Windows + */ + + name = axiom_attribute_get_value(trs_name, env); + if(name) + { + if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_SMTP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_SMTP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_XMPP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_XMPP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_TCP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_TCP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_HTTPS)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_HTTPS; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_AMQP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_AMQP; + } + else if(!axutil_strcmp(name, AXIS2_TRANSPORT_UDP)) + { + transport_enum = AXIS2_TRANSPORT_ENUM_UDP; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport %s could not be recognized.", name); + return AXIS2_FAILURE; + } + + transport_in = axis2_transport_in_desc_create(env, transport_enum); + } + if(!transport_in) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating trasport_in_desc for transport %s failed", name); + return AXIS2_FAILURE; + } + + /* transport impl class */ + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + trs_class_name = axiom_element_get_attribute(transport_element, env, class_qname); + axutil_qname_free(class_qname, env); + + if(trs_class_name) + { + axis2_char_t *class_name = NULL; + axis2_char_t *dll_name = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axis2_transport_receiver_t *recv = NULL; + axis2_status_t stat = AXIS2_FAILURE; + axis2_char_t *path_qualified_dll_name = NULL; + axis2_char_t *repos_name = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + + axutil_param_t *tnsparam; + axis2_char_t *libpath; + + class_name = axiom_attribute_get_value(trs_class_name, env); + impl_info_param = axutil_param_create(env, class_name, NULL); + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, + class_name); + if(!axis2_flag) + { + /* Axis2 Configuration is not built using axis2.xml */ + repos_name = axis2_dep_engine_get_repos_path(axis2_desc_builder_get_dep_engine( + conf_builder->desc_builder, env), env); + temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + path_qualified_dll_name = axutil_stracat(env, temp_path3, dll_name); + AXIS2_FREE(env->allocator, temp_path); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + } + else + { + /* Axis2 Configuration is built using axis2.xml */ + tnsparam = axis2_conf_get_param(conf, env, AXIS2_LIB_DIR); + if(tnsparam) + { + libpath = (axis2_char_t *)axutil_param_get_value(tnsparam, env); + + if(libpath) + { + path_qualified_dll_name = axutil_strcat(env, libpath, + AXIS2_PATH_SEP_STR, dll_name, NULL); + } + } + } + + axutil_dll_desc_set_name(dll_desc, env, path_qualified_dll_name); + AXIS2_FREE(env->allocator, path_qualified_dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_TRANSPORT_RECV_DLL); + + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + recv = (axis2_transport_receiver_t *)axutil_class_loader_create_dll(env, + impl_info_param); + axis2_transport_in_desc_add_param(transport_in, env, impl_info_param); + + if(!recv) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Transport receiver loading failed for %s, " + "unable to continue", dll_name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + axis2_transport_receiver_set_is_application_client_side(recv, env, AXIS2_TRUE); + stat = axis2_transport_in_desc_set_recv(transport_in, env, recv); + + if(!stat) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting transport receiver for transport %s into " + "transport in description failed, unable to continue", name); + axis2_transport_in_desc_free(transport_in, env); + return stat; + } + + } + + /* process Parameters */ + /* processing Paramters */ + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(transport_element, env, qparamst, + transport_node); + axutil_qname_free(qparamst, env); + status = axis2_desc_builder_process_params(conf_builder->desc_builder, env, itr, + axis2_transport_in_desc_param_container(transport_in, env), + axis2_conf_get_param_container(conf_builder->conf, env)); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing transport receiver parameters failed. " + "Unable to continue"); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + /* process OUT_FLOW */ + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qoutflowst, transport_node, &out_flow_node); + axutil_qname_free(qoutflowst, env); + if(out_flow_element) + { + axis2_transport_in_desc_free(transport_in, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OUT_FLOW_NOT_ALLOWED_IN_TRS_IN, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Out flow element not allowed in transport in path"); + return AXIS2_FAILURE; + } + + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname(transport_element, env, + qinflowst, transport_node, &in_flow_node); + axutil_qname_free(qinflowst, env); + if(in_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + in_flow_element, axis2_conf_get_param_container(conf_builder->conf, env), + in_flow_node); + status = axis2_transport_in_desc_set_in_flow(transport_in, env, flow); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting in flow into transport_in_desc of transport " + "%s failed", name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + } + + qinfaultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qinfaultflowst, transport_node, &in_fault_flow_node); + axutil_qname_free(qinfaultflowst, env); + if(in_fault_flow_element) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(conf_builder->desc_builder, env, + in_fault_flow_element, axis2_conf_get_param_container(conf_builder->conf, env), + in_fault_flow_node); + status = axis2_transport_in_desc_set_fault_in_flow(transport_in, env, flow); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting in fault flow into transport_in_desc of " + "transport %s failed", name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + } + + qoutfaultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_fault_flow_element = axiom_element_get_first_child_with_qname(transport_element, + env, qoutfaultflowst, transport_node, &out_fault_flow_node); + if(out_fault_flow_element) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OUT_FLOW_NOT_ALLOWED_IN_TRS_IN, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Out flow element is not allowed in transport in path"); + return AXIS2_FAILURE; + } + + /* adding to axis config */ + status = axis2_conf_add_transport_in(conf_builder->conf, env, transport_in, + transport_enum); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding transport_in_desc for transport %s into main " + "configuration failed.", name); + axis2_transport_in_desc_free(transport_in, env); + return status; + } + + axutil_qname_free(qoutfaultflowst, env); + + } + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_conf_builder_process_transport_recvs"); + return AXIS2_SUCCESS; +} + +static axis2_status_t AXIS2_CALL +axis2_conf_builder_process_default_module_versions( + axis2_conf_builder_t * conf_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_versions) +{ + AXIS2_PARAM_CHECK(env->error, module_versions, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_versions, env)) + { + axiom_element_t *om_element = NULL; + axis2_char_t *name = NULL; + axis2_char_t *default_version = NULL; + axutil_qname_t *attribute_qname = NULL; + + om_element = (axiom_element_t *)axiom_children_qname_iterator_next(module_versions, env); + if(!om_element) + { + continue; + } + attribute_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + if(!attribute_qname) + { + continue; + } + name = axiom_element_get_attribute_value(om_element, env, attribute_qname); + axutil_qname_free(attribute_qname, env); + attribute_qname = NULL; + if(!name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Attribute value is NULL for " + "attribute %s", AXIS2_ATTNAME); + return AXIS2_FAILURE; + } + attribute_qname = axutil_qname_create(env, AXIS2_ATTRIBUTE_DEFAULT_VERSION, NULL, NULL); + if(!attribute_qname) + { + continue; + } + default_version = axiom_element_get_attribute_value(om_element, env, attribute_qname); + axutil_qname_free(attribute_qname, env); + attribute_qname = NULL; + if(!default_version) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Attribute value is NULL for " + "attribute %s", AXIS2_ATTRIBUTE_DEFAULT_VERSION); + return AXIS2_FAILURE; + } + axis2_conf_add_default_module_version(conf_builder->conf, env, name, default_version); + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/conf_init.c b/src/core/deployment/conf_init.c new file mode 100644 index 0000000..6a622b4 --- /dev/null +++ b/src/core/deployment/conf_init.c @@ -0,0 +1,460 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEFAULT_REPO_PATH "." + +axis2_status_t AXIS2_CALL +axis2_init_modules( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +static axis2_status_t AXIS2_CALL +axis2_load_services( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +axis2_status_t AXIS2_CALL +axis2_init_transports( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx); + +static axis2_conf_ctx_t *AXIS2_CALL +axis2_build_conf_ctx_with_dep_engine( + const axutil_env_t * env, + axis2_dep_engine_t *dep_engine, + axis2_char_t *is_server_side) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_conf_t *conf = NULL; + axutil_property_t *property = NULL; + axis2_ctx_t *conf_ctx_base = NULL; + + conf = axis2_dep_engine_load(dep_engine, env); + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Loading deployment engine failed"); + axis2_dep_engine_free(dep_engine, env); + return NULL; + } + axis2_conf_set_dep_engine(conf, env, dep_engine); + + conf_ctx = axis2_conf_ctx_create(env, conf); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating Axis2 configuration context failed."); + return NULL; + } + axis2_conf_ctx_set_root_dir(conf_ctx, env, axis2_dep_engine_get_repos_path(dep_engine, env)); + + conf_ctx_base = axis2_conf_ctx_get_base(conf_ctx, env); + property = axutil_property_create_with_args(env, 2, 0, 0, is_server_side); + axis2_ctx_set_property(conf_ctx_base, env, AXIS2_IS_SVR_SIDE, property); + + axis2_init_modules(env, conf_ctx); + axis2_init_transports(env, conf_ctx); + + if(!axutil_strcmp(is_server_side, AXIS2_VALUE_TRUE)) + { + axis2_load_services(env, conf_ctx); + } + + return conf_ctx; +} + +AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL +axis2_build_conf_ctx( + const axutil_env_t * env, + const axis2_char_t * repo_name) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_build_conf_ctx"); + dep_engine = axis2_dep_engine_create_with_repos_name(env, repo_name); + if(!dep_engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating deployment engine failed for repository %s", repo_name); + return NULL; + } + + conf_ctx = axis2_build_conf_ctx_with_dep_engine(env, dep_engine, AXIS2_VALUE_TRUE); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Loading configuration context failed for repository %s.", repo_name); + return NULL; + } + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_build_conf_ctx"); + return conf_ctx; +} + +AXIS2_EXTERN axis2_conf_ctx_t *AXIS2_CALL +axis2_build_conf_ctx_with_file( + const axutil_env_t * env, + const axis2_char_t * file) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_dep_engine_t *dep_engine = NULL; + axis2_char_t *repos_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *index = NULL; + axis2_char_t *xmlfile = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_build_conf_ctx_with_file"); + temp_path = axutil_strdup(env, file); + index = axutil_rindex(temp_path, AXIS2_PATH_SEP_CHAR); + if(!index) + {/* searching from windows specific path seperator */ + index = axutil_rindex(temp_path, '\\'); + } + + if(!index) + { + /** only the xml file name is provided. Assume the default repo path */ + repos_path = AXIS2_GETENV("AXIS2C_HOME"); + xmlfile = (axis2_char_t*)file; + }else + { + xmlfile = index+1; + temp_path[index-temp_path] = '\0'; + repos_path = temp_path; + } + + dep_engine = axis2_dep_engine_create_with_repos_name_and_svr_xml_file(env, repos_path, xmlfile); + if(!dep_engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating deployment engine for given Axis2 configuration file" + "(axis2.xml) failed"); + return NULL; + } + + conf_ctx = axis2_build_conf_ctx_with_dep_engine(env, dep_engine, AXIS2_VALUE_TRUE); + if(!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Loading configuration context failed for given Axis2 configuration %s.", file); + return NULL; + } + AXIS2_FREE(env->allocator, temp_path); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_build_conf_ctx_with_file"); + return conf_ctx; +} + +axis2_conf_ctx_t *AXIS2_CALL +axis2_build_client_conf_ctx( + const axutil_env_t * env, + const axis2_char_t * axis2_home) +{ + axis2_conf_ctx_t *conf_ctx = NULL; + axis2_dep_engine_t *dep_engine = NULL; + axis2_conf_t *conf = NULL; + axutil_property_t *property = NULL; + axis2_ctx_t *conf_ctx_base = NULL; + + axis2_status_t status; + unsigned int len = 0; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_build_client_conf_ctx"); + /* Building conf using axis2.xml, in that case we check whether + * last 9 characters of the axis2_home equals to the "axis2.xml" + * else treat it as a directory + */ + + status = axutil_file_handler_access (axis2_home, AXIS2_R_OK); + if (status == AXIS2_SUCCESS) + { + len = (int)strlen (axis2_home); + /* We are sure that the difference lies within the int range */ + if ((len >= 9) && + !strcmp ((axis2_home + (len - 9)), "axis2.xml")) + { + dep_engine = axis2_dep_engine_create_with_axis2_xml (env, + axis2_home); + } + else + { + dep_engine = axis2_dep_engine_create(env); + } + } + else + { + AXIS2_LOG_WARNING (env->log, AXIS2_LOG_SI, + "Provided client repository path %s does not exsist or no "\ + "permission to read, therefore set axis2c home to DEFAULT_REPO_PATH.", + axis2_home); + axis2_home = DEFAULT_REPO_PATH; + dep_engine = axis2_dep_engine_create(env); + } + if (!dep_engine) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating deployment engine for client repository %s failed." , + axis2_home); + return NULL; + } + conf = axis2_dep_engine_load_client(dep_engine, env, axis2_home); + if (!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Loading deployment engine failed for client repository %s", + axis2_home); + axis2_dep_engine_free(dep_engine, env); + return NULL; + } + axis2_conf_set_dep_engine(conf, env, dep_engine); + + conf_ctx = axis2_conf_ctx_create(env, conf); + if (!conf_ctx) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating Axis2 configuration context failed"); + return NULL; + } + axis2_conf_ctx_set_root_dir(conf_ctx, env, axis2_dep_engine_get_repos_path(dep_engine, env)); + + conf_ctx_base = axis2_conf_ctx_get_base(conf_ctx, env); + property = axutil_property_create_with_args(env, 2, 0, 0, AXIS2_VALUE_FALSE); + axis2_ctx_set_property(conf_ctx_base, env, AXIS2_IS_SVR_SIDE, property); + + axis2_init_modules(env, conf_ctx); + axis2_init_transports(env, conf_ctx); + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_build_client_conf_ctx"); + return conf_ctx; +} + +axis2_status_t AXIS2_CALL +axis2_init_modules( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_init_modules"); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axutil_hash_t *module_map = axis2_conf_get_all_modules(conf, env); + if(module_map) + { + axutil_hash_index_t *hi = NULL; + void *module = NULL; + for(hi = axutil_hash_first(module_map, env); hi; hi = axutil_hash_next(env, hi)) + { + axutil_hash_this(hi, NULL, NULL, &module); + if(module) + { + axis2_module_desc_t *mod_desc = (axis2_module_desc_t *)module; + if(mod_desc) + { + axis2_module_t *mod = axis2_module_desc_get_module(mod_desc, env); + if(mod) + { + axis2_module_init(mod, env, conf_ctx, mod_desc); + } + } + } + } + } + status = AXIS2_SUCCESS; + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Retrieving Axis2 configuration from Axis2 configuration context " + "failed. Initializing modules failed"); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_init_modules"); + return status; +} + +static axis2_status_t AXIS2_CALL +axis2_load_services( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *svc_map = NULL; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_load_services"); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(!conf) + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, "Retrieving Axis2 configuration from Axis2 " + "configuration context failed, Loading services failed"); + return status; + } + + svc_map = axis2_conf_get_all_svcs_to_load(conf, env); + if(svc_map) + { + axutil_hash_index_t *hi = NULL; + void *svc = NULL; + for(hi = axutil_hash_first(svc_map, env); hi; hi = axutil_hash_next(env, hi)) + { + void *impl_class = NULL; + axutil_hash_t *ops_hash = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axutil_hash_this(hi, NULL, NULL, &svc); + if(!svc) + { + continue; + } + impl_class = axis2_svc_get_impl_class(svc, env); + if(impl_class) + continue; + + ops_hash = axis2_svc_get_all_ops(svc, env); + if(ops_hash) + { + axutil_hash_index_t *op_hi = NULL; + void *op = NULL; + op_hi = axutil_hash_first(ops_hash, env); + if(op_hi) + { + axutil_hash_this(op_hi, NULL, NULL, &op); + if(op) + { + msg_recv = axis2_op_get_msg_recv(op, env); + if(msg_recv) + { + axis2_msg_recv_set_conf_ctx(msg_recv, env, conf_ctx); + axis2_msg_recv_load_and_init_svc(msg_recv, env, svc); + } + } + } + + } + /* + svc_desc = (axis2_svc_t *)svc; + if(!svc_desc) + { + continue; + } + + svc_name = axis2_svc_get_name(svc_desc, env); + impl_info_param = axis2_svc_get_param(svc_desc, env, AXIS2_SERVICE_CLASS); + + if(!impl_info_param) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid state of the service %s", svc_name); + return AXIS2_FAILURE; + } + axutil_class_loader_init(env); + impl_class = axutil_class_loader_create_dll(env, impl_info_param); + if(!impl_class) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service %s could not be loaded", svc_name); + return AXIS2_FAILURE; + } + + axis2_svc_set_impl_class(svc_desc, env, impl_class); + if(AXIS2_SVC_SKELETON_INIT_WITH_CONF((axis2_svc_skeleton_t *)impl_class, env, conf) + != AXIS2_SUCCESS) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Initialization failed for the service %s. " + "Check the service's init_with_conf() function for errors and retry", svc_name); + } + */ + + } + } + status = AXIS2_SUCCESS; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_load_services"); + return status; +} + +axis2_status_t AXIS2_CALL +axis2_init_transports( + const axutil_env_t * env, + axis2_conf_ctx_t * conf_ctx) +{ + axis2_conf_t *conf = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_init_transports"); + AXIS2_PARAM_CHECK(env->error, conf_ctx, AXIS2_FAILURE); + + conf = axis2_conf_ctx_get_conf(conf_ctx, env); + if(conf) + { + axis2_transport_in_desc_t **transport_in_map = NULL; + axis2_transport_out_desc_t **transport_out_map = NULL; + int i = 0; + + transport_in_map = axis2_conf_get_all_in_transports(conf, env); + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(transport_in_map[i]) + { + axis2_transport_receiver_t *listener = axis2_transport_in_desc_get_recv( + transport_in_map[i], env); + if(listener) + { + status = axis2_transport_receiver_init(listener, env, conf_ctx, + transport_in_map[i]); + } + } + } + + transport_out_map = axis2_conf_get_all_out_transports(conf, env); + for(i = 0; i < AXIS2_TRANSPORT_ENUM_MAX; i++) + { + if(transport_out_map[i]) + { + axis2_transport_sender_t *sender = axis2_transport_out_desc_get_sender( + transport_out_map[i], env); + if(sender) + { + status = AXIS2_TRANSPORT_SENDER_INIT(sender, env, conf_ctx, + transport_out_map[i]); + } + } + } + status = AXIS2_SUCCESS; + } + else + { + AXIS2_LOG_WARNING(env->log, AXIS2_LOG_SI, + "Retrieving Axis2 configuration from Axis2 configuration context " + "failed. Initializing transports failed"); + } + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_init_transports"); + return status; +} + diff --git a/src/core/deployment/dep_engine.c b/src/core/deployment/dep_engine.c new file mode 100644 index 0000000..2c43380 --- /dev/null +++ b/src/core/deployment/dep_engine.c @@ -0,0 +1,1988 @@ +/* + * 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. + */ + +#include "axis2_dep_engine.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct axis2_dep_engine +{ + axis2_arch_file_data_t *curr_file; + axis2_arch_reader_t *arch_reader; + + /** + * To keep a reference to engine configuration. + * This reference will pass to engine when it call start() + * function + */ + axis2_conf_t *conf; + axis2_char_t *axis2_repos; + axis2_bool_t hot_dep; /* to do hot deployment or not */ + axis2_bool_t hot_update; /* to do hot update or not */ + + /* Whether dep_engine built using axis2.xml */ + axis2_bool_t file_flag; + + /** + * This will store all the web services to deploy + */ + axutil_array_list_t *ws_to_deploy; + + /** + * This will store all the web services to undeploy + */ + axutil_array_list_t *ws_to_undeploy; + axis2_phases_info_t *phases_info; /* To store phases list in axis2.xml */ + + axis2_char_t *folder_name; + + /** + * Module directory, dep_engine holds in the module build scenario. + */ + axis2_char_t *module_dir; + + /** + * Services directory, services are avialble in services directory + */ + + axis2_char_t *svc_dir; + + /** + * Full path to the server xml file(axis2.xml) + */ + axis2_char_t *conf_name; + + /** + * To store the module specified in the server.xml(axis2.xml) at the + * document parsing time + */ + axutil_array_list_t *module_list; + axis2_repos_listener_t *repos_listener; /*Added this here to help with freeing + memory allocated for this - Samisa */ + axis2_conf_builder_t *conf_builder; + axis2_svc_builder_t *svc_builder; + axutil_array_list_t *desc_builders; + axutil_array_list_t *module_builders; + axutil_array_list_t *svc_builders; + axutil_array_list_t *svc_grp_builders; +}; + +static axis2_status_t +axis2_dep_engine_set_dep_features( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + +static axis2_status_t +axis2_dep_engine_check_client_home( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home); + +static axis2_status_t +axis2_dep_engine_engage_modules( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + +static axis2_status_t +axis2_dep_engine_validate_system_predefined_phases( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env); + +static axis2_status_t +axis2_dep_engine_add_new_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_grp_t * svc_metadata); + +static axis2_status_t +axis2_dep_engine_load_module_dll( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_desc); + +static axis2_status_t +axis2_dep_engine_add_module_flow_handlers( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_flow_t * flow, + axutil_hash_t * handler_create_func_map); + +static axis2_status_t +axis2_dep_engine_add_new_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_metadata); + +static axis2_char_t * +axis2_dep_engine_get_axis_svc_name( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * file_name); + +static axis2_status_t +axis2_dep_engine_set_svc_and_module_dir_path( + axis2_dep_engine_t *dep_engine, + const axutil_env_t *env); + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create( + const axutil_env_t * env) +{ + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + dep_engine = (axis2_dep_engine_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_dep_engine_t)); + + if(!dep_engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + dep_engine = (axis2_dep_engine_t *)memset(dep_engine, 0, sizeof(axis2_dep_engine_t)); + dep_engine->curr_file = NULL; + dep_engine->arch_reader = NULL; + dep_engine->conf = NULL; + dep_engine->axis2_repos = NULL; + dep_engine->ws_to_deploy = NULL; + dep_engine->ws_to_undeploy = NULL; + dep_engine->phases_info = NULL; + dep_engine->folder_name = NULL; + dep_engine->module_dir = NULL; + dep_engine->svc_dir = NULL; + dep_engine->conf_name = NULL; + dep_engine->module_list = NULL; + dep_engine->repos_listener = NULL; + dep_engine->conf_builder = NULL; + dep_engine->svc_builder = NULL; + dep_engine->desc_builders = NULL; + dep_engine->module_builders = NULL; + dep_engine->svc_builders = NULL; + dep_engine->svc_grp_builders = NULL; + + dep_engine->ws_to_deploy = axutil_array_list_create(env, 0); + if(!(dep_engine->ws_to_deploy)) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + dep_engine->desc_builders = axutil_array_list_create(env, 0); + dep_engine->module_builders = axutil_array_list_create(env, 0); + dep_engine->svc_builders = axutil_array_list_create(env, 0); + dep_engine->svc_grp_builders = axutil_array_list_create(env, 0); + + dep_engine->phases_info = axis2_phases_info_create(env); + if(!(dep_engine->phases_info)) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_repos_name( + const axutil_env_t * env, + const axis2_char_t * repos_path) +{ + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create_with_repos_name_and_svr_xml_file( + env, repos_path, AXIS2_SERVER_XML_FILE); + + if(!dep_engine) + { + return NULL; + } + + dep_engine->file_flag = AXIS2_FALSE; + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_axis2_xml( + const axutil_env_t * env, + const axis2_char_t * axis2_xml) +{ + axis2_dep_engine_t *dep_engine = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create_with_svr_xml_file(env, axis2_xml); + if(!dep_engine) + { + return NULL; + } + dep_engine->file_flag = AXIS2_TRUE; + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_repos_name_and_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * repos_path, + const axis2_char_t * svr_xml_file) +{ + axis2_dep_engine_t *dep_engine = NULL; + axis2_char_t *conf_file_l = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, repos_path, NULL); + AXIS2_PARAM_CHECK(env->error, svr_xml_file, NULL); + if(!axutil_strcmp("", repos_path)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository path cannot be empty"); + return NULL; + } + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create(env); + + if(!dep_engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + status = axutil_file_handler_access(repos_path, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOSITORY_NOT_EXIST, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository path %s does not exist", repos_path); + return NULL; + } + + dep_engine->folder_name = axutil_strdup(env, repos_path); + if(!dep_engine->folder_name) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + dep_engine->axis2_repos = axutil_strdup(env, repos_path); + if(!dep_engine->axis2_repos) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + conf_file_l = axutil_stracat(env, repos_path, AXIS2_PATH_SEP_STR); + dep_engine->conf_name = axutil_stracat(env, conf_file_l, svr_xml_file); + + AXIS2_FREE(env->allocator, conf_file_l); + if(!dep_engine->conf_name) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name cannot be NULL"); + return NULL; + } + + status = axutil_file_handler_access(dep_engine->conf_name, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name not found"); + return NULL; + } + + return dep_engine; +} + +AXIS2_EXTERN axis2_dep_engine_t *AXIS2_CALL +axis2_dep_engine_create_with_svr_xml_file( + const axutil_env_t * env, + const axis2_char_t * svr_xml_file) +{ + axis2_dep_engine_t *dep_engine = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_ENV_CHECK(env, NULL); + AXIS2_PARAM_CHECK(env->error, svr_xml_file, NULL); + + dep_engine = (axis2_dep_engine_t *)axis2_dep_engine_create(env); + + if(!dep_engine) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + dep_engine->conf_name = axutil_strdup(env, (axis2_char_t *)svr_xml_file); + if(!dep_engine->conf_name) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name cannot be NULL"); + return NULL; + } + status = axutil_file_handler_access(dep_engine->conf_name, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + axis2_dep_engine_free(dep_engine, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name not found"); + return NULL; + } + + return dep_engine; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_dep_engine_free( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_ENV_CHECK(env, void); + if(!dep_engine) + { + return; + } + + if(dep_engine->curr_file) + { + axis2_arch_file_data_free(dep_engine->curr_file, env); + } + + if(dep_engine->phases_info) + { + axis2_phases_info_free(dep_engine->phases_info, env); + } + + if(dep_engine->conf_builder) + { + axis2_conf_builder_free(dep_engine->conf_builder, env); + } + + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + } + + if(dep_engine->svc_builder) + { + axis2_svc_builder_free(dep_engine->svc_builder, env); + } + + if(dep_engine->ws_to_deploy) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->ws_to_deploy, env); + for(i = 0; i < size; i++) + { + axis2_arch_file_data_t *file_data = NULL; + + file_data = (axis2_arch_file_data_t *)axutil_array_list_get(dep_engine->ws_to_deploy, + env, i); + + axis2_arch_file_data_free(file_data, env); + } + + axutil_array_list_free(dep_engine->ws_to_deploy, env); + dep_engine->ws_to_deploy = NULL; + } + + if(dep_engine->desc_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->desc_builders, env); + for(i = 0; i < size; i++) + { + axis2_desc_builder_t *desc_builder = NULL; + + desc_builder = (axis2_desc_builder_t *)axutil_array_list_get(dep_engine->desc_builders, + env, i); + + axis2_desc_builder_free(desc_builder, env); + } + + axutil_array_list_free(dep_engine->desc_builders, env); + } + + if(dep_engine->module_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->module_builders, env); + for(i = 0; i < size; i++) + { + axis2_module_builder_t *module_builder = NULL; + + module_builder = (axis2_module_builder_t *)axutil_array_list_get( + dep_engine->module_builders, env, i); + + axis2_module_builder_free(module_builder, env); + } + + axutil_array_list_free(dep_engine->module_builders, env); + } + + if(dep_engine->svc_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->svc_builders, env); + for(i = 0; i < size; i++) + { + axis2_svc_builder_t *svc_builder = NULL; + + svc_builder = (axis2_svc_builder_t *)axutil_array_list_get(dep_engine->svc_builders, + env, i); + + axis2_svc_builder_free(svc_builder, env); + } + + axutil_array_list_free(dep_engine->svc_builders, env); + } + + if(dep_engine->svc_grp_builders) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->svc_grp_builders, env); + for(i = 0; i < size; i++) + { + axis2_svc_grp_builder_t *svc_grp_builder = NULL; + + svc_grp_builder = (axis2_svc_grp_builder_t *)axutil_array_list_get( + dep_engine->svc_grp_builders, env, i); + + axis2_svc_grp_builder_free(svc_grp_builder, env); + } + + axutil_array_list_free(dep_engine->svc_grp_builders, env); + } + + if(dep_engine->ws_to_undeploy) + { + int i = 0; + int size = 0; + + size = axutil_array_list_size(dep_engine->ws_to_undeploy, env); + + for(i = 0; i < size; i++) + { + axis2_arch_file_data_t *file_data = NULL; + + file_data = (axis2_arch_file_data_t *)axutil_array_list_get(dep_engine->ws_to_undeploy, + env, i); + + axis2_arch_file_data_free(file_data, env); + } + + axutil_array_list_free(dep_engine->ws_to_undeploy, env); + dep_engine->ws_to_undeploy = NULL; + } + + if(dep_engine->module_list) + { + int size = 0; + int i = 0; + + size = axutil_array_list_size(dep_engine->module_list, env); + + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + qname = axutil_array_list_get(dep_engine->module_list, env, i); + if(qname) + { + axutil_qname_free(qname, env); + } + } + + axutil_array_list_free(dep_engine->module_list, env); + } + + if(dep_engine->folder_name) + { + AXIS2_FREE(env->allocator, dep_engine->folder_name); + } + + if(dep_engine->conf_name) + { + AXIS2_FREE(env->allocator, dep_engine->conf_name); + } + + if(dep_engine->axis2_repos) + { + AXIS2_FREE(env->allocator, dep_engine->axis2_repos); + } + + if(dep_engine->repos_listener) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + } + + if(dep_engine) + { + AXIS2_FREE(env->allocator, dep_engine); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_qname) +{ + axutil_qname_t *qname = NULL; + + AXIS2_PARAM_CHECK(env->error, module_qname, AXIS2_FAILURE); + + qname = axutil_qname_clone(module_qname, env); + if(!dep_engine->module_list) + { + dep_engine->module_list = axutil_array_list_create(env, 0); + if(!dep_engine->module_list) + { + axutil_qname_free(qname, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + } + return axutil_array_list_add(dep_engine->module_list, env, qname); +} + +struct axis2_module_desc *AXIS2_CALL +axis2_dep_engine_get_module( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_qname_t * module_qname) +{ + AXIS2_PARAM_CHECK(env->error, module_qname, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + return axis2_conf_get_module(dep_engine->conf, env, module_qname); +} + +AXIS2_EXTERN struct axis2_arch_file_data *AXIS2_CALL +axis2_dep_engine_get_current_file_item( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->curr_file; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_ws_to_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_arch_file_data_t * file) +{ + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->ws_to_deploy, env, file); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_ws_to_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_ws_info_t * file) +{ + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + if(!(dep_engine->ws_to_undeploy)) + { + dep_engine->ws_to_undeploy = axutil_array_list_create(env, 0); + } + return axutil_array_list_add(dep_engine->ws_to_undeploy, env, file); +} + +AXIS2_EXTERN axis2_phases_info_t *AXIS2_CALL +axis2_dep_engine_get_phases_info( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->phases_info; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_dep_engine_get_axis_conf( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->conf; +} + +/** + * To set hot deployment and hot update + */ +static axis2_status_t +axis2_dep_engine_set_dep_features( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + axis2_char_t *value = NULL; + axutil_param_t *para_hot_dep = NULL; + axutil_param_t *para_hot_update = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + para_hot_dep = axis2_conf_get_param(dep_engine->conf, env, AXIS2_HOTDEPLOYMENT); + para_hot_update = axis2_conf_get_param(dep_engine->conf, env, AXIS2_HOTUPDATE); + + if(para_hot_dep) + { + value = (axis2_char_t *)axutil_param_get_value(para_hot_dep, env); + if(0 == axutil_strcasecmp(AXIS2_VALUE_FALSE, value)) + { + dep_engine->hot_dep = AXIS2_FALSE; + } + } + + if(para_hot_update) + { + value = (axis2_char_t *)axutil_param_get_value(para_hot_update, env); + if(0 == axutil_strcasecmp(AXIS2_VALUE_FALSE, value)) + { + dep_engine->hot_update = AXIS2_FALSE; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_dep_engine_load( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_array_list_t *out_fault_phases = NULL; + + if(!dep_engine->conf_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Path to axis2 configuration file is NULL. Unable to continue"); + return NULL; + } + + dep_engine->conf = axis2_conf_create(env); + if(!dep_engine->conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Allocation to configuration failed"); + return NULL; + } + + /* Set a flag to mark that conf is created using axis2 xml. To find out that conf is build using + * axis2 xml , this flag can be used. + */ + axis2_conf_set_axis2_flag(dep_engine->conf, env, dep_engine->file_flag); + axis2_conf_set_axis2_xml(dep_engine->conf, env, dep_engine->conf_name); + + dep_engine->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env, + dep_engine->conf_name, dep_engine, dep_engine->conf); + if(!(dep_engine->conf_builder)) + { + axis2_conf_free(dep_engine->conf, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Configuration builder creation failed"); + dep_engine->conf = NULL; + } + + /* Populate the axis2 configuration from reading axis2.xml. + */ + status = axis2_conf_builder_populate_conf(dep_engine->conf_builder, env); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Populating Axis2 Configuration failed"); + return NULL; + } + + status = axis2_dep_engine_set_svc_and_module_dir_path(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service and module directory paths failed"); + return NULL; + } + + status = axis2_dep_engine_set_dep_features(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting deployment features failed"); + return NULL; + } + + if(dep_engine->repos_listener) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + } + + dep_engine->repos_listener = axis2_repos_listener_create_with_folder_name_and_dep_engine(env, + dep_engine->folder_name, dep_engine); + if(!dep_engine->repos_listener) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "dep_engine repos listener creation failed, folder name is %s", dep_engine->folder_name); + return NULL; + } + + axis2_conf_set_repo(dep_engine->conf, env, dep_engine->axis2_repos); + axis2_core_utils_calculate_default_module_version(env, axis2_conf_get_all_modules( + dep_engine->conf, env), dep_engine->conf); + + status = axis2_dep_engine_validate_system_predefined_phases(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Validating system predefined phases failed"); + return NULL; + } + + status = axis2_conf_set_phases_info(dep_engine->conf, env, dep_engine->phases_info); + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting phases info into Axis2 Configuration failed"); + return NULL; + } + + out_fault_phases = axis2_phases_info_get_op_out_faultphases(dep_engine->phases_info, env); + if(out_fault_phases) + { + status = axis2_conf_set_out_fault_phases(dep_engine->conf, env, out_fault_phases); + } + + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting out fault phases into Axis2 Configuratin failed"); + return NULL; + } + + status = axis2_dep_engine_engage_modules(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "dep engine failed to engaged_modules"); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, AXIS2_FAILURE); + return NULL; + } + + return dep_engine->conf; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_dep_engine_load_client( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home) +{ + axis2_bool_t is_repos_exist = AXIS2_FALSE; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t flag = AXIS2_FALSE; + + AXIS2_PARAM_CHECK(env->error, client_home, NULL); + + flag = axis2_dep_engine_get_file_flag(dep_engine, env); + + if(!flag) + { + dep_engine->axis2_repos = axutil_strdup(env, client_home); + if(!dep_engine->axis2_repos) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return NULL; + } + + if(client_home && axutil_strcmp("", client_home)) + { + status = axis2_dep_engine_check_client_home(dep_engine, env, client_home); + if(AXIS2_SUCCESS == status) + { + is_repos_exist = AXIS2_TRUE; + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "axis2.xml is not available in client repo %s ", client_home); + + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + + return NULL; + } + } + else + { + dep_engine->conf_name = axutil_strdup(env, AXIS2_CONFIGURATION_RESOURCE); + + if(!dep_engine->conf_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Axis2 Configuration file name cannot be NULL"); + return NULL; + } + } + } + + else + { + is_repos_exist = AXIS2_TRUE; + } + + dep_engine->conf = axis2_conf_create(env); + if(!dep_engine->conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Allocation for Axis2 Configuration failed"); + return NULL; + } + dep_engine->conf_builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env, + dep_engine->conf_name, dep_engine, dep_engine->conf); + + if(!(dep_engine->conf_builder)) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + } + + /** + Very important: Only after populating we will be able to access + parameters in axis2 xml. + */ + + axis2_conf_set_axis2_flag(dep_engine->conf, env, dep_engine->file_flag); + axis2_conf_set_axis2_xml(dep_engine->conf, env, dep_engine->conf_name); + + status = axis2_conf_builder_populate_conf(dep_engine->conf_builder, env); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Populating Axis2 Configuration failed"); + return NULL; + } + + status = axis2_dep_engine_set_svc_and_module_dir_path(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting service and module paths failed"); + return NULL; + } + + if(is_repos_exist) + { + dep_engine->hot_dep = AXIS2_FALSE; + dep_engine->hot_update = AXIS2_FALSE; + if(dep_engine->repos_listener) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + } + + dep_engine->repos_listener = axis2_repos_listener_create_with_folder_name_and_dep_engine( + env, dep_engine->folder_name, dep_engine); + } + + axis2_conf_set_repo(dep_engine->conf, env, dep_engine->axis2_repos); + axis2_core_utils_calculate_default_module_version(env, axis2_conf_get_all_modules( + dep_engine->conf, env), dep_engine->conf); + + axis2_conf_set_phases_info(dep_engine->conf, env, dep_engine->phases_info); + status = axis2_dep_engine_engage_modules(dep_engine, env); + if(AXIS2_SUCCESS != status) + { + axis2_repos_listener_free(dep_engine->repos_listener, env); + axis2_conf_free(dep_engine->conf, env); + dep_engine->conf = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Module engage failed for deployment engine"); + return NULL; + } + + return dep_engine->conf; +} + +static axis2_status_t +axis2_dep_engine_check_client_home( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t * client_home) +{ + axis2_char_t *path_l = NULL; + axis2_status_t status = AXIS2_FAILURE; + + dep_engine->folder_name = axutil_strdup(env, client_home); + if(!dep_engine->folder_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + path_l = axutil_stracat(env, client_home, AXIS2_PATH_SEP_STR); + dep_engine->conf_name = axutil_stracat(env, path_l, AXIS2_SERVER_XML_FILE); + AXIS2_FREE(env->allocator, path_l); + + if(!dep_engine->conf_name) + { + dep_engine->conf_name = axutil_strdup(env, AXIS2_CONFIGURATION_RESOURCE); + if(!dep_engine->conf_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name cannot be NULL"); + return AXIS2_FAILURE; + } + } + + status = axutil_file_handler_access(dep_engine->conf_name, AXIS2_F_OK); + if(AXIS2_SUCCESS != status) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration file name not found"); + return AXIS2_FAILURE; + } + + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_dep_engine_engage_modules( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + int size = 0; + int i = 0; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + if(!dep_engine->module_list) + { + /* There are no modules */ + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No modules configured"); + return AXIS2_SUCCESS; + } + + size = axutil_array_list_size(dep_engine->module_list, env); + + for(i = 0; i < size; i++) + { + axutil_qname_t *qname = NULL; + qname = (axutil_qname_t *)axutil_array_list_get(dep_engine->module_list, env, i); + if(qname && dep_engine->conf) + { + status = axis2_conf_engage_module(dep_engine->conf, env, qname); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Engaging module %s to Axis2 Configuration failed", axutil_qname_get_localpart( + qname, env)); + + return status; + } + } + } + + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_dep_engine_validate_system_predefined_phases( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + axutil_array_list_t *in_phases = NULL; + axis2_char_t *phase0 = NULL; + axis2_char_t *phase1 = NULL; + axis2_char_t *phase2 = NULL; + axis2_char_t *phase3 = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + in_phases = axis2_phases_info_get_in_phases(dep_engine->phases_info, env); + if(in_phases) + { + phase0 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 0); + phase1 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 1); + phase2 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 2); + phase3 = (axis2_char_t *)axutil_array_list_get(in_phases, env, 3); + } + + if((phase0 && 0 != axutil_strcmp(phase0, AXIS2_PHASE_TRANSPORT_IN)) || (phase1 && 0 + != axutil_strcmp(phase1, AXIS2_PHASE_PRE_DISPATCH)) || (phase2 && 0 != axutil_strcmp( + phase2, AXIS2_PHASE_DISPATCH)) || (phase3 && 0 != axutil_strcmp(phase3, + AXIS2_PHASE_POST_DISPATCH))) + { + AXIS2_ERROR_SET(env->error, AXI2_ERROR_INVALID_PHASE, AXIS2_FAILURE); + return AXIS2_SUCCESS; + } + + return AXIS2_SUCCESS; +} + +/* For each searvices belonging to the service group passed as parameter, + * 1) Modules defined to be engaged to passed service group are engaged. + * 2) Modules defined to be engaged to service are engaged. + * + * Then for each service operation modules defined to be engaged to that operation are engaged. + */ +static axis2_status_t +axis2_dep_engine_add_new_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_grp_t * svc_metadata) +{ + axutil_array_list_t *svcs = NULL; + int sizei = 0; + int i = 0; + + AXIS2_PARAM_CHECK(env->error, svc_metadata, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + svcs = axis2_arch_file_data_get_deployable_svcs(dep_engine->curr_file, env); + if(svcs) + { + sizei = axutil_array_list_size(svcs, env); + } + + for(i = 0; i < sizei; i++) + { + axis2_svc_t *svc = NULL; + axutil_file_t *file = NULL; + axutil_array_list_t *grp_modules = NULL; + axutil_array_list_t *list = NULL; + int sizej = 0; + int j = 0; + axutil_hash_t *ops = NULL; + axutil_hash_index_t *index_i = NULL; + axis2_char_t *file_name = NULL; + + svc = (axis2_svc_t *)axutil_array_list_get(svcs, env, i); + + file = axis2_arch_file_data_get_file(dep_engine->curr_file, env); + file_name = axutil_file_get_name(file, env); + axis2_svc_set_file_name(svc, env, file_name); + + /* Modules from service group */ + grp_modules = axis2_svc_grp_get_all_module_qnames(svc_metadata, env); + if(grp_modules) + { + sizej = axutil_array_list_size(grp_modules, env); + } + for(j = 0; j < sizej; j++) + { + axis2_module_desc_t *module_desc = NULL; + axutil_qname_t *qmodulename = NULL; + + qmodulename = (axutil_qname_t *)axutil_array_list_get(grp_modules, env, j); + module_desc = axis2_conf_get_module(dep_engine->conf, env, qmodulename); + if(module_desc) + { + axis2_svc_engage_module(svc, env, module_desc, dep_engine->conf); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid module reference taken from conf"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + /* Modules from service */ + list = axis2_svc_get_all_module_qnames(svc, env); + sizej = axutil_array_list_size(list, env); + for(j = 0; j < sizej; j++) + { + axis2_module_desc_t *module_desc = NULL; + axutil_qname_t *qmodulename = NULL; + + qmodulename = (axutil_qname_t *)axutil_array_list_get(list, env, j); + module_desc = axis2_conf_get_module(dep_engine->conf, env, qmodulename); + if(module_desc) + { + axis2_status_t status = AXIS2_FAILURE; + status = axis2_svc_engage_module(svc, env, module_desc, dep_engine->conf); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Engaging module %s to service %s failed", axutil_qname_get_localpart( + qmodulename, env), file_name); + return status; + } + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid module reference taken from conf"); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF, AXIS2_FAILURE); + return AXIS2_FAILURE; + } + } + + ops = axis2_svc_get_all_ops(svc, env); + for(index_i = axutil_hash_first(ops, env); index_i; index_i + = axutil_hash_next(env, index_i)) + { + void *v = NULL; + axis2_op_t *op_desc = NULL; + axutil_array_list_t *modules = NULL; + int sizek = 0; + int k = 0; + + axutil_hash_this(index_i, NULL, NULL, &v); + op_desc = (axis2_op_t *)v; + + modules = axis2_op_get_all_module_qnames(op_desc, env); + if(modules) + { + sizek = axutil_array_list_size(modules, env); + } + for(k = 0; k < sizek; k++) + { + axutil_qname_t *module_qname = NULL; + axis2_module_desc_t *module = NULL; + + module_qname = (axutil_qname_t *)axutil_array_list_get(modules, env, k); + module = axis2_conf_get_module(dep_engine->conf, env, module_qname); + + if(module) + { + axis2_op_engage_module(op_desc, env, module, dep_engine->conf); + } + else + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODUELE_REF_BY_OP, + AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s is not added to the Axis2 Configuration", + axutil_qname_get_localpart(module_qname, env)); + + return AXIS2_FAILURE; + } + } + } + + axis2_svc_grp_add_svc(svc_metadata, env, svc); + } + + return axis2_conf_add_svc_grp(dep_engine->conf, env, svc_metadata); +} + +/* Here we will load the actual module implementation dll using the class loader and store it in + * module description. + */ +static axis2_status_t +axis2_dep_engine_load_module_dll( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_desc) +{ + axis2_char_t *read_in_dll = NULL; + axis2_module_t *module = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_file_t *module_folder = NULL; + AXIS2_TIME_T timestamp = 0; + axis2_char_t *module_folder_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *dll_path = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *dll_name = NULL; + + AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + read_in_dll = axis2_arch_file_data_get_module_dll_name(dep_engine->curr_file, env); + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, read_in_dll); + + module_folder = axis2_arch_file_data_get_file(dep_engine->curr_file, env); + timestamp = axutil_file_get_timestamp(module_folder, env); + axutil_dll_desc_set_timestamp(dll_desc, env, timestamp); + module_folder_path = axutil_file_get_path(module_folder, env); + temp_path = axutil_stracat(env, module_folder_path, AXIS2_PATH_SEP_STR); + dll_path = axutil_stracat(env, temp_path, dll_name); + + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "axis2_dep_engine_load_module_dll: DLL path is : %s", + dll_path); + status = axutil_dll_desc_set_name(dll_desc, env, dll_path); + if(AXIS2_SUCCESS != status) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting dll path %s to the dll description failed", dll_path); + + return AXIS2_FAILURE; + } + + /* Free all temp vars */ + AXIS2_FREE(env->allocator, temp_path); + temp_path = NULL; + AXIS2_FREE(env->allocator, dll_path); + dll_path = NULL; + + axutil_dll_desc_set_type(dll_desc, env, AXIS2_MODULE_DLL); + impl_info_param = axutil_param_create(env, read_in_dll, NULL); + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + axutil_class_loader_init(env); + module = (axis2_module_t *)axutil_class_loader_create_dll(env, impl_info_param); + + /* We cannot free the created impl_info_param here because by freeing + * so, it will free dll_desc which in turn unload the module. So we + * add this as a param to module_desc + */ + axis2_module_desc_add_param(module_desc, env, impl_info_param); + + return axis2_module_desc_set_module(module_desc, env, module); +} + +/* For each handler description of the module flow take the corresponding handler create function + * from handler_create_func_map and create the handler instance for the handler description. + */ +static axis2_status_t +axis2_dep_engine_add_module_flow_handlers( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_flow_t * flow, + axutil_hash_t * handler_create_func_map) +{ + int count = 0; + int j = 0; + + AXIS2_PARAM_CHECK(env->error, flow, AXIS2_FAILURE); + + count = axis2_flow_get_handler_count(flow, env); + + for(j = 0; j < count; j++) + { + axis2_handler_desc_t *handlermd = NULL; + axis2_handler_t *handler = NULL; + const axutil_string_t *handler_name = NULL; + AXIS2_HANDLER_CREATE_FUNC handler_create_func = NULL; + + handlermd = axis2_flow_get_handler(flow, env, j); + handler_name = axis2_handler_desc_get_name(handlermd, env); + handler_create_func = axutil_hash_get(handler_create_func_map, axutil_string_get_buffer( + handler_name, env), AXIS2_HASH_KEY_STRING); + + handler = handler_create_func(env, handler_name); + axis2_handler_init(handler, env, handlermd); + axis2_handler_desc_set_handler(handlermd, env, handler); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN void *AXIS2_CALL +axis2_dep_engine_get_handler_dll( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * class_name) +{ + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axis2_handler_t *handler = NULL; + axis2_char_t *dll_name = NULL; + + AXIS2_PARAM_CHECK(env->error, class_name, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + dll_desc = axutil_dll_desc_create(env); + dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + axutil_dll_desc_set_name(dll_desc, env, dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_HANDLER_DLL); + axutil_class_loader_init(env); + impl_info_param = axutil_param_create(env, NULL, NULL); + axutil_param_set_value(impl_info_param, env, dll_desc); + handler = (axis2_handler_t *)axutil_class_loader_create_dll(env, impl_info_param); + + return handler; +} + +/* Caller has module description filled with the information in module.xml by the time this + * function is called. Now it will load the actual module implementation and fill the module + * flows with the actual handler instances. Finally module description will be added into the + * configuration module list. + */ +static axis2_status_t +axis2_dep_engine_add_new_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_desc_t * module_metadata) +{ + axis2_flow_t *in_flow = NULL; + axis2_flow_t *out_flow = NULL; + axis2_flow_t *in_fault_flow = NULL; + axis2_flow_t *out_fault_flow = NULL; + axis2_module_t *module = NULL; + axis2_status_t status = AXIS2_FAILURE; + const axutil_qname_t *module_qname = NULL; + axis2_char_t *module_name = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + module_qname = axis2_module_desc_get_qname(module_metadata, env); + module_name = axutil_qname_get_localpart(module_qname, env); + status = axis2_dep_engine_load_module_dll(dep_engine, env, module_metadata); + + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Loading module description %s failed", module_name); + + return status; + } + + module = axis2_module_desc_get_module(module_metadata, env); + if(!module) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Retrieving module from module description %s failed", module_name); + + return AXIS2_FAILURE; + } + + /* Module implementor will provide functions for creating his handlers and by calling this + * function these function pointers will be stored in a hash map in the module. + */ + status = axis2_module_fill_handler_create_func_map(module, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Filling handler create function for module map %s failed", module_name); + return status; + } + + in_flow = axis2_module_desc_get_in_flow(module_metadata, env); + if(in_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_flow, + module->handler_create_func_map); + } + + out_flow = axis2_module_desc_get_out_flow(module_metadata, env); + if(out_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_flow, + module->handler_create_func_map); + } + + in_fault_flow = axis2_module_desc_get_fault_in_flow(module_metadata, env); + if(in_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_fault_flow, + module->handler_create_func_map); + } + + out_fault_flow = axis2_module_desc_get_fault_out_flow(module_metadata, env); + if(out_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_fault_flow, + module->handler_create_func_map); + } + + /* Add the module description into the axis2 configuration. Axis2 configuration will keep these + * handlers in a hash_map called all_modules. + */ + axis2_conf_add_module(dep_engine->conf, env, module_metadata); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_do_deploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + int size = 0; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + size = axutil_array_list_size(dep_engine->ws_to_deploy, env); + + if(size > 0) + { + int i = 0; + for(i = 0; i < size; i++) + { + int type = 0; + axis2_svc_grp_t *svc_grp = NULL; + axis2_char_t *file_name = NULL; + axis2_module_desc_t *meta_data = NULL; + + dep_engine->curr_file = (axis2_arch_file_data_t *)axutil_array_list_get( + dep_engine->ws_to_deploy, env, i); + + type = axis2_arch_file_data_get_type(dep_engine->curr_file, env); + switch(type) + { + case AXIS2_SVC: + { + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + } + + dep_engine->arch_reader = axis2_arch_reader_create(env); + svc_grp = axis2_svc_grp_create_with_conf(env, dep_engine->conf); + file_name = axis2_arch_file_data_get_name(dep_engine->curr_file, env); + status = axis2_arch_reader_process_svc_grp(dep_engine->arch_reader, env, + file_name, dep_engine, svc_grp); + + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing service group %s failed", file_name); + + return status; + } + + status = axis2_dep_engine_add_new_svc(dep_engine, env, svc_grp); + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding new service %s to the deployment engine failed", file_name); + + return status; + } + + dep_engine->curr_file = NULL; + break; + } + + case AXIS2_MODULE: + { + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + } + dep_engine->arch_reader = axis2_arch_reader_create(env); + meta_data = axis2_module_desc_create(env); + file_name = axis2_arch_file_data_get_name(dep_engine->curr_file, env); + status = axis2_arch_reader_read_module_arch(env, file_name, dep_engine, + meta_data); + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Reading module archive for file %s failed", file_name); + + return AXIS2_FAILURE; + } + + status = axis2_dep_engine_add_new_module(dep_engine, env, meta_data); + if(AXIS2_SUCCESS != status) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE, AXIS2_FAILURE); + + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding new module %s to the deployment engine failed", file_name); + + return AXIS2_FAILURE; + } + + dep_engine->curr_file = NULL; + break; + } + }; + + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + dep_engine->curr_file = NULL; + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_undeploy( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + int size = 0; + axis2_char_t *svc_name = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + size = axutil_array_list_size(dep_engine->ws_to_undeploy, env); + + if(size > 0) + { + int i = 0; + for(i = 0; i < size; i++) + { + int type = 0; + axis2_ws_info_t *ws_info = NULL; + axutil_hash_t *faulty_svcs = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(dep_engine->ws_to_undeploy, env, i); + type = axis2_ws_info_get_type(ws_info, env); + if(type == AXIS2_SVC) + { + axis2_char_t *file_name = NULL; + + file_name = axis2_ws_info_get_file_name(ws_info, env); + svc_name = axis2_dep_engine_get_axis_svc_name(dep_engine, env, file_name); + + axis2_conf_remove_svc(dep_engine->conf, env, svc_name); + } + + faulty_svcs = axis2_conf_get_all_faulty_svcs(dep_engine->conf, env); + axutil_hash_set(faulty_svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL); + } + + } + + axutil_array_list_free(dep_engine->ws_to_undeploy, env); + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_dep_engine_is_hot_update( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + return dep_engine->hot_update; +} + +static axis2_char_t * +axis2_dep_engine_get_axis_svc_name( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + axis2_char_t name_sep = '.'; + axis2_char_t *temp_name = NULL; + axis2_char_t *ptr = NULL; + axis2_char_t *file_name_l = NULL; + axis2_char_t *svc_name = NULL; + int len = 0; + + file_name_l = axutil_strdup(env, file_name); + ptr = AXIS2_STRRCHR(file_name_l, AXIS2_PATH_SEP_CHAR); + + temp_name = ptr + 1; + ptr = AXIS2_STRRCHR(temp_name, name_sep); + ptr[0] = '\0'; + len = (int)strlen(temp_name); + /* We are sure that the difference lies within the int range */ + svc_name = AXIS2_MALLOC(env->allocator, len + 1); + sscanf(temp_name, "%s", svc_name); + AXIS2_FREE(env->allocator, file_name_l); + + return svc_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_phases_info( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_phases_info_t * phases_info) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + dep_engine->phases_info = phases_info; + return AXIS2_SUCCESS; +} + +/** + * This method is used to fill a axis2 service instance using services.xml , + * first it should create an axis service instance and then fill that using + * given service.xml and load all the required class and build the chains , + * finally add the service context to engine context and axis2 service into + * Engine Configuration. + */ +AXIS2_EXTERN axis2_svc_t *AXIS2_CALL +axis2_dep_engine_build_svc( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_t * svc, + axis2_char_t * file_name) +{ + axiom_node_t *node = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + dep_engine->curr_file = axis2_arch_file_data_create_with_type_and_name(env, AXIS2_SVC, ""); + + dep_engine->svc_builder = axis2_svc_builder_create_with_file_and_dep_engine_and_svc(env, + file_name, dep_engine, svc); + + node = axis2_desc_builder_build_om(axis2_svc_builder_get_desc_builder(dep_engine->svc_builder, + env), env); + + axis2_svc_builder_populate_svc(dep_engine->svc_builder, env, node); + + return svc; +} + +/** + * This function can be used to build Module Description for a given module + * archieve file. + */ +AXIS2_EXTERN axis2_module_desc_t *AXIS2_CALL +axis2_dep_engine_build_module( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axutil_file_t * module_archive, + axis2_conf_t * conf) +{ + axis2_module_desc_t *module_desc = NULL; + axis2_module_t *module = NULL; + axis2_phases_info_t *phases_info = NULL; + axis2_arch_reader_t *arch_reader = NULL; + axis2_flow_t *in_flow = NULL; + axis2_flow_t *out_flow = NULL; + axis2_flow_t *in_fault_flow = NULL; + axis2_flow_t *out_fault_flow = NULL; + axis2_char_t *file_name = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, module_archive, NULL); + AXIS2_PARAM_CHECK(env->error, conf, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + + phases_info = axis2_conf_get_phases_info(conf, env); + axis2_dep_engine_set_phases_info(dep_engine, env, phases_info); + dep_engine->curr_file = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, + module_archive); + + module_desc = axis2_module_desc_create(env); + arch_reader = axis2_arch_reader_create(env); + file_name = axutil_file_get_name(module_archive, env); + status = axis2_arch_reader_read_module_arch(env, file_name, dep_engine, module_desc); + axis2_arch_reader_free(arch_reader, env); + if(AXIS2_SUCCESS != status) + { + axis2_module_desc_free(module_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Reading module archive for file %s failed", + file_name); + return NULL; + } + status = axis2_dep_engine_load_module_dll(dep_engine, env, module_desc); + if(AXIS2_SUCCESS != status) + { + axis2_module_desc_free(module_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Loading module dll %s failed", file_name); + return NULL; + } + + module = axis2_module_desc_get_module(module_desc, env); + + /* Module implementor will provide functions for creating his handlers and by calling this + * function these function pointers will be stored in a hash map in the module. + */ + axis2_module_fill_handler_create_func_map(module, env); + + in_flow = axis2_module_desc_get_in_flow(module_desc, env); + if(in_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_flow, + module->handler_create_func_map); + } + + out_flow = axis2_module_desc_get_out_flow(module_desc, env); + if(out_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_flow, + module->handler_create_func_map); + } + + in_fault_flow = axis2_module_desc_get_fault_in_flow(module_desc, env); + if(in_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, in_fault_flow, + module->handler_create_func_map); + } + + out_fault_flow = axis2_module_desc_get_fault_out_flow(module_desc, env); + if(out_fault_flow) + { + axis2_dep_engine_add_module_flow_handlers(dep_engine, env, out_fault_flow, + module->handler_create_func_map); + } + + dep_engine->curr_file = NULL; + + return module_desc; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_dep_engine_get_repos_path( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return dep_engine->folder_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_current_file_item( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_arch_file_data_t * file_data) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + if(dep_engine->curr_file) + { + axis2_arch_file_data_free(dep_engine->curr_file, env); + dep_engine->curr_file = NULL; + } + dep_engine->curr_file = file_data; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_arch_reader( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_arch_reader_t * arch_reader) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + if(dep_engine->arch_reader) + { + axis2_arch_reader_free(dep_engine->arch_reader, env); + dep_engine->arch_reader = NULL; + } + dep_engine->arch_reader = arch_reader; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_module_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_module_builder_t * module_builder) +{ + AXIS2_PARAM_CHECK(env->error, module_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->module_builders, env, module_builder); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_svc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_builder_t * svc_builder) +{ + AXIS2_PARAM_CHECK(env->error, svc_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->svc_builders, env, svc_builder); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_svc_grp_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + axis2_svc_grp_builder_t * svc_grp_builder) +{ + AXIS2_PARAM_CHECK(env->error, svc_grp_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->svc_grp_builders, env, svc_grp_builder); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_add_desc_builder( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + struct axis2_desc_builder * desc_builder) +{ + AXIS2_PARAM_CHECK(env->error, desc_builder, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + + return axutil_array_list_add(dep_engine->desc_builders, env, desc_builder); +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_dep_engine_get_module_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return axutil_strdup(env, dep_engine->module_dir); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_module_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *module_dir) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, module_dir, AXIS2_FAILURE); + dep_engine->module_dir = axutil_strdup(env, module_dir); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_dep_engine_get_file_flag( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FALSE); + return dep_engine->file_flag; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_dep_engine_get_svc_dir( + const axis2_dep_engine_t * dep_engine, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + return axutil_strdup(env, dep_engine->svc_dir); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_dep_engine_set_svc_dir( + axis2_dep_engine_t * dep_engine, + const axutil_env_t * env, + const axis2_char_t *svc_dir) +{ + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_dir, AXIS2_FAILURE); + dep_engine->svc_dir = axutil_strdup(env, svc_dir); + return AXIS2_SUCCESS; +} + +static axis2_status_t +axis2_dep_engine_set_svc_and_module_dir_path( + axis2_dep_engine_t *dep_engine, + const axutil_env_t *env) +{ + axis2_bool_t flag; + axis2_conf_t *conf; + axis2_char_t *dirpath; + axutil_param_t *dep_param; + AXIS2_PARAM_CHECK(env->error, dep_engine, AXIS2_FAILURE); + flag = dep_engine->file_flag; + if(!flag) + { + return AXIS2_SUCCESS; + } + else + { + conf = dep_engine->conf; + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Axis2 Configuration cannot be NULL"); + return AXIS2_FAILURE; + } + + dep_param = axis2_conf_get_param(conf, env, AXIS2_MODULE_DIR); + if(dep_param) + { + dirpath = (axis2_char_t *)axutil_param_get_value(dep_param, env); + if(dirpath) + { + dep_engine->module_dir = dirpath; + dirpath = NULL; + } + } + dep_param = NULL; + + dep_param = axis2_conf_get_param(conf, env, AXIS2_SERVICE_DIR); + if(dep_param) + { + dirpath = (axis2_char_t *)axutil_param_get_value(dep_param, env); + if(dirpath) + { + dep_engine->svc_dir = dirpath; + dirpath = NULL; + } + } + } + + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/desc_builder.c b/src/core/deployment/desc_builder.c new file mode 100644 index 0000000..a6fde18 --- /dev/null +++ b/src/core/deployment/desc_builder.c @@ -0,0 +1,1148 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +struct axis2_desc_builder +{ + /** + * Store the full path to configuration file. + */ + axis2_char_t *file_name; + axiom_node_t *root; + struct axis2_dep_engine *engine; +}; + +static axis2_status_t +set_attrs_and_value( + axutil_param_t * param, + const axutil_env_t * env, + axiom_element_t * param_element, + axiom_node_t * param_node); + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_desc_builder_create( + const axutil_env_t * env) +{ + axis2_desc_builder_t *desc_builder = NULL; + + desc_builder = (axis2_desc_builder_t *)AXIS2_MALLOC(env-> allocator, + sizeof(axis2_desc_builder_t)); + + if(!desc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot allocate memory to desc_builder"); + return NULL; + } + desc_builder->file_name = NULL; + desc_builder->engine = NULL; + desc_builder->root = NULL; + + return desc_builder; +} + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_desc_builder_create_with_file_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * file_name, + axis2_dep_engine_t * engine) +{ + axis2_desc_builder_t *desc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + AXIS2_PARAM_CHECK(env->error, engine, NULL); + + desc_builder = (axis2_desc_builder_t *)axis2_desc_builder_create(env); + if(!desc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot allocate memory to desc_builder"); + return NULL; + } + + desc_builder->root = NULL; + + desc_builder->file_name = axutil_strdup(env, file_name); + if(!desc_builder->file_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "No memory. Cannot allocate memory to desc_builder->file_name"); + return NULL; + } + desc_builder->engine = engine; + + return desc_builder; +} + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_desc_builder_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine * engine) +{ + axis2_desc_builder_t *desc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, engine, NULL); + + desc_builder = (axis2_desc_builder_t *)axis2_desc_builder_create(env); + if(!desc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Cannot allocate memory to desc_builder"); + return NULL; + } + + desc_builder->engine = engine; + + return desc_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_desc_builder_free( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env) +{ + if(desc_builder->file_name) + { + AXIS2_FREE(env->allocator, desc_builder->file_name); + } + + if(desc_builder->root) + { + axiom_node_free_tree(desc_builder->root, env); + } + + /* we cannot free deployment engine here */ + desc_builder->engine = NULL; + + if(desc_builder) + { + AXIS2_FREE(env->allocator, desc_builder); + } + return; +} + +AXIS2_EXTERN axiom_node_t *AXIS2_CALL +axis2_desc_builder_build_om( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env) +{ + axiom_xml_reader_t *reader = NULL; + axiom_document_t *document = NULL; + axiom_stax_builder_t *builder = NULL; + + if(!desc_builder->file_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_STATE_DESC_BUILDER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Invalid state desc builder. Unable to continue"); + return NULL; + } + + /** create pull parser using the file path to configuration file */ + reader = axiom_xml_reader_create_for_file(env, desc_builder->file_name, NULL); + + if(!reader) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create xml reader for %s", + desc_builder->file_name); + return NULL; + }; + + /** create axiom_stax_builder by parsing pull_parser struct */ + builder = axiom_stax_builder_create(env, reader); + + if(!(builder)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CREATING_XML_STREAM_READER, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Could not create xml stream reader for desc builder %s. Unable " + "to continue", desc_builder->file_name); + return NULL; + } + + /** + get the om document form builder + document is the container of om model created using builder + */ + document = axiom_stax_builder_get_document(builder, env); + + /** + * In description building we don't want defferred building. So build + * the whole tree at once + */ + axiom_document_build_all(document, env); + + /** + get root element , building starts hear + */ + desc_builder->root = axiom_document_get_root_element(document, env); + /** + We have built the whole document. So no need of keeping the builder. + */ + axiom_stax_builder_free_self(builder, env); + + return desc_builder->root; +} + +AXIS2_EXTERN axis2_flow_t *AXIS2_CALL +axis2_desc_builder_process_flow( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_element_t * flow_element, + axutil_param_container_t * parent, + axiom_node_t * flow_node) +{ + axis2_flow_t *flow = NULL; + axiom_children_qname_iterator_t *handlers = NULL; + axutil_qname_t *qchild = NULL; + + AXIS2_PARAM_CHECK(env->error, parent, NULL); + AXIS2_PARAM_CHECK(env->error, flow_node, NULL); + + flow = axis2_flow_create(env); + if(!flow) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Could not allocate to flow"); + return NULL; + } + + if(!flow_element) + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "There is no flow element to process"); + return NULL; + } + + qchild = axutil_qname_create(env, AXIS2_HANDLERST, NULL, NULL); + handlers = axiom_element_get_children_with_qname(flow_element, env, qchild, flow_node); + if(qchild) + { + axutil_qname_free(qchild, env); + } + + while(axiom_children_qname_iterator_has_next(handlers, env)) + { + axiom_node_t *handler_node = NULL; + axis2_handler_desc_t *handler_desc = NULL; + axis2_status_t status = AXIS2_FAILURE; + + handler_node = (axiom_node_t *)axiom_children_qname_iterator_next(handlers, env); + + handler_desc = axis2_desc_builder_process_handler(desc_builder, env, handler_node, parent); + status = axis2_flow_add_handler(flow, env, handler_desc); + if(!status) + { + const axutil_string_t *handler_name = NULL; + const axis2_char_t *hname = NULL; + handler_name = axis2_handler_desc_get_name(handler_desc, env); + hname = axutil_string_get_buffer(handler_name, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding handler %s to flow failed", hname); + axis2_flow_free(flow, env); + return NULL; + } + } + return flow; +} + +struct axis2_handler_desc *AXIS2_CALL +axis2_desc_builder_process_handler( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * handler_node, + struct axutil_param_container *parent) +{ + axis2_handler_desc_t *handler_desc = NULL; + axiom_attribute_t *name_attrib = NULL; + axutil_qname_t *attr_qname = NULL; + axiom_attribute_t *class_attrib = NULL; + axutil_qname_t *class_qname = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *attrib_value = NULL; + axiom_element_t *handler_element = NULL; + axiom_node_t *order_node = NULL; + axiom_element_t *order_element = NULL; + axutil_qname_t *order_qname = NULL; + axutil_string_t *handler_name = NULL; + const axis2_char_t *hname = NULL; + + AXIS2_PARAM_CHECK(env->error, handler_node, NULL); + AXIS2_PARAM_CHECK(env->error, parent, NULL); + + handler_desc = axis2_handler_desc_create(env, NULL); + if(!handler_desc) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not create handler description"); + return NULL; + } + /* Setting Handler name */ + attr_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + handler_element = axiom_node_get_data_element(handler_node, env); + name_attrib = axiom_element_get_attribute(handler_element, env, attr_qname); + if(attr_qname) + { + axutil_qname_free(attr_qname, env); + } + + if(!name_attrib) + { + axis2_handler_desc_free(handler_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Name attribute not fould for handler."); + return NULL; + } + else + { + axis2_char_t *value = NULL; + + value = axiom_attribute_get_value(name_attrib, env); + handler_name = axutil_string_create(env, value); + status = axis2_handler_desc_set_name(handler_desc, env, handler_name); + if(handler_name) + { + axutil_string_free(handler_name, env); + } + + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting name for handler description failed in %s", desc_builder->file_name); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + hname = axutil_string_get_buffer(handler_name, env); + /*Setting Handler Class name */ + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + class_attrib = axiom_element_get_attribute(handler_element, env, class_qname); + if(class_qname) + { + axutil_qname_free(class_qname, env); + } + + if(!class_attrib) + { + axis2_handler_desc_free(handler_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Library name attribute not found for handler %s", + hname); + return NULL; + } + else + { + attrib_value = axiom_attribute_get_value(class_attrib, env); + status = axis2_handler_desc_set_class_name(handler_desc, env, attrib_value); + } + + /*processing phase Rules (order) */ + + order_qname = axutil_qname_create(env, AXIS2_ORDER, NULL, NULL); + order_element = axiom_element_get_first_child_with_qname(handler_element, env, order_qname, + handler_node, &order_node); + if(order_qname) + { + axutil_qname_free(order_qname, env); + } + + if(!order_element || !order_node) + { + axis2_handler_desc_free(handler_desc, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_HANDLER_STATE, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Order node not found for handler description %s", + hname); + return NULL; + } + else + { + axutil_hash_t *order_itr = NULL; + axiom_children_qname_iterator_t *params = NULL; + axutil_qname_t *param_qname = NULL; + axutil_hash_index_t *index_i = NULL; + + order_itr = axiom_element_get_all_attributes(order_element, env); + if(!order_itr) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Order element for handler desc %s does not contain any " + "attribute", hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + index_i = axutil_hash_first(order_itr, env); + + while(index_i) + { + axiom_attribute_t *order_attrib = NULL; + axutil_qname_t *qname = NULL; + axis2_char_t *name = NULL; + axis2_char_t *value = NULL; + void *v = NULL; + + axutil_hash_this(index_i, NULL, NULL, &v); + order_attrib = (axiom_attribute_t *)v; + qname = axiom_attribute_get_qname(order_attrib, env); + name = axutil_qname_get_localpart(qname, env); + + value = axiom_attribute_get_value(order_attrib, env); + if(!axutil_strcmp(AXIS2_AFTER, name)) + { + struct axis2_phase_rule *phase_rule = NULL; + + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_after(phase_rule, env, value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s phase rule failed for handler %s", AXIS2_AFTER, hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + if(!axutil_strcmp(AXIS2_BEFORE, name)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_before(phase_rule, env, value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s phase rule failed for handler %s", AXIS2_BEFORE, hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + if(!axutil_strcmp(AXIS2_PHASE, name)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_name(phase_rule, env, value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting phase rule name failed for handler %s", hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + if(!axutil_strcmp(AXIS2_PHASEFIRST, name)) + { + axis2_char_t *bool_val = NULL; + + bool_val = axis2_desc_builder_get_value(desc_builder, env, value); + if(!axutil_strcmp(bool_val, AXIS2_VALUE_TRUE)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_first(phase_rule, env, AXIS2_TRUE); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s property for phase rules for handler " + "%s failed", AXIS2_PHASEFIRST, hname); + axis2_handler_desc_free(handler_desc, env); + AXIS2_FREE(env->allocator, bool_val); + return NULL; + } + } + else if(!axutil_strcmp(bool_val, AXIS2_VALUE_FALSE)) + { + struct axis2_phase_rule *phase_rule = NULL; + phase_rule = axis2_handler_desc_get_rules(handler_desc, env); + status = axis2_phase_rule_set_first(phase_rule, env, AXIS2_FALSE); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting %s property for phase rules for handler " + "%s failed", AXIS2_PHASEFIRST, hname); + axis2_handler_desc_free(handler_desc, env); + AXIS2_FREE(env->allocator, bool_val); + return NULL; + } + } + AXIS2_FREE(env->allocator, bool_val); + } + index_i = axutil_hash_next(env, index_i); + } + + param_qname = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params = axiom_element_get_children_with_qname(handler_element, env, param_qname, + handler_node); + axutil_qname_free(param_qname, env); + status = axis2_desc_builder_process_params(desc_builder, env, params, + axis2_handler_desc_get_param_container(handler_desc, env), parent); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing params failed for handler %s", + hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + } + + status = axis2_handler_desc_set_parent(handler_desc, env, parent); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting parent failed for handler %s", hname); + axis2_handler_desc_free(handler_desc, env); + return NULL; + } + + return handler_desc; +} + +static axis2_status_t +set_attrs_and_value( + axutil_param_t * param, + const axutil_env_t * env, + axiom_element_t * param_element, + axiom_node_t * param_node) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_hash_t *attrs = NULL; + axiom_child_element_iterator_t *childs = NULL; + + AXIS2_PARAM_CHECK(env->error, param, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_element, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_node, AXIS2_FAILURE); + + /* Setting attributes */ + attrs = axiom_element_extract_attributes(param_element, env, param_node); + if(attrs) + { + axutil_hash_index_t *i = NULL; + + for(i = axutil_hash_first(attrs, env); i; i = axutil_hash_next(env, i)) + { + void *v = NULL; + axiom_attribute_t *value = NULL; + axutil_generic_obj_t *obj = NULL; + axutil_qname_t *attr_qname = NULL; + axis2_char_t *attr_name = NULL; + + axutil_hash_this(i, NULL, NULL, &v); + if(!v) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Attibute missing in the parameter element"); + axutil_param_free(param, env); + return AXIS2_FAILURE; + } + obj = axutil_generic_obj_create(env); + if(!obj) + { + axutil_param_free(param, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + value = (axiom_attribute_t *)v; + axutil_generic_obj_set_value(obj, env, value); + axutil_generic_obj_set_free_func(obj, env, axiom_attribute_free_void_arg); + attr_qname = axiom_attribute_get_qname(value, env); + attr_name = axutil_qname_to_string(attr_qname, env); + axutil_hash_set(attrs, attr_name, AXIS2_HASH_KEY_STRING, obj); + } + axutil_param_set_attributes(param, env, attrs); + } + + childs = axiom_element_get_child_elements(param_element, env, param_node); + if(childs) + { + axutil_array_list_t *value_list = NULL; + + value_list = axutil_array_list_create(env, 0); + axutil_param_set_value_list(param, env, value_list); + + while(AXIOM_CHILD_ELEMENT_ITERATOR_HAS_NEXT(childs, env)) + { + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + axutil_param_t *param = NULL; + axis2_char_t *pname = NULL; + + node = AXIOM_CHILD_ELEMENT_ITERATOR_NEXT(childs, env); + element = axiom_node_get_data_element(node, env); + param = axutil_param_create(env, NULL, NULL); + pname = axiom_element_get_localname(element, env); + status = axutil_param_set_name(param, env, pname); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name to parameter failed"); + axutil_param_free(param, env); + return status; + } + axutil_param_set_param_type(param, env, AXIS2_DOM_PARAM); + set_attrs_and_value(param, env, element, node); + axutil_array_list_add(value_list, env, param); + } + } + else + { + axis2_char_t *para_test_value = NULL; + axis2_char_t *temp = NULL; + + temp = axiom_element_get_text(param_element, env, param_node); + para_test_value = axutil_strdup(env, temp); + status = axutil_param_set_value(param, env, para_test_value); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting value to parameter failed"); + axutil_param_free(param, env); + AXIS2_FREE(env->allocator, para_test_value); + return status; + } + axutil_param_set_param_type(param, env, AXIS2_TEXT_PARAM); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_rest_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc) +{ + axiom_element_t *op_element = NULL; + axutil_qname_t *qname = NULL; + axutil_qname_t *param_qname = NULL; + axiom_node_t *rest_node = NULL; + axiom_element_t *rest_element = NULL; + axiom_children_qname_iterator_t *rest_mappings = NULL; + + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + + op_element = axiom_node_get_data_element(op_node, env); + + param_qname = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + + if(op_element) + { + rest_mappings + = axiom_element_get_children_with_qname(op_element, env, param_qname, op_node); + } + + while(rest_mappings && axiom_children_qname_iterator_has_next(rest_mappings, env)) + { + axis2_char_t *param_value = NULL; + rest_node = (axiom_node_t *)axiom_children_qname_iterator_next(rest_mappings, env); + rest_element = axiom_node_get_data_element(rest_node, env); + param_value = axiom_element_get_attribute_value(rest_element, env, qname); + if(!strcmp(param_value, AXIS2_REST_HTTP_METHOD)) + { + axis2_op_set_rest_http_method(op_desc, env, axiom_element_get_text(rest_element, env, + rest_node)); + } + param_value = axiom_element_get_attribute_value(rest_element, env, qname); + if(!strcmp(param_value, AXIS2_REST_HTTP_LOCATION)) + { + axis2_op_set_rest_http_location(op_desc, env, axiom_element_get_text(rest_element, env, + rest_node)); + } + if(axis2_op_get_rest_http_method(op_desc, env) && axis2_op_get_rest_http_location(op_desc, + env)) + { + break; + } + } + + axutil_qname_free(qname, env); + axutil_qname_free(param_qname, env); + return AXIS2_SUCCESS; +} + +/** + * Populate the Axis2 Operation with details from the actionMapping, + * outputActionMapping and faultActionMapping elements from the operation + * element. + * + * @param operation + * @param op_desc + */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_action_mappings( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_node_t * op_node, + axis2_op_t * op_desc) +{ + axiom_element_t *op_element = NULL; + axutil_qname_t *qname = NULL; + axiom_children_qname_iterator_t *action_mappings = NULL; + axutil_array_list_t *mapping_list = axutil_array_list_create(env, 0); + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + + op_element = axiom_node_get_data_element(op_node, env); + qname = axutil_qname_create(env, AXIS2_ACTION_MAPPING, NULL, NULL); + if(op_element) + { + action_mappings = axiom_element_get_children_with_qname(op_element, env, qname, op_node); + } + + axutil_qname_free(qname, env); + qname = NULL; + if(!action_mappings) + { + if(mapping_list) + { + axutil_array_list_free(mapping_list, env); + mapping_list = NULL; + } + return AXIS2_SUCCESS; + } + while(axiom_children_qname_iterator_has_next(action_mappings, env)) + { + axiom_element_t *mapping_element = NULL; + axiom_node_t *mapping_node = NULL; + axis2_char_t *input_action_string = NULL; + axis2_char_t *temp_str = NULL; + + /* This is to check whether some one has locked the parmter at the top + * level + */ + mapping_node = (axiom_node_t *)axiom_children_qname_iterator_next(action_mappings, env); + mapping_element = axiom_node_get_data_element(mapping_node, env); + temp_str = axiom_element_get_text(mapping_element, env, mapping_node); + input_action_string = axutil_strtrim(env, temp_str, NULL); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Input action mapping found %s", + input_action_string); + if(axutil_strcmp("", input_action_string)) + { + axutil_array_list_add(mapping_list, env, input_action_string); + } + else + { + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Zero length " + "input_action_string found. Not added to the mapping list"); + } + } + axis2_op_set_wsamapping_list(op_desc, env, mapping_list); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_params( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * params, + axutil_param_container_t * param_container, + axutil_param_container_t * parent) +{ + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, params, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, param_container, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(params, env)) + { + axiom_element_t *param_element = NULL; + axiom_node_t *param_node = NULL; + axutil_param_t *param = NULL; + axutil_param_t *parent_para = NULL; + axiom_attribute_t *para_name = NULL; + axiom_attribute_t *para_locked = NULL; + axutil_qname_t *att_locked = NULL; + axutil_qname_t *att_qname = NULL; + axis2_char_t *pname = NULL; + + /* This is to check whether some one has locked the parmter at the top + * level + */ + param_node = (axiom_node_t *)axiom_children_qname_iterator_next(params, env); + param_element = axiom_node_get_data_element(param_node, env); + param = axutil_param_create(env, NULL, NULL); + + /* Setting paramter name */ + att_qname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + para_name = axiom_element_get_attribute(param_element, env, att_qname); + axutil_qname_free(att_qname, env); + if(!para_name) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Parameter name attribute not found for parameter"); + axutil_param_free(param, env); + return AXIS2_FAILURE; + } + pname = axiom_attribute_get_value(para_name, env); + status = axutil_param_set_name(param, env, pname); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Could not set parameter name for parameter"); + axutil_param_free(param, env); + return status; + } + + /* Setting paramter Value (the chiled elemnt of the paramter) */ + set_attrs_and_value(param, env, param_element, param_node); + + /* Setting locking attrib */ + att_locked = axutil_qname_create(env, AXIS2_ATTLOCKED, NULL, NULL); + para_locked = axiom_element_get_attribute(param_element, env, att_locked); + axutil_qname_free(att_locked, env); + if(parent) + { + axis2_char_t *param_name = NULL; + + param_name = axutil_param_get_name(param, env); + parent_para = axutil_param_container_get_param(parent, env, param_name); + } + if(para_locked) + { + axis2_char_t *locked_value = NULL; + locked_value = axiom_attribute_get_value(para_locked, env); + if(!axutil_strcmp(AXIS2_VALUE_TRUE, locked_value)) + { + axis2_char_t *param_name = NULL; + axis2_bool_t is_param_locked = AXIS2_FALSE; + /*if the parameter is locked at some level parameter value replace + * by that + */ + param_name = axutil_param_get_name(param, env); + is_param_locked = axutil_param_container_is_param_locked(parent, env, param_name); + if(parent && is_param_locked) + { + axutil_param_free(param, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_CONFIG_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Parameter %s is locked", param_name); + return AXIS2_FAILURE; + } + else + { + axutil_param_set_locked(param, env, AXIS2_TRUE); + } + } + else + { + axutil_param_set_locked(param, env, AXIS2_FALSE); + } + } + + if(parent) + { + axis2_char_t *name = NULL; + axis2_bool_t bvalue = AXIS2_FALSE; + + name = axutil_param_get_name(param, env); + bvalue = axutil_param_container_is_param_locked(parent, env, name); + if(parent_para || !bvalue) + { + status = axutil_param_container_add_param(param_container, env, param); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding parameter %s failed", name); + axutil_param_free(param, env); + return status; + } + } + } + else + { + status = axutil_param_container_add_param(param_container, env, param); + if(!status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding parameter %s failed", pname); + axutil_param_free(param, env); + return status; + } + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_desc_builder_process_op_module_refs( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_op_t * op) +{ + axiom_element_t *moduleref = NULL; + axiom_attribute_t *module_ref_attrib = NULL; + axutil_qname_t *qref = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, op, AXIS2_FAILURE); + + while(module_refs && axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_node_t *moduleref_node = axiom_children_qname_iterator_next(module_refs, env); + moduleref = (axiom_element_t *)axiom_node_get_data_element(moduleref_node, env); + + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_attrib = axiom_element_get_attribute(moduleref, env, qref); + axutil_qname_free(qref, env); + if(module_ref_attrib) + { + axis2_char_t *ref_name = NULL; + axutil_qname_t *ref_qname = NULL; + axis2_module_desc_t *module_desc = NULL; + + ref_name = axiom_attribute_get_value(module_ref_attrib, env); + ref_qname = axutil_qname_create(env, ref_name, NULL, NULL); + module_desc = axis2_dep_engine_get_module(desc_builder->engine, env, ref_qname); + if(!module_desc) + { + axutil_qname_free(ref_qname, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s not found in the deployment engine", ref_name); + + return AXIS2_FAILURE; + } + else + { + status = axis2_op_add_module_qname(op, env, ref_qname); + axutil_qname_free(ref_qname, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Adding module ref %s to operation %s failed", ref_name, + axutil_qname_get_localpart(axis2_op_get_qname(op, env), env)); + + return AXIS2_FAILURE; + } + } + } + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_msg_recv_t *AXIS2_CALL +axis2_desc_builder_load_msg_recv( + axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + struct axiom_element * recv_element) +{ + axiom_attribute_t *recv_name = NULL; + axis2_char_t *class_name = NULL; + axis2_msg_recv_t *msg_recv = NULL; + axutil_qname_t *class_qname = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axis2_char_t *repos_name = NULL; + axis2_char_t *dll_name = NULL; + axis2_char_t *temp_path = NULL; + axis2_char_t *temp_path2 = NULL; + axis2_char_t *temp_path3 = NULL; + axis2_conf_t *conf = NULL; + axis2_char_t *msg_recv_dll_name = NULL; + + AXIS2_PARAM_CHECK(env->error, recv_element, NULL); + + class_qname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + recv_name = axiom_element_get_attribute(recv_element, env, class_qname); + axutil_qname_free(class_qname, env); + class_name = axiom_attribute_get_value(recv_name, env); + + conf = axis2_dep_engine_get_axis_conf(desc_builder->engine, env); + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Configuration not found in the deployment engine"); + return NULL; + } + impl_info_param = axis2_conf_get_param(conf, env, class_name); + + if(!impl_info_param) + { + dll_desc = axutil_dll_desc_create(env); + msg_recv_dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, + class_name); + repos_name = axis2_dep_engine_get_repos_path(desc_builder->engine, env); + temp_path = axutil_stracat(env, repos_name, AXIS2_PATH_SEP_STR); + temp_path2 = axutil_stracat(env, temp_path, AXIS2_LIB_FOLDER); + temp_path3 = axutil_stracat(env, temp_path2, AXIS2_PATH_SEP_STR); + dll_name = axutil_stracat(env, temp_path3, msg_recv_dll_name); + AXIS2_FREE(env->allocator, temp_path); + AXIS2_FREE(env->allocator, temp_path2); + AXIS2_FREE(env->allocator, temp_path3); + axutil_dll_desc_set_name(dll_desc, env, dll_name); + AXIS2_FREE(env->allocator, dll_name); + axutil_dll_desc_set_type(dll_desc, env, AXIS2_MSG_RECV_DLL); + impl_info_param = axutil_param_create(env, class_name, NULL); + axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + /* set the impl_info_param(which contain dll_desc as value) so that + * loaded msg_recv loader lib can be re-used in future + */ + axis2_conf_add_param(conf, env, impl_info_param); + } + + axutil_class_loader_init(env); + msg_recv = (axis2_msg_recv_t *)axutil_class_loader_create_dll(env, impl_info_param); + return msg_recv; +} + +AXIS2_EXTERN struct axis2_msg_recv *AXIS2_CALL +axis2_desc_builder_load_default_msg_recv( + const axutil_env_t * env) +{ + axis2_msg_recv_t *msg_recv = NULL; + + msg_recv = axis2_raw_xml_in_out_msg_recv_create(env); + return msg_recv; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_desc_builder_get_short_file_name( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + const axis2_char_t *separator = NULL; + axis2_char_t *value = NULL; + axis2_char_t *file_name_l = NULL; + axis2_char_t *short_name = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + file_name_l = axutil_strdup(env, file_name); + if(!file_name_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + separator = "."; + + value = axutil_strstr(file_name_l, separator); + + value[0] = AXIS2_EOLN; + short_name = file_name_l; + + return short_name; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_desc_builder_get_file_name_without_prefix( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * short_file_name) +{ + axis2_char_t *file_name_l = NULL; + axis2_char_t *short_name = NULL; + int len = 0; + AXIS2_PARAM_CHECK(env->error, short_file_name, NULL); + file_name_l = axutil_strdup(env, short_file_name); + if(!file_name_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + len = axutil_strlen(AXIS2_LIB_PREFIX); + short_name = &file_name_l[len]; + return short_name; + +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_desc_builder_get_value( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env, + axis2_char_t * in) +{ + const axis2_char_t *separator = ":"; + axis2_char_t *value = NULL; + axis2_char_t *in_l = NULL; + + AXIS2_PARAM_CHECK(env->error, in, NULL); + + in_l = axutil_strdup(env, in); + if(!in_l) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + value = axutil_strstr(in_l, separator); + value = value + 1; + + return value; +} + +AXIS2_EXTERN struct axis2_dep_engine *AXIS2_CALL +axis2_desc_builder_get_dep_engine( + const axis2_desc_builder_t * desc_builder, + const axutil_env_t * env) +{ + return desc_builder->engine; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_process_policy_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include) +{ + while(axiom_children_qname_iterator_has_next(iterator, env)) + { + axiom_node_t *node = NULL; + node = axiom_children_qname_iterator_next(iterator, env); + if(node) + { + axiom_element_t *element = NULL; + neethi_policy_t *policy = NULL; + + element = axiom_node_get_data_element(node, env); + policy = neethi_engine_get_policy(env, node, element); + if(!policy) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return AXIS2_FAILURE; + } + axis2_policy_include_add_policy_element(policy_include, env, type, policy); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_process_policy_reference_elements( + const axutil_env_t * env, + int type, + axiom_children_qname_iterator_t * iterator, + axis2_policy_include_t * policy_include) +{ + while(axiom_children_qname_iterator_has_next(iterator, env)) + { + axiom_node_t *node = NULL; + node = axiom_children_qname_iterator_next(iterator, env); + if(node) + { + axiom_element_t *element = NULL; + neethi_reference_t *reference = NULL; + + element = axiom_node_get_data_element(node, env); + /* TODO: add neethi_engine_get_policy_reference + reference = neethi_engine_get_policy_reference(env, node, element); */ + axis2_policy_include_add_policy_reference_element(policy_include, env, type, reference); + } + } + return AXIS2_SUCCESS; +} + diff --git a/src/core/deployment/module_builder.c b/src/core/deployment/module_builder.c new file mode 100644 index 0000000..ad91866 --- /dev/null +++ b/src/core/deployment/module_builder.c @@ -0,0 +1,514 @@ +/* + * 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. + */ + +#include +#include + +struct axis2_module_builder +{ + axis2_module_desc_t *module_desc; + struct axis2_desc_builder *desc_builder; +}; + +static axutil_array_list_t *AXIS2_CALL axis2_module_builder_process_ops( + axis2_module_builder_t * module_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr); + +AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL +axis2_module_builder_create( + const axutil_env_t * env) +{ + axis2_module_builder_t *module_builder = NULL; + + module_builder = (axis2_module_builder_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_module_builder_t)); + + if(!module_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory to create module builder"); + return NULL; + } + + return module_builder; +} + +AXIS2_EXTERN axis2_module_builder_t *AXIS2_CALL +axis2_module_builder_create_with_file_and_dep_engine_and_module( + const axutil_env_t * env, + axis2_char_t * file_name, + axis2_dep_engine_t * dep_engine, + axis2_module_desc_t * module_desc) +{ + axis2_module_builder_t *module_builder = NULL; + + module_builder = (axis2_module_builder_t *)axis2_module_builder_create(env); + if(!module_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory to create module builder %s", file_name); + return NULL; + } + module_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, + file_name, dep_engine); + if(!module_builder->desc_builder) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Description builder creation failed for module builder %s", file_name); + axis2_module_builder_free(module_builder, env); + return NULL; + } + module_builder->module_desc = module_desc; + return module_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_module_builder_free( + axis2_module_builder_t * module_builder, + const axutil_env_t * env) +{ + if(module_builder->desc_builder) + { + axis2_desc_builder_free(module_builder->desc_builder, env); + } + + if(module_builder) + { + AXIS2_FREE(env->allocator, module_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_module_builder_populate_module( + axis2_module_builder_t * module_builder, + const axutil_env_t * env) +{ + axiom_element_t *module_element = NULL; + axiom_node_t *module_node = NULL; + axutil_qname_t *qdllname = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qinfaultflow = NULL; + axutil_qname_t *qoutfaultflow = NULL; + axutil_qname_t *qopst = NULL; + axiom_attribute_t *module_dll_att = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *op_itr = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *in_fault_flow_element = NULL; + axiom_node_t *in_fault_flow_node = NULL; + axiom_element_t *out_fault_flow_element = NULL; + axiom_node_t *out_fault_flow_node = NULL; + axis2_conf_t *parent = NULL; + axutil_array_list_t *ops = NULL; + axutil_param_container_t *parent_container = NULL; + int size = 0; + int i = 0; + axis2_arch_file_data_t *file_data = NULL; + axis2_char_t *module_name = NULL; + axutil_qname_t *module_qname = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_module_builder_populate_module"); + + module_node = axis2_desc_builder_build_om(module_builder->desc_builder, env); + module_element = axiom_node_get_data_element(module_node, env); + if(!module_element) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Data element not found for the module node, Unable to proceed"); + return AXIS2_FAILURE; + } + file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( + module_builder->desc_builder, env), env); + module_name = axis2_arch_file_data_get_module_name(file_data, env); + + module_qname = axutil_qname_create(env, module_name, NULL, NULL); + axis2_module_desc_set_qname(module_builder->module_desc, env, module_qname); + + if(module_qname) + { + axutil_qname_free(module_qname, env); + } + /* Setting Module Dll Name , if it is there */ + + qdllname = axutil_qname_create(env, AXIS2_CLASSNAME, NULL, NULL); + module_dll_att = axiom_element_get_attribute(module_element, env, qdllname); + if(qdllname) + { + axutil_qname_free(qdllname, env); + } + + if(module_dll_att) + { + axis2_char_t *class_name = NULL; + + class_name = axiom_attribute_get_value(module_dll_att, env); + if(class_name && (axutil_strcmp("", class_name))) + { + axis2_dep_engine_t *dep_engine = axis2_desc_builder_get_dep_engine( + module_builder->desc_builder, env); + if(dep_engine) + { + axis2_arch_file_data_t *file_data = NULL; + + file_data = axis2_dep_engine_get_current_file_item(dep_engine, env); + axis2_arch_file_data_set_module_dll_name(file_data, env, class_name); + } + } + } + + /* Processing Paramters */ + /* Processing service level paramters */ + + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + itr = axiom_element_get_children_with_qname(module_element, env, qparamst, module_node); + if(qparamst) + { + axutil_qname_free(qparamst, env); + } + parent = axis2_module_desc_get_parent(module_builder->module_desc, env); + + if(parent) + { + parent_container = axis2_conf_get_param_container(parent, env); + } + axis2_desc_builder_process_params(module_builder->desc_builder, env, itr, + axis2_module_desc_get_param_container(module_builder->module_desc, env), parent_container); + + /* Process IN_FLOW */ + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname(module_element, env, qinflowst, + module_node, &in_flow_node); + if(qinflowst) + { + axutil_qname_free(qinflowst, env); + } + + if(in_flow_element && in_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, in_flow_element, + axis2_module_desc_get_param_container(module_builder->module_desc, env), in_flow_node); + status = axis2_module_desc_set_in_flow(module_builder->module_desc, env, flow); + + if(!status) + { + if(flow) + { + axis2_flow_free(flow, env); + } + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting in flow failed for module desc %s", + module_name); + return status; + } + } + + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname(module_element, env, qoutflowst, + module_node, &out_flow_node); + if(qoutflowst) + { + axutil_qname_free(qoutflowst, env); + } + + if(out_flow_element && out_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, out_flow_element, + axis2_module_desc_get_param_container(module_builder->module_desc, env), out_flow_node); + status = axis2_module_desc_set_out_flow(module_builder->module_desc, env, flow); + + if(!status) + { + axis2_flow_free(flow, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting out flow failed for module desc %s", + module_name); + return status; + } + } + + qinfaultflow = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_fault_flow_element = axiom_element_get_first_child_with_qname(module_element, env, + qinfaultflow, module_node, &in_fault_flow_node); + if(qinfaultflow) + { + axutil_qname_free(qinfaultflow, env); + } + + if(in_fault_flow_element && NULL != in_fault_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, + in_fault_flow_element, axis2_module_desc_get_param_container( + module_builder->module_desc, env), in_fault_flow_node); + status = axis2_module_desc_set_fault_in_flow(module_builder->module_desc, env, flow); + + if(!status) + { + axis2_flow_free(flow, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting fault in flow failed for module desc %s", module_name); + return status; + } + } + + qoutfaultflow = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_fault_flow_element = axiom_element_get_first_child_with_qname(module_element, env, + qoutfaultflow, module_node, &out_fault_flow_node); + if(qoutfaultflow) + { + axutil_qname_free(qoutfaultflow, env); + } + + if(out_fault_flow_element && NULL != out_fault_flow_node) + { + axis2_flow_t *flow = NULL; + + flow = axis2_desc_builder_process_flow(module_builder->desc_builder, env, + out_fault_flow_element, axis2_module_desc_get_param_container( + module_builder->module_desc, env), out_fault_flow_node); + status = axis2_module_desc_set_fault_out_flow(module_builder->module_desc, env, flow); + if(AXIS2_SUCCESS != status) + { + axis2_flow_free(flow, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Setting fault out flow failed for module desc %s", module_name); + return status; + } + } + + /* Processing Operations */ + qopst = axutil_qname_create(env, AXIS2_OPERATIONST, NULL, NULL); + op_itr = axiom_element_get_children_with_qname(module_element, env, qopst, module_node); + if(qopst) + { + axutil_qname_free(qopst, env); + } + ops = axis2_module_builder_process_ops(module_builder, env, op_itr); + size = axutil_array_list_size(ops, env); + for(i = 0; i < size; i++) + { + axis2_op_t *op_desc = NULL; + + op_desc = (axis2_op_t *)axutil_array_list_get(ops, env, i); + axis2_module_desc_add_op(module_builder->module_desc, env, op_desc); + } + axutil_array_list_free(ops, env); + AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_module_builder_populate_module"); + return AXIS2_SUCCESS; +} + +static axutil_array_list_t *AXIS2_CALL +axis2_module_builder_process_ops( + axis2_module_builder_t * module_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr) +{ + axutil_array_list_t *ops = NULL; + + AXIS2_PARAM_CHECK(env->error, op_itr, NULL); + + ops = axutil_array_list_create(env, 0); + while(axiom_children_qname_iterator_has_next(op_itr, env)) + { + axiom_element_t *op_element = NULL; + axiom_node_t *op_node = NULL; + axiom_attribute_t *op_name_att = NULL; + axiom_attribute_t *op_mep_att = NULL; + axutil_qname_t *qattname = NULL; + axis2_char_t *mep_url = NULL; + axis2_char_t *op_name = NULL; + axutil_qname_t *qopname = NULL; + axutil_qname_t *qmsgrecv = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qmep = NULL; + axiom_children_qname_iterator_t *params = NULL; + axiom_children_qname_iterator_t *modules = NULL; + axiom_element_t *recv_element = NULL; + axiom_node_t *recv_node = NULL; + axis2_phases_info_t *info = NULL; + axis2_op_t *op_desc = NULL; + axutil_qname_t *qpolicy = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + + op_node = (axiom_node_t *)axiom_children_qname_iterator_next(op_itr, env); + op_element = axiom_node_get_data_element(op_node, env); + /* getting operation name */ + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + op_name_att = axiom_element_get_attribute(op_element, env, qattname); + if(qattname) + { + axutil_qname_free(qattname, env); + } + + if(!op_name_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Operation name missing for module operation."); + return NULL; + } + qmep = axutil_qname_create(env, AXIS2_MEP, NULL, NULL); + op_mep_att = axiom_element_get_attribute(op_element, env, qmep); + if(qmep) + { + axutil_qname_free(qmep, env); + } + + if(op_mep_att) + { + mep_url = axiom_attribute_get_value(op_mep_att, env); + } + if(!mep_url) + { + /* Assuming in-out mep */ + op_desc = axis2_op_create_from_module(env); + } + else + { + op_desc = axis2_op_create_from_module(env); + axis2_op_set_msg_exchange_pattern(op_desc, env, mep_url); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "mep_url:%s", mep_url); + } + + op_name = axiom_attribute_get_value(op_name_att, env); + qopname = axutil_qname_create(env, op_name, NULL, NULL); + axis2_op_set_qname(op_desc, env, qopname); + if(qopname) + { + axutil_qname_free(qopname, env); + } + + /* Operation parameters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params = axiom_element_get_children_with_qname(op_element, env, qparamst, op_node); + if(qparamst) + { + axutil_qname_free(qparamst, env); + } + + axis2_desc_builder_process_params(module_builder->desc_builder, env, params, + axis2_op_get_param_container(op_desc, env), axis2_module_desc_get_param_container( + module_builder->module_desc, env)); + /* To process wsamapping */ + axis2_desc_builder_process_action_mappings(module_builder->desc_builder, env, op_node, + op_desc); + + /* To process REST params */ + axis2_desc_builder_process_rest_params(module_builder->desc_builder, env, op_node, op_desc); + + /* setting the policy_include */ + + desc = axis2_op_get_base(op_desc, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + /* processing .. elements */ + + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + if(itr) + { + axis2_process_policy_elements(env, AXIS2_MODULE_OPERATION_POLICY, itr, policy_include); + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + + /* setting the mep of the operation */ + + /* loading the message receivers */ + qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL); + recv_element = axiom_element_get_first_child_with_qname(op_element, env, qmsgrecv, op_node, + &recv_node); + if(qmsgrecv) + { + axutil_qname_free(qmsgrecv, env); + } + if(recv_element && NULL != recv_node) + { + axis2_msg_recv_t *msg_recv = NULL; + + msg_recv = axis2_desc_builder_load_msg_recv(module_builder-> desc_builder, env, + recv_element); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + } + else + { + axis2_msg_recv_t *msg_recv = NULL; + /* setting default message reciver */ + msg_recv = axis2_desc_builder_load_default_msg_recv(env); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + } + /* Process Module Refs */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + modules = axiom_element_get_children_with_qname(op_element, env, qmodulest, op_node); + if(qmodulest) + { + axutil_qname_free(qmodulest, env); + } + axis2_desc_builder_process_op_module_refs(module_builder->desc_builder, env, modules, + op_desc); + /* setting Operation phase */ + info = axis2_dep_engine_get_phases_info(axis2_desc_builder_get_dep_engine( + module_builder->desc_builder, env), env); + axis2_phases_info_set_op_phases(info, env, op_desc); + + /* adding operation */ + axutil_array_list_add(ops, env, op_desc); + } + return ops; +} + diff --git a/src/core/deployment/phases_info.c b/src/core/deployment/phases_info.c new file mode 100644 index 0000000..075fc8e --- /dev/null +++ b/src/core/deployment/phases_info.c @@ -0,0 +1,564 @@ +/* + * 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. + */ + +#include + +struct axis2_phases_info +{ + axutil_array_list_t *in_phases; + axutil_array_list_t *out_phases; + axutil_array_list_t *in_faultphases; + axutil_array_list_t *out_faultphases; + axutil_hash_t *op_in_phases; + axutil_hash_t *op_out_phases; + axutil_hash_t *op_in_faultphases; + axutil_hash_t *op_out_faultphases; + +}; + +AXIS2_EXTERN axis2_phases_info_t *AXIS2_CALL +axis2_phases_info_create( + const axutil_env_t * env) +{ + axis2_phases_info_t *phases_info = NULL; + + phases_info = (axis2_phases_info_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_phases_info_t)); + + if(!phases_info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)phases_info, 0, sizeof(axis2_phases_info_t)); + phases_info->op_in_phases = axutil_hash_make(env); + phases_info->op_out_phases = axutil_hash_make(env); + phases_info->op_in_faultphases = axutil_hash_make(env); + phases_info->op_out_faultphases = axutil_hash_make(env); + + return phases_info; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_phases_info_free( + axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + if(phases_info->in_phases) + { + axutil_array_list_free(phases_info->in_phases, env); + } + + if(phases_info->out_phases) + { + axutil_array_list_free(phases_info->out_phases, env); + } + + if(phases_info->in_faultphases) + { + axutil_array_list_free(phases_info->in_faultphases, env); + } + + if(phases_info->out_faultphases) + { + axutil_array_list_free(phases_info->out_faultphases, env); + } + + if(phases_info->op_in_phases) + { + axutil_hash_free(phases_info->op_in_phases, env); + } + + if(phases_info->op_out_phases) + { + axutil_hash_free(phases_info->op_out_phases, env); + } + + if(phases_info->op_in_faultphases) + { + axutil_hash_free(phases_info->op_in_faultphases, env); + } + + if(phases_info->op_out_faultphases) + { + axutil_hash_free(phases_info->op_out_faultphases, env); + } + + if(phases_info) + { + AXIS2_FREE(env->allocator, phases_info); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phases_info_set_in_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * in_phases) +{ + AXIS2_PARAM_CHECK(env->error, in_phases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->in_phases) + { + axutil_array_list_free(phases_info->in_phases, env); + } + + phases_info->in_phases = in_phases; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phases_info_set_out_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * out_phases) +{ + AXIS2_PARAM_CHECK(env->error, out_phases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->out_phases) + { + axutil_array_list_free(phases_info->out_phases, env); + phases_info->out_phases = NULL; + } + phases_info->out_phases = out_phases; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phases_info_set_in_faultphases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * in_faultphases) +{ + AXIS2_PARAM_CHECK(env->error, in_faultphases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->in_faultphases) + { + axutil_array_list_free(phases_info->in_faultphases, env); + phases_info->in_faultphases = NULL; + } + phases_info->in_faultphases = in_faultphases; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phases_info_set_out_faultphases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axutil_array_list_t * out_faultphases) +{ + AXIS2_PARAM_CHECK(env->error, out_faultphases, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + if(phases_info->out_faultphases) + { + axutil_array_list_free(phases_info->out_faultphases, env); + phases_info->out_faultphases = NULL; + } + phases_info->out_faultphases = out_faultphases; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_in_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->in_phases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_out_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->out_phases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_in_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->in_faultphases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_out_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + return phases_info->out_faultphases; +} + +/* Here we create the operation inflow as an array list and create phases for phases defined in + * inflow of axis2.xml and add them into the array list. + */ +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_op_in_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + struct axis2_phase *phase = NULL; + int i = 0; + int size = 0; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_in_phases = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + op_in_phases = axutil_array_list_create(env, 0); + if(!op_in_phases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + if(!phases_info->in_phases) + { + return op_in_phases; + } + + /* For each inflow phase name create a phase instance and add into the inflow. */ + size = axutil_array_list_size(phases_info->in_phases, env); + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->in_phases, env, i); + + if(!axutil_strcmp(AXIS2_PHASE_TRANSPORT_IN, phase_name) || !axutil_strcmp( + AXIS2_PHASE_PRE_DISPATCH, phase_name) || !axutil_strcmp(AXIS2_PHASE_DISPATCH, + phase_name) || !axutil_strcmp(AXIS2_PHASE_POST_DISPATCH, phase_name)) + { + /* We are not concerned here with system phases. */ + } + else + { + /* This is the cause for jira AXIS2C-624. As solution I create new + * phases for each operation specific flow making the operation + * the owner of the flow and the phases contained within it*/ + /*phase = axutil_hash_get(phases_info->op_in_phases, phase_name, + AXIS2_HASH_KEY_STRING); + if(!phase) + { + phase = axis2_phase_create(env, phase_name); + axutil_hash_set(phases_info->op_in_phases, phase_name, + AXIS2_HASH_KEY_STRING, phase); + } */ + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_in_phases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_in_phases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_in_phases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + axutil_array_list_free(op_in_phases, env); + op_in_phases = NULL; + return NULL; + } + } + } + + return op_in_phases; +} + +/* Here we create the operation outflow as an array list and create phases for phases defined in + * outflow of axis2.xml and add them into the array list. + */ +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_op_out_phases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + struct axis2_phase *phase = NULL; + int i = 0; + int size = 0; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_out_phases = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + if(phases_info->out_phases) + { + size = axutil_array_list_size(phases_info->out_phases, env); + } + + op_out_phases = axutil_array_list_create(env, 0); + if(!op_out_phases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->out_phases, env, i); + + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_out_phases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_out_phases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_out_phases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + + axutil_array_list_free(op_out_phases, env); + op_out_phases = NULL; + return NULL; + } + } + + return op_out_phases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_op_in_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + int i = 0; + int size = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_in_faultphases = NULL; + struct axis2_phase *phase = NULL; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + if(!phases_info->in_faultphases) + { + return NULL; + } + + size = axutil_array_list_size(phases_info->in_faultphases, env); + if(0 == size) + { + return NULL; + } + + op_in_faultphases = axutil_array_list_create(env, 0); + if(!op_in_faultphases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->in_faultphases, env, i); + + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_in_faultphases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_in_faultphases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_in_faultphases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + axutil_array_list_free(op_in_faultphases, env); + op_in_faultphases = NULL; + return NULL; + + } + } + + return op_in_faultphases; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_get_op_out_faultphases( + const axis2_phases_info_t * phases_info, + const axutil_env_t * env) +{ + int i = 0; + int size = 0; + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *phase_name = NULL; + axutil_array_list_t *op_out_faultphases = NULL; + struct axis2_phase *phase = NULL; + + AXIS2_PARAM_CHECK(env->error, phases_info, NULL); + + if(!phases_info->out_faultphases) + { + return NULL; + } + size = axutil_array_list_size(phases_info->out_faultphases, env); + + if(0 == size) + { + return NULL; + } + + op_out_faultphases = axutil_array_list_create(env, 0); + if(!op_out_faultphases) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + for(i = 0; i < size; i++) + { + phase_name = (axis2_char_t *)axutil_array_list_get(phases_info->out_faultphases, env, i); + phase = axis2_phase_create(env, phase_name); + status = axutil_array_list_add(op_out_faultphases, env, phase); + if(AXIS2_SUCCESS != status) + { + int i = 0; + int size = 0; + + axis2_phase_free(phase, env); + phase = NULL; + size = axutil_array_list_size(op_out_faultphases, env); + for(i = 0; i < size; i++) + { + phase = axutil_array_list_get(op_out_faultphases, env, i); + axis2_phase_free(phase, env); + phase = NULL; + } + axutil_array_list_free(op_out_faultphases, env); + op_out_faultphases = NULL; + return NULL; + + } + } + + return op_out_faultphases; +} + +/* + * Get user defined phase instances for each flow defined in axis2.xml in an array list and add it + * into operation. This is called service builder, module builder and service client to add phases + * into operations. + */ +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_phases_info_set_op_phases( + axis2_phases_info_t * phases_info, + const axutil_env_t * env, + axis2_op_t * op_desc) +{ + axis2_status_t status = AXIS2_FAILURE; + axutil_array_list_t *op_in_phases = NULL; + axutil_array_list_t *op_out_phases = NULL; + axutil_array_list_t *op_in_faultphases = NULL; + axutil_array_list_t *op_out_faultphases = NULL; + + AXIS2_PARAM_CHECK(env->error, op_desc, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE); + + op_in_phases = axis2_phases_info_get_op_in_phases(phases_info, env); + if(!op_in_phases) + { + status = AXIS2_ERROR_GET_STATUS_CODE(env->error); + /* op_in_phases cannot be NULL */ + return status; + } + + op_out_phases = axis2_phases_info_get_op_out_phases(phases_info, env); + if(!op_out_phases) + { + status = AXIS2_ERROR_GET_STATUS_CODE(env->error); + /* op_out_phases cannot be NULL */ + return status; + } + + op_in_faultphases = axis2_phases_info_get_op_in_faultphases(phases_info, env); + op_out_faultphases = axis2_phases_info_get_op_out_faultphases(phases_info, env); + + status = axis2_op_set_in_flow(op_desc, env, op_in_phases); + status = axis2_op_set_out_flow(op_desc, env, op_out_phases); + if(op_in_faultphases) + { + status = axis2_op_set_fault_in_flow(op_desc, env, op_in_faultphases); + } + + if(op_out_faultphases) + { + status = axis2_op_set_fault_out_flow(op_desc, env, op_out_faultphases); + } + + return status; +} + +AXIS2_EXTERN axutil_array_list_t *AXIS2_CALL +axis2_phases_info_copy_flow( + const axutil_env_t * env, + const axutil_array_list_t * flow_to_copy) +{ + int size = 0, i = 0; + + axutil_array_list_t *new_flow = NULL; + if(flow_to_copy) + { + size = axutil_array_list_size((axutil_array_list_t *)flow_to_copy, env); + } + + if(size > 0) + { + new_flow = axutil_array_list_create(env, 0); + if(!new_flow) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + } + + for(i = 0; i < size; i++) + { + void *item = axutil_array_list_get((axutil_array_list_t *)flow_to_copy, env, i); + axis2_phase_increment_ref((axis2_phase_t *)item, env); + axutil_array_list_add(new_flow, env, item); + } + + return new_flow; +} + diff --git a/src/core/deployment/repos_listener.c b/src/core/deployment/repos_listener.c new file mode 100644 index 0000000..1df1325 --- /dev/null +++ b/src/core/deployment/repos_listener.c @@ -0,0 +1,398 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_repos_listener +{ + + /** + * Referance to a ws info list + */ + axis2_ws_info_list_t *info_list; + + /** + * The parent directory of the modules and services directories + * that the listener should listen + */ + axis2_char_t *folder_name; + axis2_conf_t *conf; +}; + +static axis2_status_t +axis2_repos_listener_search( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env, + axis2_char_t * folder_name, + int type); + +AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL +axis2_repos_listener_create( + const axutil_env_t * env) +{ + axis2_repos_listener_t *repos_listener = NULL; + + repos_listener = (axis2_repos_listener_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_repos_listener_t)); + + if(!repos_listener) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + repos_listener->folder_name = NULL; + repos_listener->info_list = NULL; + repos_listener->folder_name = AXIS2_FALSE; + + return repos_listener; +} + +/** + * This constructor take two argumnets, folder name and referance to + * deployment engine. Fisrt it initilize the sysetm , by loading all the + * modules in the /modules directory and also create a ws info list to + * keep info about available modules and services. + * @param folderName path to parent directory that the repos_listener + * should listens + * @param deploy_engine refearnce to engine registry inorder to + * inform the updates + */ + +AXIS2_EXTERN axis2_repos_listener_t *AXIS2_CALL +axis2_repos_listener_create_with_folder_name_and_dep_engine( + const axutil_env_t * env, + axis2_char_t * folder_name, + axis2_dep_engine_t * dep_engine) +{ + axis2_repos_listener_t *repos_listener = NULL; + axis2_status_t status = AXIS2_FAILURE; + + axis2_conf_t *conf; + axis2_bool_t file_flag; + + repos_listener = (axis2_repos_listener_t *)axis2_repos_listener_create(env); + + if(!repos_listener) + { + return NULL; + } + + file_flag = axis2_dep_engine_get_file_flag(dep_engine, env); + + if(!file_flag) + { + repos_listener->folder_name = axutil_strdup(env, folder_name); + if(!repos_listener->folder_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + } + + repos_listener->info_list = axis2_ws_info_list_create_with_dep_engine(env, dep_engine); + if(!repos_listener->info_list) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating ws info list failed"); + return NULL; + } + + /* Here dep_engine's conf will set to repo_listner. Then we could get + * details of the axis2.xml through axis2 configuration. + */ + + conf = axis2_dep_engine_get_axis_conf(dep_engine, env); + if(!conf) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Deployment engines axis2 configuration not available"); + + return NULL; + } + axis2_repos_listener_set_conf(repos_listener, env, conf); + + status = axis2_repos_listener_init(repos_listener, env); + if(AXIS2_SUCCESS != status) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPOS_LISTENER_INIT_FAILED, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Repository listener initialization failed"); + + return NULL; + } + return repos_listener; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_repos_listener_free( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + if(!repos_listener) + return; + + if(repos_listener->folder_name) + { + AXIS2_FREE(env->allocator, repos_listener->folder_name); + } + + if(repos_listener->info_list) + { + axis2_ws_info_list_free(repos_listener->info_list, env); + } + + AXIS2_FREE(env->allocator, repos_listener); + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_check_modules( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + axis2_char_t *module_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_bool_t axis2_flag = AXIS2_FALSE; + axis2_conf_t *conf; + + axutil_param_t *module_param; + axis2_char_t *module_dir; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + + conf = axis2_repos_listener_get_conf(repos_listener, env); + + /* Configuration is needed only to decide we are using axis2.xml. Other + * case we don't need. Hence even if conf is NULL we can continue. + */ + + if(conf) + { + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + } + + if(!axis2_flag) + { + + temp_path = axutil_stracat(env, repos_listener->folder_name, AXIS2_PATH_SEP_STR); + module_path = axutil_stracat(env, temp_path, AXIS2_MODULE_PATH); + AXIS2_FREE(env->allocator, temp_path); + } + else + { + module_param = axis2_conf_get_param(conf, env, AXIS2_MODULE_DIR); + if(module_param) + { + module_dir = (axis2_char_t *)axutil_param_get_value(module_param, env); + module_path = axutil_strdup(env, module_dir); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "While creating axis2 configuration using " + "axis2.xml, modulesDir parameter not available."); + } + + } + + status = axis2_repos_listener_search(repos_listener, env, module_path, AXIS2_MODULE); + + AXIS2_FREE(env->allocator, module_path); + + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_check_svcs( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + axis2_char_t *svc_path = NULL; + axis2_char_t *temp_path = NULL; + axis2_status_t status = AXIS2_FAILURE; + + axis2_conf_t *conf; + axis2_bool_t axis2_flag = AXIS2_FALSE; + + axutil_param_t *svc_param; + axis2_char_t *svc_dir; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + + conf = axis2_repos_listener_get_conf(repos_listener, env); + + if(conf) + axis2_flag = axis2_conf_get_axis2_flag(conf, env); + + if(!axis2_flag) + { + temp_path = axutil_stracat(env, repos_listener->folder_name, AXIS2_PATH_SEP_STR); + svc_path = axutil_stracat(env, temp_path, AXIS2_SVC_PATH); + AXIS2_FREE(env->allocator, temp_path); + } + else + { + svc_param = axis2_conf_get_param(conf, env, AXIS2_SERVICE_DIR); + if(svc_param) + { + svc_dir = axutil_param_get_value(svc_param, env); + svc_path = axutil_strdup(env, svc_dir); + } + else + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "While creating axis2 configuration using axis2.xml, servicesDir" + " parameter not available."); + } + } + + status = axis2_repos_listener_search(repos_listener, env, svc_path, AXIS2_SVC); + AXIS2_FREE(env->allocator, svc_path); + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_update( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + return axis2_ws_info_list_update(repos_listener->info_list, env); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_init( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + + status = axis2_ws_info_list_init(repos_listener->info_list, env); + if(AXIS2_SUCCESS != status) + { + return status; + } + /* if check_modules return AXIS2_FAILURE that means + * there are no modules to load + */ + axis2_repos_listener_check_modules(repos_listener, env); + + /* if check_svcs return AXIS2_FAILURE that means + * there are no services to load + */ + axis2_repos_listener_check_svcs(repos_listener, env); + return axis2_repos_listener_update(repos_listener, env); +} + +/** + * Folder name could be a repository modules or services folder. If it is modules + * folder then current_info_list contain the list of axis2 files corresponding to + * the modules within it. For services folder it should be understood similarly. + */ +static axis2_status_t +axis2_repos_listener_search( + axis2_repos_listener_t * repos_listener, + const axutil_env_t * env, + axis2_char_t * folder_name, + int type) +{ + int size = 0; + int i = 0; + axutil_array_list_t *current_info_list = NULL; + axis2_status_t status = AXIS2_FAILURE; + + AXIS2_PARAM_CHECK(env->error, repos_listener, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, folder_name, AXIS2_FAILURE); + current_info_list = axutil_dir_handler_list_service_or_module_dirs(env, folder_name); + if(!current_info_list) + { + axis2_status_t status_code = AXIS2_FAILURE; + + status_code = AXIS2_ERROR_GET_STATUS_CODE(env->error); + if(AXIS2_SUCCESS != status) + { + return status; + } + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "No %s in the folder.", folder_name); + return AXIS2_SUCCESS; + } + + size = axutil_array_list_size(current_info_list, env); + + for(i = 0; i < size; i++) /* Loop until empty */ + { + axutil_file_t *file = NULL; + file = axutil_array_list_get(current_info_list, env, i); + status = axis2_ws_info_list_add_ws_info_item(repos_listener->info_list, env, file, type); + if(AXIS2_SUCCESS != status) + { + int size_j = 0; + int j = 0; + axis2_char_t* file_name = axutil_file_get_name(file, env); + + size_j = axutil_array_list_size(current_info_list, env); + for(j = 0; j < size_j; j++) + { + axutil_file_t *del_file = NULL; + + del_file = axutil_array_list_get(current_info_list, env, j); + axutil_file_free(del_file, env); + } + axutil_array_list_free(current_info_list, env); + current_info_list = NULL; + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding file %s to ws info list failed", + file_name); + return status; + } + } + + for(i = 0; i < size; i++) + { + axutil_file_t *del_file = NULL; + + del_file = axutil_array_list_get(current_info_list, env, i); + axutil_file_free(del_file, env); + } + axutil_array_list_free(current_info_list, env); + current_info_list = NULL; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_repos_listener_set_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env, + axis2_conf_t *conf) +{ + AXIS2_PARAM_CHECK(env->error, repo_listener, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE); + repo_listener->conf = conf; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_conf_t *AXIS2_CALL +axis2_repos_listener_get_conf( + axis2_repos_listener_t *repo_listener, + const axutil_env_t * env) +{ + AXIS2_PARAM_CHECK(env->error, repo_listener, NULL); + return repo_listener->conf; +} + diff --git a/src/core/deployment/svc_builder.c b/src/core/deployment/svc_builder.c new file mode 100644 index 0000000..7f55fb6 --- /dev/null +++ b/src/core/deployment/svc_builder.c @@ -0,0 +1,840 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include + +struct axis2_svc_builder +{ + axis2_svc_t *svc; + struct axis2_desc_builder *desc_builder; +}; + +static axutil_array_list_t * +axis2_svc_builder_process_ops( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr); + +static void +axis2_svc_builder_process_msgs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * iterator, + axis2_op_t * op); + +AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL +axis2_svc_builder_create( + const axutil_env_t * env) +{ + axis2_svc_builder_t *svc_builder = NULL; + + svc_builder = (axis2_svc_builder_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_svc_builder_t)); + + if(!svc_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory. Allocation to svc_builder failed"); + return NULL; + } + + svc_builder->desc_builder = NULL; + svc_builder->svc = NULL; + + return svc_builder; +} + +AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL +axis2_svc_builder_create_with_file_and_dep_engine_and_svc( + const axutil_env_t * env, + axis2_char_t * file_name, + struct axis2_dep_engine * dep_engine, + axis2_svc_t * svc) +{ + axis2_svc_builder_t *svc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + AXIS2_PARAM_CHECK(env->error, svc, NULL); + svc_builder = (axis2_svc_builder_t *)axis2_svc_builder_create(env); + if(!svc_builder) + { + return NULL; + } + svc_builder->desc_builder = axis2_desc_builder_create_with_file_and_dep_engine(env, file_name, + dep_engine); + if(!svc_builder->desc_builder) + { + axis2_svc_builder_free(svc_builder, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating description builder for service builder %s failed", file_name); + return NULL; + } + svc_builder->svc = svc; + return svc_builder; +} + +AXIS2_EXTERN axis2_svc_builder_t *AXIS2_CALL +axis2_svc_builder_create_with_dep_engine_and_svc( + const axutil_env_t * env, + axis2_dep_engine_t * dep_engine, + axis2_svc_t * svc) +{ + axis2_svc_builder_t *svc_builder = NULL; + + AXIS2_PARAM_CHECK(env->error, dep_engine, NULL); + AXIS2_PARAM_CHECK(env->error, svc, NULL); + svc_builder = (axis2_svc_builder_t *)axis2_svc_builder_create(env); + if(!svc_builder) + { + return NULL; + } + svc_builder->desc_builder = axis2_desc_builder_create_with_dep_engine(env, dep_engine); + if(!svc_builder->desc_builder) + { + axis2_svc_builder_free(svc_builder, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Creating description builder for service builder failed"); + return NULL; + } + svc_builder->svc = svc; + return svc_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_builder_free( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env) +{ + if(svc_builder->desc_builder) + { + axis2_desc_builder_free(svc_builder->desc_builder, env); + } + + svc_builder->svc = NULL; + + if(svc_builder) + { + AXIS2_FREE(env->allocator, svc_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_builder_populate_svc( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_node_t * svc_node) +{ + axiom_element_t *svc_element = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *operation_itr = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qdesc = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qinflowst = NULL; + axutil_qname_t *qoutflowst = NULL; + axutil_qname_t *qin_faultflowst = NULL; + axutil_qname_t *qout_faultflowst = NULL; + axutil_qname_t *qopst = NULL; + axutil_qname_t *qattname = NULL; + axutil_qname_t *qpolicy = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_svc_grp_t *parent = NULL; + axiom_element_t *desc_element = NULL; + axiom_node_t *desc_node = NULL; + axiom_children_qname_iterator_t *module_refs = NULL; + axiom_node_t *in_flow_node = NULL; + axiom_element_t *in_flow_element = NULL; + axiom_node_t *out_flow_node = NULL; + axiom_element_t *out_flow_element = NULL; + axiom_node_t *in_faultflow_node = NULL; + axiom_element_t *in_faultflow_element = NULL; + axiom_node_t *out_faultflow_node = NULL; + axiom_element_t *out_faultflow_element = NULL; + axiom_attribute_t *name_attr = NULL; + axutil_array_list_t *ops = NULL; + axis2_char_t *svc_name = NULL; + axis2_char_t *class_name = NULL; + axis2_char_t *svc_dll_name = NULL; + axutil_dll_desc_t *dll_desc = NULL; + axutil_param_t *impl_info_param = NULL; + axutil_param_t *wsdl_path_param = NULL; + axis2_char_t *wsdl_path = NULL; + axis2_arch_file_data_t *arch_file_data = NULL; + axutil_file_t *svc_folder = NULL; + axis2_char_t *dll_path = NULL; + axis2_char_t *svc_folder_path = NULL; + int i = 0; + int size = 0; + AXIS2_TIME_T timestamp = 0; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + axutil_qname_t *qname_addressing = NULL; + axis2_bool_t addressing_engaged = AXIS2_FALSE; + axutil_array_list_t *svc_module_qnames = NULL; + int svc_module_qname_size = 0; + + AXIS2_PARAM_CHECK(env->error, svc_node, AXIS2_FAILURE); + + svc_element = axiom_node_get_data_element(svc_node, env); + /* Processing service level paramters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + if(!qparamst) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "No memory"); + return AXIS2_FAILURE; + } + itr = axiom_element_get_children_with_qname(svc_element, env, qparamst, svc_node); + axutil_qname_free(qparamst, env); + qparamst = NULL; + + parent = axis2_svc_get_parent(svc_builder->svc, env); + + desc = axis2_svc_get_base(svc_builder->svc, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + status = axis2_desc_builder_process_params(svc_builder->desc_builder, env, itr, + axis2_svc_get_param_container(svc_builder->svc, env), axis2_svc_grp_get_param_container( + parent, env)); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing parameters failed"); + return status; + } + + /* process service description */ + qdesc = axutil_qname_create(env, AXIS2_DESCRIPTION, NULL, NULL); + desc_element = axiom_element_get_first_child_with_qname(svc_element, env, qdesc, svc_node, + &desc_node); + axutil_qname_free(qdesc, env); + qdesc = NULL; + if(desc_element) + { + axiom_element_t *desc_value_element = NULL; + axiom_node_t *desc_value_node = NULL; + axis2_char_t *description_text = NULL; + + desc_value_element = axiom_element_get_first_element(desc_element, env, desc_node, + &desc_value_node); + description_text = axiom_element_get_text(desc_element, env, desc_node); + if(description_text) + { + axis2_svc_set_svc_desc(svc_builder->svc, env, description_text); + } + } + + /* wsdl path */ + wsdl_path_param = axutil_param_container_get_param(axis2_svc_get_param_container( + svc_builder->svc, env), env, AXIS2_SVC_WSDL_PATH); + + if(wsdl_path_param) + { + wsdl_path = axutil_param_get_value(wsdl_path_param, env); + } + + if(wsdl_path) + { + axis2_svc_set_svc_wsdl_path(svc_builder->svc, env, wsdl_path); + } + + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + name_attr = axiom_element_get_attribute(svc_element, env, qattname); + svc_name = axiom_attribute_get_value(name_attr, env); + axis2_svc_set_name(svc_builder->svc, env, svc_name); + axutil_qname_free(qattname, env); + + /* create dll_desc and set it in a parameter. then set that param in param + * container taken from svc + */ + dll_desc = axutil_dll_desc_create(env); + impl_info_param = axutil_param_container_get_param(axis2_svc_get_param_container( + svc_builder->svc, env), env, AXIS2_SERVICE_CLASS); + if(!impl_info_param) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "%s parameter not found", AXIS2_SERVICE_CLASS); + return AXIS2_FAILURE; + } + class_name = axutil_strtrim(env, axutil_param_get_value(impl_info_param, env), NULL); + svc_dll_name = axutil_dll_desc_create_platform_specific_dll_name(dll_desc, env, class_name); + + if(class_name) + { + AXIS2_FREE(env->allocator, class_name); + class_name = NULL; + } + + arch_file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( + svc_builder->desc_builder, env), env); + svc_folder = axis2_arch_file_data_get_file(arch_file_data, env); + timestamp = axutil_file_get_timestamp(svc_folder, env); + axutil_dll_desc_set_timestamp(dll_desc, env, timestamp); + svc_folder_path = axutil_file_get_path(svc_folder, env); + axis2_svc_set_svc_folder_path(svc_builder->svc, env, svc_folder_path); + dll_path = axutil_strcat(env, svc_folder_path, AXIS2_PATH_SEP_STR, svc_dll_name, NULL); + AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "DLL path is : %s", dll_path); + status = axutil_dll_desc_set_name(dll_desc, env, dll_path); + if(AXIS2_SUCCESS != status) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting name to %s dll description failed", + dll_path); + return status; + } + AXIS2_FREE(env->allocator, dll_path); + dll_path = NULL; + + axutil_dll_desc_set_type(dll_desc, env, AXIS2_SVC_DLL); + status = axutil_param_set_value(impl_info_param, env, dll_desc); + axutil_param_set_value_free(impl_info_param, env, axutil_dll_desc_free_void_arg); + if(AXIS2_SUCCESS != status) + { + axutil_dll_desc_free(dll_desc, env); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Setting dll_desc to parameter %s failed", + class_name); + return status; + } + /* processing service wide modules which required to engage globally */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_refs = axiom_element_get_children_with_qname(svc_element, env, qmodulest, svc_node); + axutil_qname_free(qmodulest, env); + qmodulest = NULL; + status = axis2_svc_builder_process_module_refs(svc_builder, env, module_refs); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Processing module references failed"); + return status; + } + + if(!addressing_engaged) + { + svc_module_qnames = axis2_svc_get_all_module_qnames(svc_builder->svc, env); + if(svc_module_qnames) + { + svc_module_qname_size = axutil_array_list_size(svc_module_qnames, env); + qname_addressing = axutil_qname_create(env, AXIS2_MODULE_ADDRESSING, NULL, NULL); + for(i = 0; i < svc_module_qname_size; i++) + { + if(axutil_qname_equals(axutil_array_list_get(svc_module_qnames, env, i), env, + qname_addressing)) + { + addressing_engaged = AXIS2_TRUE; + break; + } + } + axutil_qname_free(qname_addressing, env); + } + svc_module_qnames = NULL; + } + + /* process IN_FLOW */ + qinflowst = axutil_qname_create(env, AXIS2_IN_FLOW_START, NULL, NULL); + in_flow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qinflowst, svc_node, &in_flow_node); + axutil_qname_free(qinflowst, env); + qinflowst = NULL; + + qoutflowst = axutil_qname_create(env, AXIS2_OUT_FLOW_START, NULL, NULL); + out_flow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qoutflowst, svc_node, &out_flow_node); + axutil_qname_free(qoutflowst, env); + qoutflowst = NULL; + + qin_faultflowst = axutil_qname_create(env, AXIS2_IN_FAILTFLOW, NULL, NULL); + in_faultflow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qin_faultflowst, svc_node, &in_faultflow_node); + axutil_qname_free(qin_faultflowst, env); + qin_faultflowst = NULL; + + qout_faultflowst = axutil_qname_create(env, AXIS2_OUT_FAILTFLOW, NULL, NULL); + out_faultflow_element = axiom_element_get_first_child_with_qname( + svc_element, env, qout_faultflowst, svc_node, &out_faultflow_node); + axutil_qname_free(qout_faultflowst, env); + qout_faultflowst = NULL; + + /* processing operations */ + qopst = axutil_qname_create(env, AXIS2_OPERATIONST, NULL, NULL); + operation_itr = axiom_element_get_children_with_qname(svc_element, env, qopst, svc_node); + axutil_qname_free(qopst, env); + qopst = NULL; + ops = axis2_svc_builder_process_ops(svc_builder, env, operation_itr); + if(ops) + { + size = axutil_array_list_size(ops, env); + } + for(i = 0; i < size; i++) + { + axis2_op_t *op_desc = NULL; + axutil_array_list_t *params = NULL; + int j = 0; + int sizej = 0; + + op_desc = (axis2_op_t *)axutil_array_list_get(ops, env, i); + if(addressing_engaged) + { + params = axis2_op_get_all_params(op_desc, env); + /* Adding wsa-mapping into service */ + sizej = axutil_array_list_size(params, env); + for(j = 0; j < sizej; j++) + { + axutil_param_t *param = NULL; + axis2_char_t *param_name = NULL; + + param = axutil_array_list_get(params, env, j); + param_name = axutil_param_get_name(param, env); + if(0 == axutil_strcmp(param_name, AXIS2_WSA_MAPPING)) + { + axis2_char_t *key = NULL; + + key = (axis2_char_t *)axutil_param_get_value(param, env); + axis2_svc_add_mapping(svc_builder->svc, env, key, op_desc); + } + } + } + axis2_svc_add_op(svc_builder->svc, env, op_desc); + if(axis2_op_get_rest_http_method(op_desc, env) && axis2_op_get_rest_http_location(op_desc, + env)) + { + axis2_svc_add_rest_mapping(svc_builder->svc, env, axis2_op_get_rest_http_method( + op_desc, env), axis2_op_get_rest_http_location(op_desc, env), op_desc); + } + } + axutil_array_list_free(ops, env); + + /* + + setting the PolicyInclude + processing .. elements + */ + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include); + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(svc_element, env, qpolicy, svc_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + + return AXIS2_SUCCESS; +} + +static axutil_array_list_t * +axis2_svc_builder_process_ops( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * op_itr) +{ + axutil_array_list_t *ops = NULL; + + AXIS2_PARAM_CHECK(env->error, op_itr, NULL); + + ops = axutil_array_list_create(env, 0); + while(AXIS2_TRUE == axiom_children_qname_iterator_has_next(op_itr, env)) + { + axiom_element_t *op_element = NULL; + axiom_node_t *op_node = NULL; + axiom_attribute_t *op_name_att = NULL; + axiom_attribute_t *op_mep_att = NULL; + axutil_qname_t *qmep = NULL; + axutil_qname_t *qopname = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmsgrecv = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qattname = NULL; + axis2_char_t *mep_url = NULL; + axis2_char_t *op_name = NULL; + axis2_op_t *op_desc = NULL; + axiom_children_qname_iterator_t *params_itr = NULL; + axiom_children_qname_iterator_t *module_itr = NULL; + axiom_element_t *recv_element = NULL; + axiom_node_t *recv_node = NULL; + axis2_status_t status = AXIS2_FAILURE; + struct axis2_dep_engine *dep_engine = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *qpolicy = NULL; + axutil_qname_t *qmessage = NULL; + + op_node = axiom_children_qname_iterator_next(op_itr, env); + /* getting operation name */ + op_element = axiom_node_get_data_element(op_node, env); + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + op_name_att = axiom_element_get_attribute(op_element, env, qattname); + axutil_qname_free(qattname, env); + qattname = NULL; + if(!op_name_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_OP_NAME_MISSING, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, ""); + return NULL; + } + + op_name = axiom_attribute_get_value(op_name_att, env); + qopname = axutil_qname_create(env, op_name, NULL, NULL); + op_desc = axis2_op_create(env); + axis2_op_set_qname(op_desc, env, qopname); + axutil_qname_free(qopname, env); + qopname = NULL; + + /* set the mep of the operation */ + qmep = axutil_qname_create(env, AXIS2_MEP, NULL, NULL); + op_mep_att = axiom_element_get_attribute(op_element, env, qmep); + axutil_qname_free(qmep, env); + qmep = NULL; + op_name = axiom_attribute_get_value(op_name_att, env); + + if(op_mep_att) + { + mep_url = axiom_attribute_get_value(op_mep_att, env); + if(mep_url) + { + axis2_op_set_msg_exchange_pattern(op_desc, env, mep_url); + } + } + + desc = axis2_op_get_base(op_desc, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + /* operation parameters */ + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params_itr = axiom_element_get_children_with_qname(op_element, env, qparamst, op_node); + axutil_qname_free(qparamst, env); + qparamst = NULL; + status = axis2_desc_builder_process_params(svc_builder->desc_builder, env, params_itr, + axis2_op_get_param_container(op_desc, env), axis2_svc_get_param_container( + svc_builder->svc, env)); + /* To process wsamapping */ + axis2_desc_builder_process_action_mappings(svc_builder->desc_builder, env, op_node, op_desc); + + /* To process REST params */ + axis2_desc_builder_process_rest_params(svc_builder->desc_builder, env, op_node, op_desc); + + /* loading the message receivers */ + qmsgrecv = axutil_qname_create(env, AXIS2_MESSAGERECEIVER, NULL, NULL); + recv_element = axiom_element_get_first_child_with_qname(op_element, env, qmsgrecv, op_node, + &recv_node); + axutil_qname_free(qmsgrecv, env); + qmsgrecv = NULL; + if(recv_element && NULL != recv_node) + { + axis2_msg_recv_t *msg_recv = NULL; + msg_recv = axis2_desc_builder_load_msg_recv(svc_builder->desc_builder, env, + recv_element); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + + } + else + { + axis2_msg_recv_t *msg_recv = NULL; + /* setting the default message receiver */ + msg_recv = axis2_desc_builder_load_default_msg_recv(env); + axis2_op_set_msg_recv(op_desc, env, msg_recv); + } + /* process module refs */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_itr = axiom_element_get_children_with_qname(op_element, env, qmodulest, op_node); + axutil_qname_free(qmodulest, env); + qmodulest = NULL; + status = axis2_desc_builder_process_op_module_refs(svc_builder-> desc_builder, env, + module_itr, op_desc); + if(AXIS2_SUCCESS != status) + { + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Processing module operation references failed for operation %s", op_name); + return NULL; + } + + /* setting the policy_include */ + + /* processing .. elements */ + + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include); + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qpolicy, op_node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + + qmessage = axutil_qname_create(env, AXIS2_MESSAGE, NULL, NULL); + itr = axiom_element_get_children_with_qname(op_element, env, qmessage, op_node); + axutil_qname_free(qmessage, env); + qmessage = NULL; + + if(itr) + { + axis2_svc_builder_process_msgs(svc_builder, env, itr, op_desc); + } + + /* setting operation phase */ + dep_engine = axis2_desc_builder_get_dep_engine(svc_builder->desc_builder, env); + if(dep_engine) + { + axis2_phases_info_t *info = axis2_dep_engine_get_phases_info(dep_engine, env); + axis2_phases_info_set_op_phases(info, env, op_desc); + } + + /* adding operation */ + status = axutil_array_list_add(ops, env, op_desc); + } + + return ops; +} + +static void +axis2_svc_builder_process_msgs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * iterator, + axis2_op_t * op) +{ + while(axiom_children_qname_iterator_has_next(iterator, env)) + { + axiom_node_t *node = NULL; + axiom_element_t *element = NULL; + axutil_qname_t *qname = NULL; + axis2_char_t *msg_label = NULL; + axis2_msg_t *msg = NULL; + axiom_children_qname_iterator_t *itr = NULL; + axutil_qname_t *qpolicy = NULL; + axis2_desc_t *desc = NULL; + axis2_policy_include_t *policy_include = NULL; + + node = axiom_children_qname_iterator_next(iterator, env); + element = axiom_node_get_data_element(node, env); + qname = axutil_qname_create(env, AXIS2_LABEL, NULL, NULL); + + if(element) + { + msg_label = axiom_element_get_attribute_value(element, env, qname); + } + + if(msg_label) + { + msg = axis2_op_get_msg(op, env, msg_label); + } + + if(msg) + { + /* operation parameters */ + axiom_children_qname_iterator_t *params_itr = NULL; + axutil_qname_t *qparamst = NULL; + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + params_itr = axiom_element_get_children_with_qname(element, env, qparamst, node); + axutil_qname_free(qparamst, env); + qparamst = NULL; + axis2_desc_builder_process_params(svc_builder->desc_builder, env, params_itr, + axis2_msg_get_param_container(msg, env), axis2_op_get_param_container(op, env)); + + desc = axis2_msg_get_base(msg, env); + policy_include = axis2_desc_get_policy_include(desc, env); + + /* setting the policy_include */ + + /* processing .. elements */ + + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_POLICY, NEETHI_POLICY_15_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_elements(env, AXIS2_SERVICE_POLICY, itr, policy_include); + /* axis2_process_policy_elements(env, AXIS2_MESSAGE_POLICY, itr, + policy_include); */ + + } + + /* processing .. elements */ + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_NAMESPACE, NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + + if((!itr) || (!axiom_children_qname_iterator_has_next(itr, env))) + { + qpolicy = axutil_qname_create(env, NEETHI_REFERENCE, NEETHI_POLICY_15_NAMESPACE, + NULL); + itr = axiom_element_get_children_with_qname(element, env, qpolicy, node); + axutil_qname_free(qpolicy, env); + qpolicy = NULL; + } + + if(itr) + { + axis2_process_policy_reference_elements(env, AXIS2_POLICY_REF, itr, policy_include); + } + } + } +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_builder_process_svc_module_conf( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_confs, + axutil_param_container_t * parent, + axis2_svc_t * svc) +{ + while(axiom_children_qname_iterator_has_next(module_confs, env)) + { + axiom_element_t *module_conf_element = NULL; + axiom_node_t *module_conf_node = NULL; + axiom_attribute_t *module_name_att = NULL; + axutil_qname_t *qattname = NULL; + + module_conf_node = axiom_children_qname_iterator_next(module_confs, env); + module_conf_element = axiom_node_get_data_element(module_conf_node, env); + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + module_name_att = axiom_element_get_attribute(module_conf_element, env, qattname); + axutil_qname_free(qattname, env); + qattname = NULL; + if(!module_name_att) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE_CONF, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module name attribute not found for module node"); + return AXIS2_FAILURE; + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_builder_process_module_refs( + axis2_svc_builder_t * svc_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs) +{ + AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_element_t *module_ref_element = NULL; + axiom_node_t *module_ref_node = NULL; + axiom_attribute_t *module_ref_att = NULL; + axutil_qname_t *qref = NULL; + + module_ref_node = axiom_children_qname_iterator_next(module_refs, env); + module_ref_element = axiom_node_get_data_element(module_ref_node, env); + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref); + axutil_qname_free(qref, env); + if(module_ref_att) + { + axis2_char_t *ref_name = NULL; + axutil_qname_t *qrefname = NULL; + + ref_name = axiom_attribute_get_value(module_ref_att, env); + qrefname = axutil_qname_create(env, ref_name, NULL, NULL); + if(!axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine( + svc_builder->desc_builder, env), env, qrefname)) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Unable to find " + "Module %s, in Service %s", ref_name, axis2_svc_get_name(svc_builder->svc, env)); + return AXIS2_FAILURE; + } + else + { + axis2_svc_add_module_qname(svc_builder->svc, env, qrefname); + } + axutil_qname_free(qrefname, env); + } + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN struct axis2_desc_builder *AXIS2_CALL +axis2_svc_builder_get_desc_builder( + const axis2_svc_builder_t * svc_builder, + const axutil_env_t * env) +{ + return svc_builder->desc_builder; +} + diff --git a/src/core/deployment/svc_grp_builder.c b/src/core/deployment/svc_grp_builder.c new file mode 100644 index 0000000..6aa07ad --- /dev/null +++ b/src/core/deployment/svc_grp_builder.c @@ -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. + */ + +#include + +struct axis2_svc_grp_builder +{ + axiom_node_t *svc_grp; + axis2_desc_builder_t *desc_builder; +}; + +AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL +axis2_svc_grp_builder_create( + const axutil_env_t * env) +{ + axis2_svc_grp_builder_t *svc_grp_builder = NULL; + + AXIS2_ENV_CHECK(env, NULL); + + svc_grp_builder = (axis2_svc_grp_builder_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_svc_grp_builder_t)); + + if(!svc_grp_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + svc_grp_builder->svc_grp = NULL; + svc_grp_builder->desc_builder = NULL; + + return svc_grp_builder; +} + +AXIS2_EXTERN axis2_svc_grp_builder_t *AXIS2_CALL +axis2_svc_grp_builder_create_with_svc_and_dep_engine( + const axutil_env_t * env, + axiom_node_t * svc_grp, + axis2_dep_engine_t * dep_engine) +{ + axis2_svc_grp_builder_t *svc_grp_builder = NULL; + + svc_grp_builder = (axis2_svc_grp_builder_t *)axis2_svc_grp_builder_create(env); + if(!svc_grp_builder) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + svc_grp_builder = NULL; + } + svc_grp_builder->desc_builder = axis2_desc_builder_create_with_dep_engine(env, dep_engine); + if(!svc_grp_builder->desc_builder) + { + axis2_svc_grp_builder_free(svc_grp_builder, env); + return NULL; + } + svc_grp_builder->svc_grp = svc_grp; + + return svc_grp_builder; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_svc_grp_builder_free( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env) +{ + if(svc_grp_builder->desc_builder) + { + axis2_desc_builder_free(svc_grp_builder->desc_builder, env); + } + if(svc_grp_builder) + { + AXIS2_FREE(env->allocator, svc_grp_builder); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_builder_populate_svc_grp( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env, + axis2_svc_grp_t * svc_grp) +{ + axiom_children_qname_iterator_t *itr = NULL; + axiom_children_qname_iterator_t *module_ref_itr = NULL; + axiom_children_qname_iterator_t *svc_itr = NULL; + axutil_qname_t *qparamst = NULL; + axutil_qname_t *qmodulest = NULL; + axutil_qname_t *qsvc_element = NULL; + axiom_element_t *svc_grp_element = NULL; + axis2_status_t status = AXIS2_FAILURE; + axis2_conf_t *parent = NULL; + + /* Processing service level paramters */ + svc_grp_element = axiom_node_get_data_element(svc_grp_builder->svc_grp, env); + qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); + + itr = axiom_element_get_children_with_qname(svc_grp_element, env, qparamst, + svc_grp_builder->svc_grp); + + if(qparamst) + { + axutil_qname_free(qparamst, env); + qparamst = NULL; + } + + parent = axis2_svc_grp_get_parent(svc_grp, env); + status = axis2_desc_builder_process_params(svc_grp_builder->desc_builder, env, itr, + axis2_svc_grp_get_param_container(svc_grp, env), + axis2_conf_get_param_container(parent, env)); + + /* Processing service modules required to be engaged globally */ + qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); + module_ref_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qmodulest, + svc_grp_builder-> svc_grp); + + if(qmodulest) + { + axutil_qname_free(qmodulest, env); + qmodulest = NULL; + } + + axis2_svc_grp_builder_process_module_refs(svc_grp_builder, env, module_ref_itr, svc_grp); + qsvc_element = axutil_qname_create(env, AXIS2_SVC_ELEMENT, NULL, NULL); + svc_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qsvc_element, + svc_grp_builder->svc_grp); + + if(qsvc_element) + { + axutil_qname_free(qsvc_element, env); + qsvc_element = NULL; + } + + while(axiom_children_qname_iterator_has_next(svc_itr, env)) + { + axiom_node_t *svc_node = NULL; + axiom_element_t *svc_element = NULL; + axiom_attribute_t *svc_name_att = NULL; + axis2_char_t *svc_name = NULL; + axutil_qname_t *qattname = NULL; + + svc_node = (axiom_node_t *)axiom_children_qname_iterator_next(svc_itr, env); + svc_element = axiom_node_get_data_element(svc_node, env); + qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); + svc_name_att = axiom_element_get_attribute(svc_element, env, qattname); + + if(qattname) + { + axutil_qname_free(qattname, env); + qattname = NULL; + } + + svc_name = axiom_attribute_get_value(svc_name_att, env); + if(!svc_name) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_NAME_ERROR, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service name attribute has no value"); + return AXIS2_FAILURE; + } + else + { + axis2_svc_t *axis_svc = NULL; + axis2_arch_file_data_t *file_data = NULL; + axutil_array_list_t *deployable_svcs = NULL; + axis2_svc_builder_t *svc_builder = NULL; + + file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( + svc_grp_builder->desc_builder, env), env); + axis_svc = axis2_arch_file_data_get_svc(file_data, env, svc_name); + if(!axis_svc) + { + axutil_qname_t *qsvc_name = NULL; + + qsvc_name = axutil_qname_create(env, svc_name, NULL, NULL); + axis_svc = axis2_svc_create_with_qname(env, qsvc_name); + axutil_qname_free(qsvc_name, env); + axis2_arch_file_data_add_svc(file_data, env, axis_svc); + + } + /* Adding service to the deployable services list */ + deployable_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env); + axutil_array_list_add(deployable_svcs, env, axis_svc); + axis2_svc_set_parent(axis_svc, env, svc_grp); + svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env, + axis2_desc_builder_get_dep_engine(svc_grp_builder-> desc_builder, env), axis_svc); + status = axis2_svc_builder_populate_svc(svc_builder, env, svc_node); + axis2_svc_builder_free(svc_builder, env); + + } + } + return status; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_svc_grp_builder_process_module_refs( + axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env, + axiom_children_qname_iterator_t * module_refs, + axis2_svc_grp_t * svc_grp) +{ + AXIS2_PARAM_CHECK(env->error, module_refs, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, svc_grp, AXIS2_FAILURE); + + while(axiom_children_qname_iterator_has_next(module_refs, env)) + { + axiom_node_t *module_ref_node = NULL; + axiom_element_t *module_ref_element = NULL; + axiom_attribute_t *module_ref_att = NULL; + axutil_qname_t *qref = NULL; + + module_ref_node = (axiom_node_t *)axiom_children_qname_iterator_next(module_refs, env); + module_ref_element = axiom_node_get_data_element(module_ref_node, env); + qref = axutil_qname_create(env, AXIS2_REF, NULL, NULL); + module_ref_att = axiom_element_get_attribute(module_ref_element, env, qref); + if(module_ref_att) + { + axis2_char_t *ref_name = NULL; + axutil_qname_t *qrefname = NULL; + axis2_module_desc_t *module = NULL; + + ref_name = axiom_attribute_get_value(module_ref_att, env); + qrefname = axutil_qname_create(env, ref_name, NULL, NULL); + module = axis2_dep_engine_get_module(axis2_desc_builder_get_dep_engine( + svc_grp_builder->desc_builder, env), env, qrefname); + if(!module) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_NOT_FOUND, AXIS2_FAILURE); + AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, + "Module %s not found in deployment engine.", ref_name); + return AXIS2_FAILURE; + } + else + { + axis2_svc_grp_add_module_ref(svc_grp, env, qrefname); + } + axutil_qname_free(qrefname, env); + } + axutil_qname_free(qref, env); + } + + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_desc_builder_t *AXIS2_CALL +axis2_svc_grp_builder_get_desc_builder( + const axis2_svc_grp_builder_t * svc_grp_builder, + const axutil_env_t * env) +{ + return svc_grp_builder->desc_builder; +} + diff --git a/src/core/deployment/ws_info.c b/src/core/deployment/ws_info.c new file mode 100644 index 0000000..0f2fa37 --- /dev/null +++ b/src/core/deployment/ws_info.c @@ -0,0 +1,158 @@ +/* + * 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. + */ + +#include "axis2_ws_info.h" +#include + +struct axis2_ws_info +{ + axis2_char_t *file_name; + long last_modified_date; + + /** + * To check whether the file is a module or a servise + */ + int type; +}; + +AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL +axis2_ws_info_create_with_file_name_and_last_modified_date( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date) +{ + axis2_ws_info_t *ws_info = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + ws_info = (axis2_ws_info_t *)AXIS2_MALLOC(env->allocator, sizeof(axis2_ws_info_t)); + + if(!ws_info) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ws_info->file_name = NULL; + ws_info->last_modified_date = 0; + ws_info->type = 0; + + ws_info->file_name = axutil_strdup(env, file_name); + if(!ws_info->file_name) + { + axis2_ws_info_free(ws_info, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ws_info->last_modified_date = last_modified_date; + + return ws_info; +} + +AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL +axis2_ws_info_create_with_file_name_and_last_modified_date_and_type( + const axutil_env_t * env, + axis2_char_t * file_name, + long last_modified_date, + int type) +{ + axis2_ws_info_t *ws_info = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + ws_info = (axis2_ws_info_t *)axis2_ws_info_create_with_file_name_and_last_modified_date(env, + file_name, last_modified_date); + if(!ws_info) + { + axis2_ws_info_free(ws_info, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + ws_info->type = type; + return ws_info; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_ws_info_free( + axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + if(ws_info->file_name) + { + AXIS2_FREE(env->allocator, ws_info->file_name); + } + + if(ws_info) + { + AXIS2_FREE(env->allocator, ws_info); + } + + return; +} + +AXIS2_EXTERN axis2_char_t *AXIS2_CALL +axis2_ws_info_get_file_name( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + return ws_info->file_name; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_set_file_name( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + + if(ws_info->file_name) + { + AXIS2_FREE(env->allocator, ws_info->file_name); + ws_info->file_name = NULL; + } + ws_info->file_name = file_name; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN long AXIS2_CALL +axis2_ws_info_get_last_modified_date( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + return ws_info->last_modified_date; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_set_last_modified_date( + axis2_ws_info_t * ws_info, + const axutil_env_t * env, + long last_modified_date) +{ + ws_info->last_modified_date = last_modified_date; + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN int AXIS2_CALL +axis2_ws_info_get_type( + const axis2_ws_info_t * ws_info, + const axutil_env_t * env) +{ + return ws_info->type; +} + diff --git a/src/core/deployment/ws_info_list.c b/src/core/deployment/ws_info_list.c new file mode 100644 index 0000000..41a85c7 --- /dev/null +++ b/src/core/deployment/ws_info_list.c @@ -0,0 +1,370 @@ +/* + * 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. + */ + +#include +#include +#include + +struct axis2_ws_info_list +{ + /** + * This is to store all the deployment info about the deployment files + * for services or modules in a specified folder. + */ + axutil_array_list_t *ws_info_list; + + /** + * All the curently updated deployment info list. + */ + axutil_array_list_t *current_info_list; + + /** + * Referance to deployment engine to make update. + */ + struct axis2_dep_engine *dep_engine; + +}; + +AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALL +axis2_ws_info_list_create_with_dep_engine( + const axutil_env_t * env, + struct axis2_dep_engine *dep_engine) +{ + axis2_ws_info_list_t *ws_info_list = NULL; + + ws_info_list = (axis2_ws_info_list_t *)AXIS2_MALLOC(env->allocator, + sizeof(axis2_ws_info_list_t)); + + if(!ws_info_list) + { + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + memset((void *)ws_info_list, 0, sizeof(axis2_ws_info_list_t)); + + ws_info_list->dep_engine = dep_engine; + + ws_info_list->ws_info_list = axutil_array_list_create(env, 0); + if(!(ws_info_list->ws_info_list)) + { + axis2_ws_info_list_free(ws_info_list, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + ws_info_list->current_info_list = axutil_array_list_create(env, 0); + if(!(ws_info_list->current_info_list)) + { + axis2_ws_info_list_free(ws_info_list, env); + AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE); + return NULL; + } + + return ws_info_list; +} + +AXIS2_EXTERN void AXIS2_CALL +axis2_ws_info_list_free( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + if(ws_info_list->current_info_list) + { + int list_size = 0; + int i = 0; + + list_size = axutil_array_list_size(ws_info_list->current_info_list, env); + for(i = 0; i < list_size; i++) + { + axis2_char_t *file_name = NULL; + + file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list->current_info_list, env, + i); + AXIS2_FREE(env->allocator, file_name); + } + axutil_array_list_free(ws_info_list->current_info_list, env); + } + + if(ws_info_list->ws_info_list) + { + int list_size = 0; + int i = 0; + + list_size = axutil_array_list_size(ws_info_list->ws_info_list, env); + for(i = 0; i < list_size; i++) + { + axis2_ws_info_t *ws_info = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); + axis2_ws_info_free(ws_info, env); + } + axutil_array_list_free(ws_info_list->ws_info_list, env); + } + + if(ws_info_list) + { + AXIS2_FREE(env->allocator, ws_info_list); + } + + return; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_init( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + int size = 0; + int i = 0; + + size = axutil_array_list_size(ws_info_list->ws_info_list, env); + for(i = 0; i < size; i++) + { + axis2_ws_info_t *ws_info = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list->ws_info_list, env, i); + axis2_ws_info_free(ws_info, env); + } + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_add_ws_info_item( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axutil_file_t * file, + int type) +{ + axis2_status_t status = AXIS2_FAILURE; + axis2_char_t *file_name = NULL; + axis2_char_t *temp_name = NULL; + + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + + temp_name = axutil_file_get_name(file, env); + file_name = axutil_strdup(env, temp_name); + if(!file_name) + { + return AXIS2_FAILURE; + } + + switch(type) + { + case AXIS2_SVC: + { + axis2_ws_info_t *ws_info = NULL; + long last_modified_date = 0; + axis2_arch_file_data_t *file_data = NULL; + + last_modified_date = (long)axutil_file_get_timestamp(file, env); + /* We are sure that the difference lies within the long range */ + ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env, + file_name, last_modified_date, AXIS2_SVC); + status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info); + + if(AXIS2_SUCCESS != status) + { + return status; + } + file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_SVC, file); + /* To inform that new web service is to be deployed */ + status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data); + if(AXIS2_SUCCESS != status) + { + return status; + } + break; + } + case AXIS2_MODULE: + { + axis2_ws_info_t *ws_info = NULL; + long last_modified_date = 0; + axis2_arch_file_data_t *file_data = NULL; + + last_modified_date = (long)axutil_file_get_timestamp(file, env); + /* We are sure that the difference lies within the long range */ + ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env, + file_name, last_modified_date, AXIS2_MODULE); + status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info); + + if(AXIS2_SUCCESS != status) + { + return status; + } + file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, file); + /* To inform that new module is to be deployed */ + status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data); + if(AXIS2_SUCCESS != status) + { + return status; + } + + break; + } + } + return axutil_array_list_add(ws_info_list->current_info_list, env, file_name); +} + +AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL +axis2_ws_info_list_get_file_item( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + int i = 0; + int size = 0; + AXIS2_PARAM_CHECK(env->error, file_name, NULL); + + size = axutil_array_list_size(ws_info_list->ws_info_list, env); + for(i = 0; i < size; i++) + { + axis2_ws_info_t *ws_info = NULL; + axis2_char_t *file_name_l = NULL; + + ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); + + file_name_l = axis2_ws_info_get_file_name(ws_info, env); + if(!axutil_strcmp(file_name_l, file_name)) + { + return ws_info; + } + } + return NULL; +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_ws_info_list_is_modified( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axutil_file_t * file, + axis2_ws_info_t * ws_info) +{ + long last_modified_date = 0; + + AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE); + AXIS2_PARAM_CHECK(env->error, ws_info, AXIS2_FAILURE); + + last_modified_date = axis2_ws_info_get_last_modified_date(ws_info, env); + return (last_modified_date != axutil_file_get_timestamp(file, env)); +} + +AXIS2_EXTERN axis2_bool_t AXIS2_CALL +axis2_ws_info_list_is_file_exist( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env, + axis2_char_t * file_name) +{ + axis2_ws_info_t *ws_info = NULL; + + AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE); + ws_info = axis2_ws_info_list_get_file_item(ws_info_list, env, file_name); + return !(ws_info == NULL); +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_check_for_undeploy( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + int list_size = 0; + axutil_array_list_t *temp_list = NULL; + int i = 0; + + /* Create temp list */ + temp_list = axutil_array_list_create(env, 0); + if(!temp_list) + { + return AXIS2_FAILURE; + } + list_size = axutil_array_list_size(ws_info_list->ws_info_list, env); + + for(i = 0; i < list_size; i++) + { + /* For each ws_info item in the ws_info_list check whether it is also + * in the current_info_list. If not mark it to be undeployed by adding + * it to a temporarily list. Also add that item to the undeploy list of + * deployment engine.*/ + int current_lists_size = 0; + axis2_ws_info_t *file_item = NULL; + axis2_char_t *file_item_name = NULL; + axis2_bool_t exist = AXIS2_FALSE; + int j = 0; + + file_item = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i); + + file_item_name = axis2_ws_info_get_file_name(file_item, env); + current_lists_size = axutil_array_list_size(ws_info_list->current_info_list, env); + for(j = 0; j < current_lists_size; j++) + { + axis2_char_t *file_name = NULL; + file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list-> current_info_list, + env, j); + if(!axutil_strcmp(file_name, file_item_name)) + { + exist = AXIS2_TRUE; + break; + } + } + + if(!exist) + { + axis2_ws_info_t *ws_info = NULL; + long last_modified_date = 0; + + last_modified_date = axis2_ws_info_get_last_modified_date(file_item, env); + axutil_array_list_add(temp_list, env, file_item); + ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date(env, + file_item_name, last_modified_date); + /* This ws_info is to be undeployed */ + axis2_dep_engine_add_ws_to_undeploy(ws_info_list->dep_engine, env, ws_info); + } + + } + + list_size = axutil_array_list_size(temp_list, env); + for(i = 0; i < list_size; i++) + { + /* Get each ws_info item from the temp list created and remove that + * item from the ws_info_list */ + axis2_ws_info_t *file_item = NULL; + int index = 0; + + file_item = (axis2_ws_info_t *)axutil_array_list_get(temp_list, env, i); + index = axutil_array_list_index_of(ws_info_list->ws_info_list, env, file_item); + axutil_array_list_remove(ws_info_list->ws_info_list, env, index); + } + axutil_array_list_free(temp_list, env); + return AXIS2_SUCCESS; +} + +AXIS2_EXTERN axis2_status_t AXIS2_CALL +axis2_ws_info_list_update( + axis2_ws_info_list_t * ws_info_list, + const axutil_env_t * env) +{ + axis2_status_t status = AXIS2_FAILURE; + + status = axis2_ws_info_list_check_for_undeploy(ws_info_list, env); + if(AXIS2_SUCCESS != status) + { + return AXIS2_FAILURE; + } + + return axis2_dep_engine_do_deploy(ws_info_list->dep_engine, env); +} + -- cgit v1.1-32-gdbae