You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by da...@apache.org on 2006/01/06 13:00:25 UTC
svn commit: r366485 [2/2] - in /webservices/axis2/trunk/c: include/
modules/core/deployment/ modules/core/description/ modules/core/engine/
modules/platforms/unix/ modules/util/
Modified: webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/dep_engine.c Fri Jan 6 03:59:44 2006
@@ -15,6 +15,15 @@
*/
#include <axis2_dep_engine.h>
+#include <axis2_array_list.h>
+#include <axis2_deployment.h>
+#include <axis2_file_handler.h>
+#include <axis2_dll_desc.h>
+#include <axis2_flow.h>
+#include <axis2_arch_reader.h>
+#include <axis2_svc_builder.h>
+#include <axis2_om_node.h>
+#include <axis2_class_loader.h>
/**
* @brief DLL Description struct impl
@@ -23,14 +32,17 @@
typedef struct axis2_dep_engine_impl
{
axis2_dep_engine_t dep_engine;
- struct axis2_arch_file_data *current_arch_file;
+ struct axis2_arch_file_data *curr_file;
/**
* to keep a ref to engine register
* this ref will pass to engine when it call start()
* method
*/
- struct axis2_conf *axis_config;
+ struct axis2_conf *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 */
/**
* This will store all the web Services to deploy
*/
@@ -40,12 +52,20 @@
*/
axis2_array_list_t *ws_to_undeploy;
- axis2_phases_info_t *phases_info;
+ struct axis2_phases_info *phases_info; /* to store phases list in axis2.xml */
+ /**
+ * this constructor for the testing
+ */
+ axis2_char_t *folder_name;
+
+ axis2_char_t *conf_name;
+
/**
* To store the module specified in the server.xml at the document parsing
* time
*/
axis2_array_list_t *module_list;
+
} axis2_dep_engine_impl_t;
@@ -61,7 +81,7 @@
axis2_dep_engine_add_module(axis2_dep_engine_t *dep_engine,
axis2_env_t **env,
axis2_qname_t *module_qname);
-
+
struct axis2_module_desc *AXIS2_CALL
axis2_dep_engine_get_module(axis2_dep_engine_t *dep_engine,
axis2_env_t **env,
@@ -87,6 +107,100 @@
axis2_env_t **env,
axis2_ws_info_t *file);
+axis2_phases_info_t *AXIS2_CALL
+axis2_dep_engine_get_phases_info(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+/**
+ * tio get ER
+ *
+ * @return AxisConfiguration <code>AxisConfiguration</code>
+ */
+axis2_conf_t *AXIS2_CALL
+axis2_dep_engine_get_axis_conf(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+/**
+ * To set hotDeployment and hot update
+ */
+axis2_status_t
+axis2_dep_engine_set_dep_features(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+axis2_conf_t *AXIS2_CALL
+axis2_dep_engine_load(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+axis2_conf_t *AXIS2_CALL
+axis2_dep_engine_load_client(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *client_home);
+
+axis2_status_t
+axis2_dep_engine_check_client_home(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *client_home);
+
+/**
+ * This methode used to check the modules referd by server.xml
+ * are exist , or they have deployed
+ */
+axis2_status_t
+axis2_dep_engine_engage_modules(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+/**
+ * This method is to check wether some one has change the system pre defined phases for all the
+ * flows if some one has done so will throw a DeploymentException
+ *
+ */
+axis2_status_t
+axis2_dep_engine_validate_system_predefined_phases(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+axis2_conf_t *
+axis2_dep_engine_create_conf(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+axis2_status_t
+axis2_dep_engine_add_new_svc(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_svc_grp_t *svc_metadata);
+
+/**
+ * This method is used to fill the axis service , it dose loading service class and also the provider class
+ * and it will also load the service handlers
+ *
+ * @param axisService
+ * @throws org.apache.axis2.AxisFault
+ */
+axis2_status_t
+axis2_dep_engine_load_svc_props(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_svc_t *svc);
+
+axis2_status_t
+axis2_dep_engine_load_module_dll(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_module_desc_t *module_desc);
+
+axis2_status_t
+axis2_dep_engine_add_flow_handlers(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_flow_t *flow);
+
+
+void * AXIS2_CALL
+axis2_dep_engine_get_handler_dll(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *dll_name);
+
+
+axis2_status_t
+axis2_dep_engine_add_new_module(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_module_desc_t *module_metadata);
+
axis2_status_t AXIS2_CALL
axis2_dep_engine_do_deploy(axis2_dep_engine_t *dep_engine,
axis2_env_t **env);
@@ -95,64 +209,219 @@
axis2_dep_engine_undeploy(axis2_dep_engine_t *dep_engine,
axis2_env_t **env);
-axis2_phases_info_t *AXIS2_CALL
-axis2_dep_engine_get_phases_info(axis2_dep_engine_t *dep_engine,
- axis2_env_t **env);
+axis2_bool_t AXIS2_CALL
+axis2_dep_engine_is_hot_update(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env);
+
+/**
+ * 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 fileName
+ * @return String
+ */
+axis2_char_t *
+axis2_dep_engine_get_axis_svc_name(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *file_name);
+axis2_status_t AXIS2_CALL
+axis2_dep_engine_set_phases_info(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_phases_info_t *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 axisService
+ * @param serviceInputStream
+ * @param classLoader
+ * @return
+ * @throws DeploymentException
+ */
+axis2_svc_t *AXIS2_CALL
+axis2_dep_engine_build_svc(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_svc_t *svc,
+ axis2_char_t *file_name);
+
+/**
+ * This method can be used to build ModuleDescription for a given module archiev file
+ *
+ * @param modulearchive
+ * @return
+ * @throws DeploymentException
+ */
+
+axis2_module_desc_t *AXIS2_CALL
+axis2_dep_engine_build_module(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_file_t *module_archive,
+ axis2_conf_t *conf);
+
/************************* End of function headers ****************************/
-axis2_dep_engine_t *AXIS2_CALL
-axis2_dep_engine_create_with_repos_name (
- axis2_env_t **env,
- axis2_char_t *repos_path)
+axis2_dep_engine_t *AXIS2_CALL
+axis2_dep_engine_create(axis2_env_t **env)
{
- axis2_dep_engine_impl_t *dep_engine_impl = NULL;
+ axis2_dep_engine_impl_t *engine_impl = NULL;
AXIS2_ENV_CHECK(env, NULL);
- dep_engine_impl = (axis2_dep_engine_impl_t *) AXIS2_MALLOC ((*env)->allocator
+ engine_impl = (axis2_dep_engine_impl_t *) AXIS2_MALLOC ((*env)->allocator
, sizeof (axis2_dep_engine_impl_t));
- if(NULL == dep_engine_impl)
+ if(NULL == engine_impl)
{
AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
- }
-
- dep_engine_impl->axis_config = NULL;
- dep_engine_impl->current_arch_file = NULL;
- dep_engine_impl->ws_to_deploy = NULL;
- dep_engine_impl->ws_to_undeploy = NULL;
- dep_engine_impl->phases_info = NULL;
- dep_engine_impl->module_list = NULL;
+ }
+ engine_impl->conf = NULL;
+ engine_impl->axis2_repos = NULL;
+ engine_impl->curr_file = NULL;
+ engine_impl->ws_to_deploy = NULL;
+ engine_impl->ws_to_undeploy = NULL;
+ engine_impl->phases_info = NULL;
+ engine_impl->module_list = NULL;
+ engine_impl->folder_name = NULL;
+ engine_impl->conf_name = NULL;
+ engine_impl->dep_engine.ops = NULL;
- dep_engine_impl->dep_engine.ops = NULL;
-
- dep_engine_impl->dep_engine.ops = (axis2_dep_engine_ops_t *) AXIS2_MALLOC(
+ engine_impl->dep_engine.ops = (axis2_dep_engine_ops_t *) AXIS2_MALLOC(
(*env)->allocator, sizeof(axis2_dep_engine_ops_t));
- if(NULL == dep_engine_impl->dep_engine.ops)
+ if(NULL == engine_impl->dep_engine.ops)
{
AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
return NULL;
}
- dep_engine_impl->dep_engine.ops->free = axis2_dep_engine_free;
- dep_engine_impl->dep_engine.ops->add_module = axis2_dep_engine_add_module;
- dep_engine_impl->dep_engine.ops->get_module = axis2_dep_engine_get_module;
- dep_engine_impl->dep_engine.ops->get_current_file_item =
+ engine_impl->dep_engine.ops->free = axis2_dep_engine_free;
+ engine_impl->dep_engine.ops->add_module = axis2_dep_engine_add_module;
+ engine_impl->dep_engine.ops->get_module = axis2_dep_engine_get_module;
+ engine_impl->dep_engine.ops->get_current_file_item =
axis2_dep_engine_get_current_file_item;
- dep_engine_impl->dep_engine.ops->add_ws_to_deploy =
+ engine_impl->dep_engine.ops->add_ws_to_deploy =
axis2_dep_engine_add_ws_to_deploy;
- dep_engine_impl->dep_engine.ops->add_ws_to_undeploy =
+ engine_impl->dep_engine.ops->add_ws_to_undeploy =
axis2_dep_engine_add_ws_to_undeploy;
- dep_engine_impl->dep_engine.ops->do_deploy = axis2_dep_engine_do_deploy;
- dep_engine_impl->dep_engine.ops->undeploy = axis2_dep_engine_undeploy;
- dep_engine_impl->dep_engine.ops->get_phases_info =
+ engine_impl->dep_engine.ops->get_phases_info =
axis2_dep_engine_get_phases_info;
-
-
- return &(dep_engine_impl->dep_engine);
+
+ engine_impl->dep_engine.ops->get_axis_conf = axis2_dep_engine_get_axis_conf;
+ engine_impl->dep_engine.ops->load = axis2_dep_engine_load;
+ engine_impl->dep_engine.ops->load_client = axis2_dep_engine_load_client;
+ engine_impl->dep_engine.ops->get_handler_dll =
+ axis2_dep_engine_get_handler_dll;
+ engine_impl->dep_engine.ops->do_deploy = axis2_dep_engine_do_deploy;
+ engine_impl->dep_engine.ops->undeploy = axis2_dep_engine_undeploy;
+ engine_impl->dep_engine.ops->is_hot_update = axis2_dep_engine_is_hot_update;
+ engine_impl->dep_engine.ops->set_phases_info =
+ axis2_dep_engine_set_phases_info;
+ engine_impl->dep_engine.ops->build_svc = axis2_dep_engine_build_svc;
+ engine_impl->dep_engine.ops->build_module = axis2_dep_engine_build_module;
+
+ return &(engine_impl->dep_engine);
+}
+axis2_dep_engine_t *AXIS2_CALL
+axis2_dep_engine_create_with_repos_name (
+ axis2_env_t **env,
+ axis2_char_t *repos_path)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ engine_impl = (axis2_dep_engine_impl_t *)
+ axis2_dep_engine_create_with_repos_name_and_svr_xml_file(env,
+ repos_path, AXIS2_SERVER_XML_FILE);
+ if(!engine_impl)
+ {
+ return NULL;
+ }
+
+ return &(engine_impl->dep_engine);
+}
+
+axis2_dep_engine_t *AXIS2_CALL
+axis2_dep_engine_create_with_repos_name_and_svr_xml_file(axis2_env_t **env,
+ axis2_char_t *repos_path,
+ axis2_char_t *svr_xml_file)
+{
+ axis2_dep_engine_impl_t *engine_impl = 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(0 == AXIS2_STRCMP("", repos_path))
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+
+ engine_impl = (axis2_dep_engine_impl_t *) axis2_dep_engine_create(env);
+
+ if(NULL == engine_impl)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ status = axis2_file_handler_access(repos_path, AXIS2_F_OK);
+ if(AXIS2_SUCCESS != status)
+ {
+ axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_REPOSITORY_NOT_EXIST,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+
+ engine_impl->folder_name = AXIS2_STRDUP(repos_path, env);
+ if(NULL == engine_impl->folder_name)
+ {
+ axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ engine_impl->axis2_repos = AXIS2_STRDUP(repos_path, env);
+ if(NULL == engine_impl->axis2_repos)
+ {
+ axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ conf_file_l = AXIS2_STRACAT(repos_path, AXIS2_PATH_SEP_STR, env);
+ engine_impl->conf_name = AXIS2_STRACAT(conf_file_l, svr_xml_file, env);
+ AXIS2_FREE((*env)->allocator, conf_file_l);
+ if(!engine_impl->conf_name)
+ {
+ engine_impl->conf_name =
+ AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE, env);
+ if(!engine_impl->conf_name)
+ {
+ axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ }
+ status = axis2_file_handler_access(engine_impl->conf_name, AXIS2_F_OK);
+ if(AXIS2_SUCCESS != status)
+ {
+ axis2_dep_engine_free(&(engine_impl->dep_engine), env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+
+ return &(engine_impl->dep_engine);
}
/******************************************************************************/
@@ -161,30 +430,45 @@
axis2_dep_engine_free (axis2_dep_engine_t *dep_engine,
axis2_env_t **env)
{
- axis2_dep_engine_impl_t *dep_engine_impl = NULL;
+ axis2_dep_engine_impl_t *engine_impl = NULL;
AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
- dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
- if(dep_engine_impl->current_arch_file)
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+ if(engine_impl->curr_file)
+ {
+ AXIS2_ARCH_FILE_DATA_FREE(engine_impl->curr_file, env);
+ engine_impl->curr_file = NULL;
+ }
+ if(engine_impl->ws_to_deploy)
{
- AXIS2_ARCH_FILE_DATA_FREE(dep_engine_impl->current_arch_file, env);
- dep_engine_impl->current_arch_file = NULL;
+ AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_deploy, env);
+ engine_impl->ws_to_deploy = NULL;
}
- if(dep_engine_impl->ws_to_deploy)
+ if(engine_impl->ws_to_undeploy)
{
- AXIS2_ARRAY_LIST_FREE(dep_engine_impl->ws_to_deploy, env);
- dep_engine_impl->ws_to_deploy = NULL;
+ AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_undeploy, env);
+ engine_impl->ws_to_undeploy = NULL;
}
- if(dep_engine_impl->ws_to_undeploy)
+ if(engine_impl->module_list)
{
- AXIS2_ARRAY_LIST_FREE(dep_engine_impl->ws_to_undeploy, env);
- dep_engine_impl->ws_to_undeploy = NULL;
+ AXIS2_ARRAY_LIST_FREE(engine_impl->module_list, env);
+ engine_impl->module_list = NULL;
}
- if(dep_engine_impl->module_list)
+ if(engine_impl->folder_name)
{
- AXIS2_ARRAY_LIST_FREE(dep_engine_impl->module_list, env);
- dep_engine_impl->module_list = NULL;
+ AXIS2_FREE((*env)->allocator, engine_impl->folder_name);
+ engine_impl->folder_name = NULL;
+ }
+ if(engine_impl->conf_name)
+ {
+ AXIS2_FREE((*env)->allocator, engine_impl->conf_name);
+ engine_impl->conf_name = NULL;
+ }
+ if(engine_impl->axis2_repos)
+ {
+ AXIS2_FREE((*env)->allocator, engine_impl->axis2_repos);
+ engine_impl->axis2_repos = NULL;
}
if(NULL != dep_engine->ops)
@@ -197,6 +481,7 @@
return AXIS2_SUCCESS;
}
+
axis2_status_t AXIS2_CALL
axis2_dep_engine_add_module(axis2_dep_engine_t *dep_engine,
axis2_env_t **env,
@@ -220,7 +505,7 @@
AXIS2_PARAM_CHECK((*env)->error, module_name, NULL);
dep_engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
- return AXIS2_CONF_GET_MODULE(dep_engine_impl->axis_config, env, module_name);
+ return AXIS2_CONF_GET_MODULE(dep_engine_impl->conf, env, module_name);
}
struct axis2_arch_file_data *AXIS2_CALL
@@ -229,7 +514,7 @@
{
AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
- return AXIS2_INTF_TO_IMPL(dep_engine)->current_arch_file;
+ return AXIS2_INTF_TO_IMPL(dep_engine)->curr_file;
}
/**
@@ -264,26 +549,988 @@
return AXIS2_ARRAY_LIST_ADD(dep_engine_impl->ws_to_undeploy, env, file);
}
+axis2_phases_info_t *AXIS2_CALL
+axis2_dep_engine_get_phases_info(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
+ return AXIS2_INTF_TO_IMPL(dep_engine)->phases_info;
+}
+
+/**
+ * tio get ER
+ *
+ * @return AxisConfiguration <code>AxisConfiguration</code>
+ */
+axis2_conf_t *AXIS2_CALL
+axis2_dep_engine_get_axis_conf(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
+
+ return AXIS2_INTF_TO_IMPL(dep_engine)->conf;
+}
+
+/**
+ * To set hotDeployment and hot update
+ */
+axis2_status_t
+axis2_dep_engine_set_dep_features(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_char_t *value = NULL;
+ axis2_param_t *para_hot_dep = NULL;
+ axis2_param_t *para_hot_update = NULL;
+
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ para_hot_dep = AXIS2_CONF_GET_PARAM(engine_impl->conf, env,
+ AXIS2_HOTDEPLOYMENT);
+ para_hot_update = AXIS2_CONF_GET_PARAM(engine_impl->conf, env,
+ AXIS2_HOTUPDATE);
+
+ if(NULL != para_hot_dep)
+ {
+ value = (axis2_char_t *) AXIS2_PARAM_GET_VALUE(para_hot_dep, env);
+ if(0 == AXIS2_STRCASECMP("false", value))
+ {
+ engine_impl->hot_dep = AXIS2_FALSE;
+ }
+ }
+ if(NULL != para_hot_update)
+ {
+ value = (axis2_char_t *) AXIS2_PARAM_GET_VALUE(para_hot_update, env);
+ if(0 == AXIS2_STRCASECMP("false", value))
+ {
+ engine_impl->hot_update = AXIS2_FALSE;
+ }
+ }
+ return AXIS2_SUCCESS;
+}
+
+axis2_conf_t *AXIS2_CALL
+axis2_dep_engine_load(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_conf_builder_t *builder = NULL;
+ axis2_repos_listener_t *repos_listener = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ if(NULL == engine_impl->conf_name)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+
+ engine_impl->conf = axis2_conf_create(env);
+ if(!engine_impl->conf)
+ {
+ return NULL;
+ }
+ builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env,
+ engine_impl->conf_name, dep_engine, engine_impl->conf);
+ if(!builder)
+ {
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ engine_impl->conf = NULL;
+ }
+ status = AXIS2_CONF_BUILDER_POPULATE_CONF(builder, env);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ AXIS2_CONF_BUILDER_FREE(builder, env);
+ engine_impl->conf = NULL;
+ return NULL;
+ }
+ axis2_dep_engine_set_dep_features(dep_engine, env);
+
+ /*
+ if (hotDeployment) {
+ startSearch(this);
+ } else {
+ */
+ repos_listener =
+ axis2_repos_listener_create_with_folder_name_and_dep_engine(env,
+ engine_impl->folder_name, dep_engine);
+ if(!repos_listener)
+ {
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ AXIS2_CONF_BUILDER_FREE(builder, env);
+ return NULL;
+ }
+ AXIS2_CONF_SET_REPOS(engine_impl->conf, env, engine_impl->axis2_repos);
+ status = axis2_dep_engine_validate_system_predefined_phases(dep_engine, env);
+ if(AXIS2_FAILURE == status)
+ {
+ AXIS2_REPOS_LISTENER_FREE(repos_listener, env);
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ AXIS2_CONF_BUILDER_FREE(builder, env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_VAL_FAILED,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+ AXIS2_CONF_SET_PHASESINFO(engine_impl->conf, env, engine_impl->phases_info);
+ status = axis2_dep_engine_engage_modules(dep_engine, env);
+ if(AXIS2_FAILURE == status)
+ {
+ AXIS2_REPOS_LISTENER_FREE(repos_listener, env);
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ AXIS2_CONF_BUILDER_FREE(builder, env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_VAL_FAILED,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+ /*}*/
+
+ return engine_impl->conf;
+}
+
+
+axis2_conf_t *AXIS2_CALL
+axis2_dep_engine_load_client(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *client_home)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_conf_builder_t *builder = NULL;
+ axis2_repos_listener_t *repos_listener = NULL;
+ axis2_bool_t is_repos_exist = AXIS2_FALSE;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
+ AXIS2_PARAM_CHECK((*env)->error, client_home, NULL);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ engine_impl->axis2_repos = AXIS2_STRDUP(client_home, env);
+ if(!engine_impl->axis2_repos)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ if(NULL != client_home && 0 != AXIS2_STRCMP("", client_home))
+ {
+ axis2_dep_engine_check_client_home(dep_engine, env, client_home);
+ is_repos_exist = AXIS2_TRUE;
+ }
+ else
+ {
+ engine_impl->conf_name = AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE,
+ env);
+ if(!engine_impl->conf_name)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ }
+ engine_impl->conf = axis2_conf_create(env);
+ if(!engine_impl->conf)
+ {
+ return NULL;
+ }
+ builder = axis2_conf_builder_create_with_file_and_dep_engine_and_conf(env,
+ engine_impl->conf_name, dep_engine, engine_impl->conf);
+ if(!builder)
+ {
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ engine_impl->conf = NULL;
+ }
+ status = AXIS2_CONF_BUILDER_POPULATE_CONF(builder, env);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ AXIS2_CONF_BUILDER_FREE(builder, env);
+ engine_impl->conf = NULL;
+ return NULL;
+ }
+
+ if (AXIS2_TRUE == is_repos_exist)
+ {
+ engine_impl->hot_dep = AXIS2_FALSE;
+ engine_impl->hot_update = AXIS2_FALSE;
+ repos_listener =
+ axis2_repos_listener_create_with_folder_name_and_dep_engine(env,
+ engine_impl->folder_name, dep_engine);
+ }
+
+ AXIS2_CONF_SET_REPOS(engine_impl->conf, env, engine_impl->axis2_repos);
+ AXIS2_CONF_SET_PHASESINFO(engine_impl->conf, env, engine_impl->phases_info);
+ status = axis2_dep_engine_engage_modules(dep_engine, env);
+ if(AXIS2_FAILURE == status)
+ {
+ AXIS2_REPOS_LISTENER_FREE(repos_listener, env);
+ AXIS2_CONF_FREE(engine_impl->conf, env);
+ AXIS2_CONF_BUILDER_FREE(builder, env);
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_MODULE_VAL_FAILED,
+ AXIS2_FAILURE);
+ return NULL;
+ }
+
+ return engine_impl->conf;
+}
+
+
+axis2_status_t
+axis2_dep_engine_check_client_home(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *client_home)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_char_t *path_l = NULL;
+ axis2_status_t status = AXIS2_FAILURE;
+
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ engine_impl->folder_name = AXIS2_STRDUP(client_home, env);
+ if(engine_impl->folder_name)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ path_l = AXIS2_STRACAT(client_home, AXIS2_PATH_SEP_STR, env);
+ engine_impl->conf_name = AXIS2_STRACAT(path_l,AXIS2_SERVER_XML_FILE, env);
+ AXIS2_FREE((*env)->allocator, path_l);
+ if(!engine_impl->conf_name)
+ {
+ engine_impl->conf_name = AXIS2_STRDUP(AXIS2_CONFIGURATION_RESOURCE, env);
+ if(!engine_impl->conf_name)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND,
+ AXIS2_FAILURE)
+ return AXIS2_FAILURE;
+ }
+ }
+ status = axis2_file_handler_access(engine_impl->conf_name, AXIS2_F_OK);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_CONFIG_NOT_FOUND,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+ return AXIS2_SUCCESS;
+}
+
+/**
+ * This methode used to check the modules referd by server.xml
+ * are exist , or they have deployed
+ */
+axis2_status_t
+axis2_dep_engine_engage_modules(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ int size = 0;
+ int i = 0;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+ /* ArrayList modules = DeploymentData.getInstance().getModules(); */
+ /* PhaseResolver resolver = new PhaseResolver(axisConfig); */
+ size = AXIS2_ARRAY_LIST_SIZE(engine_impl->module_list, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_qname_t *qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(
+ engine_impl->module_list, env, i);
+ AXIS2_CONF_ENGAGE_MODULE(engine_impl->conf, env, qname);
+ }
+ return AXIS2_SUCCESS;
+}
+
+/**
+ * This method is to check wether some one has change the system pre defined phases for all the
+ * flows if some one has done so will throw a DeploymentException
+ *
+ */
+axis2_status_t
+axis2_dep_engine_validate_system_predefined_phases(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_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_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ in_phases = AXIS2_PHASES_INFO_GET_IN_PHASES(engine_impl->phases_info, env);
+
+ /* TODO condition checking should be otherway since null value can occur */
+ phase0 = (axis2_char_t *) AXIS2_ARRAY_LIST_GET(in_phases, env, 0);
+ phase1 = (axis2_char_t *) AXIS2_ARRAY_LIST_GET(in_phases, env, 1);
+ phase2 = (axis2_char_t *) AXIS2_ARRAY_LIST_GET(in_phases, env, 2);
+ phase3 = (axis2_char_t *) AXIS2_ARRAY_LIST_GET(in_phases, env, 3);
+ if(0 == AXIS2_STRCMP(phase0, AXIS2_PHASE_TRANSPORTIN) &&
+ 0 == AXIS2_STRCMP(phase1, AXIS2_PHASE_PRE_DISPATCH) &&
+ 0 == AXIS2_STRCMP(phase2, AXIS2_PHASE_DISPATCH) &&
+ 0 == AXIS2_STRCMP(phase3, AXIS2_PHASE_POST_DISPATCH))
+ {
+ AXIS2_ERROR_SET((*env)->error, AXI2_ERROR_IN_VALID_PHASE, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ /* ArrayList outPhaes = tempdata.getOutphases(); */
+ /* TODO do the validation code here */
+ /* ArrayList systemDefaultPhases =((AxisConfigurationImpl)axisConfig).
+ getInPhasesUptoAndIncludingPostDispatch();
+ */
+ return AXIS2_SUCCESS;
+}
+
+axis2_conf_t *
+axis2_dep_engine_create_conf(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
+{
+ AXIS2_ENV_CHECK(env, NULL);
+ return axis2_conf_create(env);
+}
+
+
+axis2_status_t
+axis2_dep_engine_add_new_svc(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_svc_grp_t *svc_metadata)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_array_list_t *svcs = NULL;
+ int size = 0;
+ int i = 0;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, svc_metadata, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+/* Iterator services = currentArchiveFile.getService().values().iterator(); */
+
+ svcs = AXIS2_ARCH_FILE_DATA_GET_DEPLOYABLE_SVCS(engine_impl->curr_file, env);
+ size = AXIS2_ARRAY_LIST_SIZE(svcs, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_svc_t *svc = NULL;
+ axis2_file_t *file = NULL;
+ axis2_array_list_t *grp_modules = NULL;
+ axis2_array_list_t *list = NULL;
+ int size = 0;
+ int i = 0;
+ axis2_hash_t *ops = NULL;
+ axis2_hash_index_t *index_i = NULL;
+
+ svc = (axis2_svc_t *) AXIS2_ARRAY_LIST_GET(svcs, env, i);
+ axis2_dep_engine_load_svc_props(dep_engine, env, svc);
+ file = AXIS2_ARCH_FILE_DATA_GET_FILE(engine_impl->curr_file, env);
+ AXIS2_SVC_SET_FILENAME(svc, env, file->name);
+
+ /* module form serviceGroup */
+ grp_modules = AXIS2_SVC_GRP_GET_MODULES(svc_metadata, env);
+ size = AXIS2_ARRAY_LIST_SIZE(grp_modules, env);
+ for(i = 0; i< size; i++)
+ {
+ axis2_module_desc_t *module_desc = NULL;
+ axis2_qname_t *qmodulename = NULL;
+
+ qmodulename = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(grp_modules,
+ env, i);
+ module_desc = AXIS2_CONF_GET_MODULE(engine_impl->conf, env,
+ qmodulename);
+ if(NULL != module_desc)
+ {
+ AXIS2_SVC_ENGAGE_MODULE(svc, env, module_desc, engine_impl->conf);
+
+ }
+ else
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODUELE_REF,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ /* modules from <service> */
+ list = AXIS2_SVC_GET_MODULES(svc, env);
+ size = AXIS2_ARRAY_LIST_SIZE(list, env);
+ for (i = 0; i < size; i++)
+ {
+ axis2_module_desc_t *module_desc = NULL;
+ axis2_qname_t *qmodulename = NULL;
+
+ qmodulename = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(grp_modules,
+ env, i);
+ module_desc = AXIS2_CONF_GET_MODULE(engine_impl->conf, env,
+ qmodulename);
+ if(NULL != module_desc)
+ {
+ AXIS2_SVC_ENGAGE_MODULE(svc, env, module_desc, engine_impl->conf);
+
+ }
+ else
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODUELE_REF,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+
+ ops = AXIS2_SVC_GET_OPS(svc, env);
+ for (index_i = axis2_hash_first (ops, env); index_i; index_i =
+ axis2_hash_next (env, index_i))
+ {
+ void * v = NULL;
+ axis2_op_t *op_desc = NULL;
+ axis2_array_list_t *modules = NULL;
+ int size = 0;
+ int i = 0;
+
+ axis2_hash_this (index_i, NULL, NULL, &v);
+ op_desc = (axis2_op_t *)v;
+
+ modules = AXIS2_OP_GET_MODULE_REFS(op_desc, env);
+ size = AXIS2_ARRAY_LIST_SIZE(modules, env);
+ for (i = 0; i < size; i++)
+ {
+ axis2_qname_t *module_qname = NULL;
+ axis2_module_desc_t *module = NULL;
+
+ module_qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(modules,
+ env, i);
+ module = AXIS2_CONF_GET_MODULE(engine_impl->conf, env,
+ module_qname);
+
+ if (NULL != module)
+ {
+ AXIS2_OP_ENGAGE_MODULE(op_desc, env, module);
+ }
+ else
+ {
+ AXIS2_ERROR_SET((*env)->error,
+ AXIS2_ERROR_INVALID_MODUELE_REF_BY_OP, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ }
+ }
+ AXIS2_SVC_GRP_ADD_SVC(svc_metadata, env, svc);
+ }
+ return AXIS2_CONF_ADD_SVC_GRP(engine_impl->conf, env, svc_metadata);
+}
+
+/**
+ * This method is used to fill the axis service , it dose loading service class and also the provider class
+ * and it will also load the service handlers
+ *
+ * @param axisService
+ * @throws org.apache.axis2.AxisFault
+ */
+axis2_status_t
+axis2_dep_engine_load_svc_props(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_svc_t *svc)
+{
+ axis2_dep_engine_impl_t *engine_impl = 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_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, svc, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ in_flow = AXIS2_SVC_GET_INFLOW(svc, env);
+ if(NULL != in_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, in_flow);
+ }
+
+ out_flow = AXIS2_SVC_GET_OUTFLOW(svc, env);
+ if(NULL != out_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, out_flow);
+ }
+
+ in_fault_flow = AXIS2_SVC_GET_FAULT_INFLOW(svc, env);
+ if(NULL != in_fault_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, in_fault_flow);
+ }
+
+ out_fault_flow = AXIS2_SVC_GET_FAULT_OUTFLOW(svc, env);
+ if(NULL != out_fault_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, out_fault_flow);
+ }
+ /* axisService.setClassLoader(currentArchiveFile.getClassLoader()); */
+ return AXIS2_SUCCESS;
+}
+
+
+axis2_status_t
+axis2_dep_engine_load_module_dll(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_module_desc_t *module_desc)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_char_t *read_in_dll = NULL;
+ axis2_module_t *module = NULL;
+ axis2_dll_desc_t *dll_desc = NULL;
+ axis2_param_t *impl_info_param = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, module_desc, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ read_in_dll = AXIS2_ARCH_FILE_DATA_GET_MODULE_DLL_NAME(engine_impl->
+ curr_file, env);
+ dll_desc = axis2_dll_desc_create(env);
+ AXIS2_DLL_DESC_SET_NAME(dll_desc, env, read_in_dll);
+ AXIS2_DLL_DESC_SET_TYPE(dll_desc, env, AXIS2_MODULE_DLL);
+ axis2_class_loader_init(env);
+ impl_info_param = axis2_param_create(env, NULL, NULL);
+ AXIS2_PARAM_SET_VALUE(impl_info_param, env, dll_desc);
+ module = (axis2_module_t *) axis2_class_loader_create_dll(env,
+ impl_info_param);
+
+ return AXIS2_MODULE_DESC_SET_MODULE(module_desc, env, module);
+}
+
+
+axis2_status_t
+axis2_dep_engine_add_flow_handlers(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_flow_t *flow)
+{
+ int count = 0;
+ int j = 0;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ 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;
+ axis2_char_t *handler_dll_name = NULL;
+ axis2_dll_desc_t *dll_desc = NULL;
+ axis2_param_t *impl_info_param = NULL;
+
+ handlermd = AXIS2_FLOW_GET_HANDLER(flow, env, j);
+ handler_dll_name = AXIS2_HANDLER_DESC_GET_CLASS_NAME(handlermd, env);
+ dll_desc = axis2_dll_desc_create(env);
+ AXIS2_DLL_DESC_SET_NAME(dll_desc, env, handler_dll_name);
+ AXIS2_DLL_DESC_SET_TYPE(dll_desc, env, AXIS2_HANDLER_DLL);
+ axis2_class_loader_init(env);
+ impl_info_param = axis2_param_create(env, NULL, NULL);
+ AXIS2_PARAM_SET_VALUE(impl_info_param, env, dll_desc);
+ handler = (axis2_handler_t *) axis2_class_loader_create_dll(env,
+ impl_info_param);
+ AXIS2_HANDLER_INIT(handler, env, handlermd);
+ AXIS2_HANDLER_DESC_SET_HANDLER(handlermd, env, handler);
+ }
+ return AXIS2_SUCCESS;
+}
+
+
+void * AXIS2_CALL
+axis2_dep_engine_get_handler_dll(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_char_t *dll_name)
+{
+ axis2_dll_desc_t *dll_desc = NULL;
+ axis2_param_t *impl_info_param = NULL;
+ axis2_handler_t *handler = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
+ AXIS2_PARAM_CHECK((*env)->error, dll_name, NULL);
+
+ dll_desc = axis2_dll_desc_create(env);
+ AXIS2_DLL_DESC_SET_NAME(dll_desc, env, dll_name);
+ AXIS2_DLL_DESC_SET_TYPE(dll_desc, env, AXIS2_HANDLER_DLL);
+ axis2_class_loader_init(env);
+ impl_info_param = axis2_param_create(env, NULL, NULL);
+ AXIS2_PARAM_SET_VALUE(impl_info_param, env, dll_desc);
+ handler = (axis2_handler_t *) axis2_class_loader_create_dll(env,
+ impl_info_param);
+
+ return handler;
+}
+
+
+axis2_status_t
+axis2_dep_engine_add_new_module(axis2_dep_engine_t *dep_engine,
+ axis2_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;
+ /* currentArchiveFile.setClassLoader(); */
+
+ in_flow = AXIS2_MODULE_DESC_GET_INFLOW(module_metadata, env);
+ if(NULL != in_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, in_flow);
+ }
+
+ out_flow = AXIS2_MODULE_DESC_GET_OUTFLOW(module_metadata, env);
+ if(NULL != out_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, out_flow);
+ }
+
+ in_fault_flow = AXIS2_MODULE_DESC_GET_FAULT_INFLOW(module_metadata, env);
+ if(NULL != in_fault_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, in_fault_flow);
+ }
+
+ out_fault_flow = AXIS2_MODULE_DESC_GET_FAULT_OUTFLOW(module_metadata, env);
+ if(NULL != out_fault_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, out_fault_flow);
+ }
+
+ axis2_dep_engine_load_module_dll(dep_engine, env, module_metadata);
+ /* module_metadata.setModuleClassLoader(currentArchiveFile.getClassLoader()); */
+ AXIS2_CONF_ADD_MODULE(AXIS2_INTF_TO_IMPL(dep_engine)->conf, env,
+ module_metadata);
+ /* log.info(Messages.getMessage(DeploymentErrorMsgs.ADDING_NEW_MODULE)); */
+ return AXIS2_SUCCESS;
+}
+
axis2_status_t AXIS2_CALL
axis2_dep_engine_do_deploy(axis2_dep_engine_t *dep_engine,
axis2_env_t **env)
{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ int size = 0;
axis2_status_t status = AXIS2_FAILURE;
- return status;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ size = AXIS2_ARRAY_LIST_SIZE(engine_impl->ws_to_deploy, env);
+
+ if (size > 0)
+ {
+ int i = 0;
+ for (i = 0; i < size; i++)
+ {
+ int type = 0;
+ axis2_arch_reader_t *arch_reader = NULL;
+ axis2_svc_grp_t *svc_grp = NULL;
+ axis2_char_t *file_name = NULL;
+ axis2_module_desc_t *meta_data = NULL;
+
+ engine_impl->curr_file = (axis2_arch_file_data_t *)
+ AXIS2_ARRAY_LIST_GET(engine_impl->ws_to_deploy, env, i);
+
+ type = AXIS2_ARCH_FILE_DATA_GET_TYPE(engine_impl->curr_file, env);
+
+ switch (type)
+ {
+ case AXIS2_SVC:
+ arch_reader = axis2_arch_reader_create(env);
+
+ /*archiveReader.processWSDLs(currentArchiveFile,this); */
+ /* AxisService service = archiveReader.createService(currentArchiveFile.getAbsolutePath()); */
+ svc_grp = axis2_svc_grp_create_with_conf(env,
+ engine_impl->conf);
+ file_name = AXIS2_ARCH_FILE_DATA_GET_NAME(engine_impl->
+ curr_file, env);
+ status = AXIS2_ARCH_READER_PROCESS_SVC_GRP(arch_reader, env,
+ file_name, dep_engine, svc_grp);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SVC,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ status = axis2_dep_engine_add_new_svc(dep_engine, env,
+ svc_grp);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_SVC,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ /* log.info(Messages.getMessage(
+ DeploymentErrorMsgs.DEPLOYING_WS, currentArchiveFile.getName())); */
+ engine_impl->curr_file = NULL;
+ break;
+ case AXIS2_MODULE:
+ arch_reader = axis2_arch_reader_create(env);
+ meta_data = axis2_module_desc_create(env);
+ file_name = AXIS2_ARCH_FILE_DATA_GET_NAME(engine_impl->
+ curr_file, env);
+ status = AXIS2_ARCH_READER_READ_MODULE_ARCH(arch_reader,
+ env, file_name, dep_engine, meta_data);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODULE,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ status = axis2_dep_engine_add_new_module(dep_engine, env,
+ meta_data);
+ if(AXIS2_SUCCESS != status)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODULE,
+ AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+
+ /*log.info(Messages.getMessage(DeploymentErrorMsgs.DEPLOYING_MODULE,
+ metaData.getName().getLocalPart())); */
+ engine_impl->curr_file = NULL;
+
+ break;
+
+ }
+ }
+ }
+ AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_deploy, env);
+ return AXIS2_SUCCESS;
}
axis2_status_t AXIS2_CALL
axis2_dep_engine_undeploy(axis2_dep_engine_t *dep_engine,
axis2_env_t **env)
{
- axis2_status_t status = AXIS2_FAILURE;
- return status;
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ int size = 0;
+ axis2_char_t *svc_name = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+ size = AXIS2_ARRAY_LIST_SIZE (engine_impl->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;
+ axis2_hash_t *faulty_svcs = NULL;
+
+ ws_info = (axis2_ws_info_t *) AXIS2_ARRAY_LIST_GET(engine_impl->
+ 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);
+
+ /* todo fix me deepal */
+ /* axisConfig.removeService(new QName(serviceName)); */
+ /*log.info(Messages.getMessage(DeploymentErrorMsgs.SERVICE_REMOVED,
+ wsInfo.getFilename()));*/
+ }
+ faulty_svcs = AXIS2_CONF_GET_FAULTY_SVCS(engine_impl->conf, env);
+ axis2_hash_set(faulty_svcs, svc_name, AXIS2_HASH_KEY_STRING, NULL);
+ }
+
+ }
+ AXIS2_ARRAY_LIST_FREE(engine_impl->ws_to_undeploy, env);
+ return AXIS2_SUCCESS;
}
-axis2_phases_info_t *AXIS2_CALL
-axis2_dep_engine_get_phases_info(axis2_dep_engine_t *dep_engine,
- axis2_env_t **env)
+axis2_bool_t AXIS2_CALL
+axis2_dep_engine_is_hot_update(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env)
{
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ return AXIS2_INTF_TO_IMPL(dep_engine)->hot_update;
+}
+
+/**
+ * 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 fileName
+ * @return String
+ */
+axis2_char_t *
+axis2_dep_engine_get_axis_svc_name(axis2_dep_engine_t *dep_engine,
+ axis2_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 = AXIS2_STRDUP(file_name, env);
+ 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 = strlen(temp_name);
+ 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_status_t AXIS2_CALL
+axis2_dep_engine_set_phases_info(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_phases_info_t *phases_info)
+{
+ AXIS2_FUNC_PARAM_CHECK(dep_engine, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, phases_info, AXIS2_FAILURE);
+ AXIS2_INTF_TO_IMPL(dep_engine)->phases_info = phases_info;
+ return AXIS2_SUCCESS;
+}
+
+/**
+ * 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 axisService
+ * @param serviceInputStream
+ * @param classLoader
+ * @return
+ * @throws DeploymentException
+ */
+axis2_svc_t *AXIS2_CALL
+axis2_dep_engine_build_svc(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_svc_t *svc,
+ axis2_char_t *file_name)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_svc_builder_t *builder = NULL;
+ axis2_om_node_t *node = NULL;
+
AXIS2_FUNC_PARAM_CHECK(dep_engine, env, NULL);
- return AXIS2_INTF_TO_IMPL(dep_engine)->phases_info;
+ AXIS2_PARAM_CHECK((*env)->error, file_name, NULL);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_name(
+ env, AXIS2_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(builder->desc_builder, env);
+ AXIS2_SVC_BUILDER_POPULATE_SVC(builder, env, node);
+ axis2_dep_engine_load_svc_props(dep_engine, env, svc);
+
+ return svc;
+}
+
+/**
+ * This method can be used to build ModuleDescription for a given module archiev file
+ *
+ * @param modulearchive
+ * @return
+ * @throws DeploymentException
+ */
+
+axis2_module_desc_t *AXIS2_CALL
+axis2_dep_engine_build_module(axis2_dep_engine_t *dep_engine,
+ axis2_env_t **env,
+ axis2_file_t *module_archive,
+ axis2_conf_t *conf)
+{
+ axis2_dep_engine_impl_t *engine_impl = NULL;
+ axis2_module_desc_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_FUNC_PARAM_CHECK(dep_engine, env, NULL);
+ engine_impl = AXIS2_INTF_TO_IMPL(dep_engine);
+
+ phases_info = AXIS2_CONF_GET_PHASESINFO(engine_impl->conf, env);
+ axis2_dep_engine_set_phases_info(dep_engine, env, phases_info);
+ engine_impl->curr_file = axis2_arch_file_data_create_with_type_and_file(
+ env, AXIS2_MODULE, module_archive);
+ module = axis2_module_desc_create(env);
+ arch_reader = axis2_arch_reader_create(env);
+ AXIS2_ARCH_READER_READ_MODULE_ARCH(arch_reader, env, module_archive->name,
+ dep_engine, module);
+
+ in_flow = AXIS2_MODULE_DESC_GET_INFLOW(module, env);
+ if(NULL != in_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, in_flow);
+ }
+
+ out_flow = AXIS2_MODULE_DESC_GET_OUTFLOW(module, env);
+ if(NULL != out_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, out_flow);
+ }
+
+ in_fault_flow = AXIS2_MODULE_DESC_GET_FAULT_INFLOW(module, env);
+ if(NULL != in_fault_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, in_fault_flow);
+ }
+
+ out_fault_flow = AXIS2_MODULE_DESC_GET_FAULT_OUTFLOW(module, env);
+ if(NULL != out_fault_flow)
+ {
+ axis2_dep_engine_add_flow_handlers(dep_engine, env, out_fault_flow);
+ }
+
+ axis2_dep_engine_load_module_dll(dep_engine, env, module);
+ engine_impl->curr_file = NULL;
+
+ /*axismodule.setModuleClassLoader(currentArchiveFile.getClassLoader()); */
+ return module;
+}
+
+/* public AxisService deployService(ClassLoader classLoder, InputStream serviceStream, String servieName) throws DeploymentException {
+AxisService service = null;
+try {
+currentArchiveFileile = new ArchiveFileData(SERVICE, servieName);
+currentArchiveFileile.setClassLoader(classLoder);
+service = new AxisService();
+DeploymentParser schme = new DeploymentParser(serviceStream, this);
+schme.parseServiceXML(service);
+service = loadServiceProperties(service);
+} catch (XMLStreamException e) {
+throw new DeploymentException(e.getMessage());
+} catch (PhaseException e) {
+throw new DeploymentException(e.getMessage());
+} catch (AxisFault axisFault) {
+throw new DeploymentException(axisFault.getMessage());
+}
+return service;
+}
+*/
+
+/**
+ * this method use to start the Deployment engine
+ * inorder to perform Hot deployment and so on..
+ */
+/*
+private void startSearch(DeploymentEngine engine) {
+ Scheduler scheduler = new Scheduler();
+ scheduler.schedule(new SchedulerTask(engine, folderName),
+ new DeploymentIterator());
}
+*/
Modified: webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/desc_builder.c Fri Jan 6 03:59:44 2006
@@ -39,7 +39,7 @@
axis2_desc_builder_free (axis2_desc_builder_t *desc_builder,
axis2_env_t **env);
-struct axis2_om_node *AXIS2_CALL
+axis2_om_node_t *AXIS2_CALL
axis2_build_OM(axis2_desc_builder_t *desc_builder,
axis2_env_t **env);
Modified: webservices/axis2/trunk/c/modules/core/deployment/module_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/module_builder.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/module_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/module_builder.c Fri Jan 6 03:59:44 2006
@@ -15,6 +15,7 @@
*/
#include <axis2_module_builder.h>
+#include <axis2_arch_file_data.h>
/**
* This is to convert OM->ServiceDescrption , where it first create OM from
@@ -82,7 +83,7 @@
return &(module_builder_impl->module_builder);
}
-
+/*
axis2_module_builder_t * AXIS2_CALL
axis2_svc_builder_create_with_file_and_dep_engine_module (axis2_env_t **env,
axis2_char_t *file_name,
@@ -110,7 +111,7 @@
builder_impl->module= module;
return &(builder_impl->module_builder);
}
-
+*/
/***************************Function implementation****************************/
axis2_status_t AXIS2_CALL
Modified: webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/repos_listener.c Fri Jan 6 03:59:44 2006
@@ -0,0 +1,317 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <axis2_repos_listener.h>
+
+/**
+ * @brief DLL Description struct impl
+ * Axis2 DLL Description impl
+ */
+typedef struct axis2_repos_listener_impl
+{
+ axis2_repos_listener_t repos_listener;
+ /**
+ * to store currrently checking ws info
+ */
+ axis2_array_list_t *current_info_list;
+ /**
+ * Referance to a WSInfoList
+ */
+ axis2_ws_info_list_t *info_list;
+
+ int BUFFER;
+
+ /**
+ * The parent directory of the modules and services directories
+ * that the listentner should listent
+ */
+ axis2_char_t *folder_name;
+
+
+
+} axis2_repos_listener_impl_t;
+
+#define AXIS2_INTF_TO_IMPL(repos_listener) \
+ ((axis2_repos_listener_impl_t *) repos_listener)
+
+/*************************** Function headers *********************************/
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_free (axis2_repos_listener_t *repos_listener,
+ axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_check_modules(axis2_repos_listener_t *listener,
+ axis2_env_t **env);
+
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_check_svcs(axis2_repos_listener_t *listener,
+ axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_update(axis2_repos_listener_t *listener,
+ axis2_env_t **env);
+
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_init(axis2_repos_listener_t *listener,
+ axis2_env_t **env);
+
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_start_listen(axis2_repos_listener_t *listener,
+ axis2_env_t **env);
+
+/**
+ * This method is to search a given folder for jar files
+ * and added them to a list wich is in the WSInfolist class
+ */
+axis2_status_t
+axis2_repos_listener_search_WS(axis2_repos_listener_t *listener,
+ axis2_env_t **env,
+ axis2_char_t *folder_name,
+ int type);
+
+/************************* End of function headers ****************************/
+
+axis2_repos_listener_t *AXIS2_CALL
+axis2_repos_listener_create(axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ listener_impl = (axis2_repos_listener_impl_t *) AXIS2_MALLOC ((*env)->allocator
+ , sizeof (axis2_repos_listener_impl_t));
+
+ if(NULL == listener_impl)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ listener_impl->folder_name = NULL;
+ listener_impl->current_info_list = NULL;
+ listener_impl->info_list = NULL;
+ listener_impl->BUFFER = 2048;
+ listener_impl->repos_listener.ops = NULL;
+
+ listener_impl->repos_listener.ops = (axis2_repos_listener_ops_t *)
+ AXIS2_MALLOC((*env)->allocator, sizeof(axis2_repos_listener_ops_t));
+
+ if(NULL == listener_impl->repos_listener.ops)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+
+ listener_impl->repos_listener.ops->free = axis2_repos_listener_free;
+ listener_impl->repos_listener.ops->check_modules =
+ axis2_repos_listener_check_modules;
+ listener_impl->repos_listener.ops->check_svcs =
+ axis2_repos_listener_check_svcs;
+ listener_impl->repos_listener.ops->update = axis2_repos_listener_update;
+ listener_impl->repos_listener.ops->init = axis2_repos_listener_init;
+ listener_impl->repos_listener.ops->start_listen =
+ axis2_repos_listener_start_listen;
+
+
+ return &(listener_impl->repos_listener);
+}
+
+
+/**
+ * This constructor take two argumnets folder name and referance to Deployment Engine
+ * Fisrt it initilize the syetm , by loading all the modules in the /modules directory
+ * and also create a WSInfoList to keep infor about available modules and services
+ *
+ * @param folderName path to parent directory that the listener should listent
+ * @param deploy_engine refearnce to engine registry inorder to inform the updates
+ */
+/*
+axis2_repos_listener_t *AXIS2_CALL
+axis2_repos_listener_create_with_folder_name_and_dep_engine(axis2_env_t **env,
+ axis2_char_t *folder_name,
+ axis2_dep_engine_t *dep_engine)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+
+ AXIS2_ENV_CHECK(env, NULL);
+
+ listener_impl = axis2_repos_listener_create(env);
+
+ if(NULL == listener_impl)
+ {
+ return NULL;
+ }
+ listener_impl->folder_name = AXIS2_STRDUP((*env)->allocator,
+ folder_name);
+ if(!listener_impl->folder_name)
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+ return NULL;
+ }
+ listener_impl->ws_info_list = axis2_ws_info_list_create_with_dep_engine(
+ env, dep_engine);
+ if(!listener_impl->ws_info_list)
+ {
+ return NULL;
+ }
+ axis2_repos_listener_init(&(listener_impl->repos_listener), env);
+ return &(listener_impl->repos_listener);
+}
+*/
+/******************************************************************************/
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_free (axis2_repos_listener_t *repos_listener,
+ axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(repos_listener, env, AXIS2_FAILURE);
+
+ listener_impl = AXIS2_INTF_TO_IMPL(repos_listener);
+
+ if(listener_impl->folder_name)
+ {
+ AXIS2_FREE((*env)->allocator, listener_impl->folder_name);
+ listener_impl->folder_name = NULL;
+ }
+
+ if(NULL != repos_listener->ops)
+ {
+ AXIS2_FREE((*env)->allocator, repos_listener->ops);
+ repos_listener->ops = NULL;
+ }
+
+
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_check_modules(axis2_repos_listener_t *listener,
+ axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+ axis2_char_t *module_path = NULL;
+ int size = 0;
+ int i = 0;
+
+ AXIS2_FUNC_PARAM_CHECK(listener, env, AXIS2_FAILURE);
+ listener_impl = AXIS2_INTF_TO_IMPL(listener);
+
+ module_path = AXIS2_STRACAT(listener_impl->folder_name, AXIS2_MODULE_PATH,
+ env);
+ listener_impl->current_info_list = AXIS2_DIR_HANDLER_LIST_DIR(env, module_path);
+
+ size = AXIS2_ARRAY_LIST_SIZE(listener_impl->current_info_list, env);
+ for (i = 0; i< size; i++) /* loop until empty */
+ {
+ axis2_file_t *file = NULL;
+ file = AXIS2_ARRAY_LIST_GET(listener_impl->current_info_list, env, i);
+ AXIS2_WS_INFO_LIST_ADD_WS_INFO_ITEM(listener_impl->info_list, env,
+ file, AXIS2_MODULE);
+ }
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_check_svcs(axis2_repos_listener_t *listener,
+ axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+ axis2_char_t *module_path = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(listener, env, AXIS2_FAILURE);
+ listener_impl = AXIS2_INTF_TO_IMPL(listener);
+ module_path = AXIS2_STRACAT(listener_impl->folder_name, AXIS2_SVC_PATH, env);
+
+ /* service archives */
+ return axis2_repos_listener_search_WS(listener, env, module_path, AXIS2_SVC);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_update(axis2_repos_listener_t *listener,
+ axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(listener, env, AXIS2_FAILURE);
+ listener_impl = AXIS2_INTF_TO_IMPL(listener);
+ /* TODO completet this */
+ /* this call the update method of WSInfoList */
+ return AXIS2_WS_INFO_LIST_UPDATE(listener_impl->info_list, env);
+}
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_init(axis2_repos_listener_t *listener,
+ axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(listener, env, AXIS2_FAILURE);
+ listener_impl = AXIS2_INTF_TO_IMPL(listener);
+
+ AXIS2_WS_INFO_LIST_INIT(listener_impl->info_list, env);
+ axis2_repos_listener_check_modules(listener, env);
+ axis2_repos_listener_check_svcs(listener, env);
+ axis2_repos_listener_update(listener, env);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_repos_listener_start_listen(axis2_repos_listener_t *listener,
+ axis2_env_t **env)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(listener, env, AXIS2_FAILURE);
+ listener_impl = AXIS2_INTF_TO_IMPL(listener);
+
+ AXIS2_WS_INFO_LIST_INIT(listener_impl->info_list, env);
+ /* axis2_repos_listener_check_modules(listener, env); */
+ axis2_repos_listener_check_svcs(listener, env);
+ axis2_repos_listener_update(listener, env);
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t
+axis2_repos_listener_search_WS(axis2_repos_listener_t *listener,
+ axis2_env_t **env,
+ axis2_char_t *folder_name,
+ int type)
+{
+ axis2_repos_listener_impl_t *listener_impl = NULL;
+ int size = 0;
+ int i = 0;
+
+ AXIS2_FUNC_PARAM_CHECK(listener, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, folder_name, AXIS2_FAILURE);
+ listener_impl = AXIS2_INTF_TO_IMPL(listener);
+
+ listener_impl->current_info_list = AXIS2_DIR_HANDLER_LIST_DIR(env, folder_name);
+
+ size = AXIS2_ARRAY_LIST_SIZE(listener_impl->current_info_list, env);
+ for (i = 0; i< size; i++) /* loop until empty */
+ {
+ axis2_file_t *file = NULL;
+ file = AXIS2_ARRAY_LIST_GET(listener_impl->current_info_list, env, i);
+ AXIS2_WS_INFO_LIST_ADD_WS_INFO_ITEM(listener_impl->info_list, env,
+ file, AXIS2_SVC);
+ }
+ return AXIS2_SUCCESS;
+}
Modified: webservices/axis2/trunk/c/modules/core/deployment/svc_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/svc_builder.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/svc_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/svc_builder.c Fri Jan 6 03:59:44 2006
@@ -110,9 +110,9 @@
}
axis2_svc_builder_t * AXIS2_CALL
-axis2_svc_builder_create_with_file_and_dep_engine_svc (axis2_env_t **env,
+axis2_svc_builder_create_with_file_and_dep_engine_and_svc (axis2_env_t **env,
axis2_char_t *file_name,
- axis2_dep_engine_t *dep_engine,
+ struct axis2_dep_engine *dep_engine,
axis2_svc_t *svc)
{
axis2_svc_builder_impl_t *builder_impl = NULL;
Modified: webservices/axis2/trunk/c/modules/core/deployment/svc_grp_builder.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/svc_grp_builder.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/svc_grp_builder.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/svc_grp_builder.c Fri Jan 6 03:59:44 2006
@@ -89,7 +89,7 @@
return &(svc_grp_builder_impl->svc_grp_builder);
}
-
+/*
axis2_svc_grp_builder_t * AXIS2_CALL
axis2_svc_grp_builder_create_with_svc_and_dep_engine (axis2_env_t **env,
axis2_om_node_t *svc,
@@ -109,7 +109,7 @@
return &(grp_builder_impl->svc_grp_builder);
}
-
+*/
/***************************Function implementation****************************/
axis2_status_t AXIS2_CALL
Modified: webservices/axis2/trunk/c/modules/core/deployment/ws_info_list.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/deployment/ws_info_list.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/deployment/ws_info_list.c (original)
+++ webservices/axis2/trunk/c/modules/core/deployment/ws_info_list.c Fri Jan 6 03:59:44 2006
@@ -17,6 +17,7 @@
#include <axis2_ws_info_list.h>
#include <string.h>
#include <axis2_class_loader.h>
+/* #include <axis2_dep_engine.h> */
/**
* @brief
@@ -38,7 +39,7 @@
/**
* Referance to DeploymentEngine to make update
*/
- axis2_dep_engine_t *deployer;
+ struct axis2_dep_engine *deployer;
} axis2_ws_info_list_impl_t;
@@ -51,6 +52,40 @@
axis2_ws_info_list_free (axis2_ws_info_list_t *ws_info_list,
axis2_env_t **env);
+axis2_status_t AXIS2_CALL
+axis2_ws_info_list_init(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_ws_info_list_add_ws_info_item(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env,
+ axis2_file_t *file,
+ int type);
+
+axis2_ws_info_t *AXIS2_CALL
+axis2_ws_info_list_get_file_item(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env,
+ axis2_char_t *file_name);
+
+axis2_bool_t AXIS2_CALL
+axis2_ws_info_list_is_modified(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env,
+ axis2_file_t *file,
+ axis2_ws_info_t *ws_info);
+
+axis2_bool_t AXIS2_CALL
+axis2_ws_info_list_is_file_exist(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env,
+ axis2_char_t *file_name);
+
+axis2_status_t AXIS2_CALL
+axis2_ws_info_list_check_for_undeploy(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env);
+
+
+axis2_status_t AXIS2_CALL
+axis2_ws_info_list_update(axis2_ws_info_list_t *info_list,
+ axis2_env_t **env);
@@ -58,7 +93,7 @@
axis2_ws_info_list_t * AXIS2_CALL
axis2_ws_info_list_create_with_dep_engine (axis2_env_t **env,
- axis2_dep_engine_t *dep_engine)
+ struct axis2_dep_engine *dep_engine)
{
axis2_ws_info_list_impl_t *ws_info_list_impl = NULL;
@@ -90,7 +125,19 @@
return NULL;
}
- ws_info_list_impl->ws_info_list.ops->free = axis2_ws_info_list_free;
+ ws_info_list_impl->ws_info_list.ops->free = axis2_ws_info_list_free;
+ ws_info_list_impl->ws_info_list.ops->init = axis2_ws_info_list_init;
+ ws_info_list_impl->ws_info_list.ops->add_ws_info_item =
+ axis2_ws_info_list_add_ws_info_item;
+ ws_info_list_impl->ws_info_list.ops->get_file_item =
+ axis2_ws_info_list_get_file_item;
+ ws_info_list_impl->ws_info_list.ops->is_modified =
+ axis2_ws_info_list_is_modified;
+ ws_info_list_impl->ws_info_list.ops->is_file_exist =
+ axis2_ws_info_list_is_file_exist;
+ ws_info_list_impl->ws_info_list.ops->check_for_undeploy =
+ axis2_ws_info_list_check_for_undeploy;
+ ws_info_list_impl->ws_info_list.ops->update = axis2_ws_info_list_update;
return &(ws_info_list_impl->ws_info_list);
}
@@ -129,9 +176,6 @@
return AXIS2_SUCCESS;
}
-/**
- * This method is used to initialize the vector
- */
axis2_status_t AXIS2_CALL
axis2_ws_info_list_init(axis2_ws_info_list_t *info_list,
axis2_env_t **env)
@@ -160,20 +204,6 @@
return AXIS2_SUCCESS;
}
-/**
- * First it check whether the file is already available in the
- * system call isFileExist , if it is not deployed yet then it will add
- * that to jarlist and to the deployment engine as new service or module
- * in adding new item to jarlist it first create optimice and requird object to
- * keep those infor call WSInfo and that will be added to jarist and actual
- * jar file will be added to DeploymentEngine
- * <p/>
- * If it is alredy exsit then it check whether it has been updated
- * then change the last update date of the wsInfo and added two entries to
- * DeploymentEngine one for New Deployment and other for undeployment
- * @param file actual jar files for either Module or service
- * @param type indicate either Service or Module
- */
axis2_status_t AXIS2_CALL
axis2_ws_info_list_add_ws_info_item(axis2_ws_info_list_t *info_list,
axis2_env_t **env,
@@ -244,12 +274,6 @@
return status;
}
-/**
- * This method is used to check whether the file exist and if so
- * it will return related wsinfo object to the file, else return null;
- *
- * @param filename
- */
axis2_ws_info_t *AXIS2_CALL
axis2_ws_info_list_get_file_item(axis2_ws_info_list_t *info_list,
axis2_env_t **env,
@@ -279,13 +303,6 @@
return NULL;
}
-/**
- * compare the last update dates of both files and if those differ
- * it will assumed as the file has been modified
- *
- * @param file
- * @param ws_info
- */
axis2_bool_t AXIS2_CALL
axis2_ws_info_list_is_modified(axis2_ws_info_list_t *info_list,
axis2_env_t **env,
@@ -302,11 +319,6 @@
return (last_modified_date != file->time_stamp);
}
-/**
- * to check whether the file is alredy in the list
- *
- * @param filename
- */
axis2_bool_t AXIS2_CALL
axis2_ws_info_list_is_file_exist(axis2_ws_info_list_t *info_list,
axis2_env_t **env,
@@ -320,13 +332,6 @@
return !(ws_info == NULL);
}
-/**
- * this is to check , undeploye WS
- * What this relly does is it check older jars files and
- * current jars. If name of the old jar file does not exit in the currentjar
- * list then it is assumed that the jar file has been removed
- * that is hot undeployment
- */
axis2_status_t AXIS2_CALL
axis2_ws_info_list_check_for_undeploy(axis2_ws_info_list_t *info_list,
axis2_env_t **env)
@@ -396,10 +401,6 @@
return AXIS2_SUCCESS;
}
-
-/**
- *
- */
axis2_status_t AXIS2_CALL
axis2_ws_info_list_update(axis2_ws_info_list_t *info_list,
axis2_env_t **env)
Modified: webservices/axis2/trunk/c/modules/core/description/module_desc.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/description/module_desc.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/description/module_desc.c (original)
+++ webservices/axis2/trunk/c/modules/core/description/module_desc.c Fri Jan 6 03:59:44 2006
@@ -24,6 +24,8 @@
{
axis2_module_desc_t module_desc;
+ axis2_module_t *module;
+
axis2_qname_t *qname;
axis2_conf_t *parent;
@@ -125,6 +127,15 @@
axis2_module_desc_is_param_locked (axis2_module_desc_t *module_desc,
axis2_env_t **env,
axis2_char_t *param_name);
+
+axis2_module_t *AXIS2_CALL
+axis2_module_desc_get_module(axis2_module_desc_t *module_desc,
+ axis2_env_t **env);
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_module(axis2_module_desc_t *module_desc,
+ axis2_env_t **env,
+ axis2_module_t *module);
/************************** End of function prototypes ************************/
@@ -145,6 +156,7 @@
}
module_desc_impl->qname = NULL;
+ module_desc_impl->module = NULL;
module_desc_impl->parent = NULL;
module_desc_impl->module_desc.params = NULL;
module_desc_impl->module_desc.flow_container = NULL;
@@ -188,6 +200,8 @@
module_desc_impl->module_desc.ops->set_inflow = axis2_module_desc_set_inflow;
module_desc_impl->module_desc.ops->get_outflow = axis2_module_desc_get_outflow;
module_desc_impl->module_desc.ops->set_outflow = axis2_module_desc_set_outflow;
+ module_desc_impl->module_desc.ops->get_module = axis2_module_desc_get_module;
+ module_desc_impl->module_desc.ops->set_module = axis2_module_desc_set_module;
module_desc_impl->module_desc.ops->get_fault_inflow =
axis2_module_desc_get_fault_inflow;
@@ -566,4 +580,23 @@
}
return ret_state;
+}
+
+axis2_module_t *AXIS2_CALL
+axis2_module_desc_get_module(axis2_module_desc_t *module_desc,
+ axis2_env_t **env)
+{
+ AXIS2_FUNC_PARAM_CHECK(module_desc, env, NULL);
+ return AXIS2_INTF_TO_IMPL(module_desc)->module;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_module_desc_set_module(axis2_module_desc_t *module_desc,
+ axis2_env_t **env,
+ axis2_module_t *module)
+{
+ AXIS2_FUNC_PARAM_CHECK(module_desc, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, module, AXIS2_FAILURE);
+ AXIS2_INTF_TO_IMPL(module_desc)->module = module;
+ return AXIS2_SUCCESS;
}
Modified: webservices/axis2/trunk/c/modules/core/engine/Makefile.am
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/engine/Makefile.am?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/Makefile.am (original)
+++ webservices/axis2/trunk/c/modules/core/engine/Makefile.am Fri Jan 6 03:59:44 2006
@@ -19,4 +19,6 @@
-I$(top_builddir)/modules/core/description \
-I$(top_builddir)/modules/wsdl \
-I$(top_builddir)/modules/core/transport \
+ -I$(top_builddir)/modules/xml/parser \
+ -I$(top_builddir)/modules/core/deployment \
-I$(top_builddir)/modules/platforms
Modified: webservices/axis2/trunk/c/modules/core/engine/conf.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/core/engine/conf.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/core/engine/conf.c (original)
+++ webservices/axis2/trunk/c/modules/core/engine/conf.c Fri Jan 6 03:59:44 2006
@@ -17,6 +17,9 @@
#include <string.h>
#include <axis2_conf.h>
+#include <axis2_dir_handler.h>
+#include <axis2_dep_engine.h>
+
typedef struct axis2_conf_impl axis2_conf_impl_t;
@@ -49,6 +52,7 @@
axis2_hash_t *msg_recvs;
axis2_hash_t *faulty_svcs;
axis2_hash_t *faulty_modules;
+ axis2_char_t *axis2_repos;
};
@@ -261,8 +265,18 @@
axis2_status_t AXIS2_CALL
axis2_conf_set_dispatch_phase(axis2_conf_t *conf,
axis2_env_t **env,
- axis2_phase_t *dispatch);
-
+ axis2_phase_t *dispatch);
+
+axis2_status_t AXIS2_CALL
+axis2_conf_set_repos(axis2_conf_t *conf,
+ axis2_env_t **env,
+ axis2_char_t *axis2_repos);
+
+axis2_status_t AXIS2_CALL
+axis2_conf_engage_module(axis2_conf_t *conf,
+ axis2_env_t **env,
+ axis2_qname_t *module_ref);
+
/************************** End of function prototypes ************************/
axis2_conf_t * AXIS2_CALL
@@ -294,6 +308,7 @@
config_impl->msg_recvs = NULL;
config_impl->faulty_svcs = NULL;
config_impl->faulty_modules = NULL;
+ config_impl->axis2_repos = NULL;
config_impl->conf.ops = NULL;
axis2_status_t status = AXIS2_FAILURE;
@@ -536,7 +551,8 @@
axis2_conf_add_module;
config_impl->conf.ops->set_default_dispatchers =
axis2_conf_set_default_dispatchers;
- config_impl->conf.ops->set_dispatch_phase = axis2_conf_set_dispatch_phase;
+ config_impl->conf.ops->set_dispatch_phase = axis2_conf_set_dispatch_phase;
+ config_impl->conf.ops->set_repos = axis2_conf_set_repos;
return &(config_impl->conf);
}
@@ -1632,6 +1648,80 @@
AXIS2_PHASE_FREE(post_dispatch, env);
AXIS2_DISP_CHECKER_FREE(disp_checker, env);
return AXIS2_FAILURE;
+ }
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_conf_set_repos(axis2_conf_t *conf,
+ axis2_env_t **env,
+ axis2_char_t *axis2_repos)
+{
+ AXIS2_FUNC_PARAM_CHECK(conf, env, AXIS2_FAILURE);
+ AXIS2_INTF_TO_IMPL(conf)->axis2_repos = axis2_repos;
+ return AXIS2_SUCCESS;
+}
+
+axis2_status_t AXIS2_CALL
+axis2_conf_engage_module(axis2_conf_t *conf,
+ axis2_env_t **env,
+ axis2_qname_t *module_ref)
+{
+ axis2_conf_impl_t *config_impl = NULL;
+ axis2_module_desc_t *module_desc = NULL;
+ axis2_bool_t is_new_module = AXIS2_FAILURE;
+ axis2_bool_t to_be_engaged = AXIS2_TRUE;
+ struct axis2_dep_engine *dep_engine = NULL;
+
+ AXIS2_FUNC_PARAM_CHECK(conf, env, AXIS2_FAILURE);
+ AXIS2_PARAM_CHECK((*env)->error, module_ref, AXIS2_FAILURE);
+ config_impl = AXIS2_INTF_TO_IMPL(conf);
+
+ module_desc = axis2_conf_get_module(conf, env, module_ref);
+ if(NULL == module_desc)
+ {
+ axis2_file_t *file = NULL;
+ file->name = AXIS2_QNAME_GET_LOCALPART(module_ref, env);
+ dep_engine = axis2_dep_engine_create(env);
+ module_desc = AXIS2_DEP_ENGINE_BUILD_MODULE(dep_engine, env, file, conf);
+ is_new_module = AXIS2_TRUE;
+ }
+ if(NULL != module_desc)
+ {
+ int size = 0;
+ int i = 0;
+
+ size = AXIS2_ARRAY_LIST_SIZE(config_impl->engaged_modules, env);
+ for(i = 0; i < size; i++)
+ {
+ axis2_qname_t *qname = NULL;
+
+ qname = (axis2_qname_t *) AXIS2_ARRAY_LIST_GET(config_impl->
+ engaged_modules, env, i);
+ if(AXIS2_TRUE == AXIS2_QNAME_EQUALS(module_ref, env, qname))
+ {
+ to_be_engaged = AXIS2_FALSE;
+ /* Instead of throwing the error, we can just log this problem */
+ /*log.info("Attempt to engage an already engaged module "+ qName);*/
+ }
+ }
+ }
+ else
+ {
+ AXIS2_ERROR_SET((*env)->error, AXIS2_ERROR_INVALID_MODULE, AXIS2_FAILURE);
+ return AXIS2_FAILURE;
+ }
+ if (to_be_engaged)
+ {
+ axis2_phase_resolver_t *phase_resolver = NULL;
+ phase_resolver = axis2_phase_resolver_create_with_config(env, conf);
+ AXIS2_PHASE_RESOLVER_ENGAGE_MODULE_GLOBALLY(phase_resolver, env,
+ module_desc);
+ AXIS2_ARRAY_LIST_ADD(config_impl->engaged_modules, env, module_ref);
+ }
+ if (is_new_module)
+ {
+ axis2_conf_add_module(conf, env, module_desc);
}
return AXIS2_SUCCESS;
}
Modified: webservices/axis2/trunk/c/modules/platforms/unix/axis2_unix.h
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/platforms/unix/axis2_unix.h?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/platforms/unix/axis2_unix.h (original)
+++ webservices/axis2/trunk/c/modules/platforms/unix/axis2_unix.h Fri Jan 6 03:59:44 2006
@@ -103,6 +103,8 @@
#include <sys/stat.h>
#include <sys/types.h>
+#define AXIS2_STRRCHR(x, y) (strrchr(x, y))
+
#define AXIS2_PLATFORM_SLEEP(x) sleep(0);
/**
@@ -151,7 +153,9 @@
/**
* Platform specific path separator char
*/
-#define AXIS2_PATH_SEP_CHAR "/"
+#define AXIS2_PATH_SEP_CHAR '/'
+#define AXIS2_PATH_SEP_STR "/"
+
/**
* Platform specific time
Modified: webservices/axis2/trunk/c/modules/util/class_loader.c
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/c/modules/util/class_loader.c?rev=366485&r1=366484&r2=366485&view=diff
==============================================================================
--- webservices/axis2/trunk/c/modules/util/class_loader.c (original)
+++ webservices/axis2/trunk/c/modules/util/class_loader.c Fri Jan 6 03:59:44 2006
@@ -49,6 +49,7 @@
void *svc_skeli = NULL; /* axis2_svc_skeleton */
void *msg_recv = NULL; /* axis2_msg_recv */
void *handler = NULL; /* axis2_handler */
+ void *module = NULL; /* axis2_module */
CREATE_FUNCT create_funct = NULL;
axis2_dll_desc_t *dll_desc = NULL;
axis2_status_t status = AXIS2_FAILURE;
@@ -124,6 +125,17 @@
return NULL;
}
return handler;
+ }
+ if(AXIS2_MODULE_DLL == dll_type)
+ {
+ create_funct(&module);
+ if(NULL == module)
+ {
+ AXIS2_ERROR_SET((*env)->error,
+ AXIS2_ERROR_MODULE_CREATION_FAILED,AXIS2_FAILURE);
+ return NULL;
+ }
+ return module;
}
if(AXIS2_MSG_RECV_DLL == dll_type)
{