/*
 * 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 <axutil_array_list.h>
#include <axis2_deployment.h>
#include <axutil_file_handler.h>
#include <axutil_dll_desc.h>
#include <axis2_flow.h>
#include <axis2_arch_reader.h>
#include <axis2_module_builder.h>
#include <axis2_svc_builder.h>
#include <axis2_svc_grp_builder.h>
#include <axiom_node.h>
#include <axutil_class_loader.h>
#include <axutil_string.h>
#include <axutil_utils.h>
#include <axis2_core_utils.h>
#include <axis2_module.h>

struct axis2_dep_engine
{
    axis2_arch_file_data_t *curr_file;
    axis2_arch_reader_t *arch_reader;

    /**
     * to keep a ref to engine register
     * this ref will pass to engine when it call start()
     * method
     */
    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 */

    /**
     * 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 */

    /**
     * this constructor for the testing
     */
    axis2_char_t *folder_name;

    /**
     * Full path to the server xml file(axis2.xml)
     */
    axis2_char_t *conf_name;

    /**
     * To store the module specified in the server.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);

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);
        return NULL;
    }
    dep_engine->conf = NULL;
    dep_engine->axis2_repos = NULL;
    dep_engine->curr_file = NULL;
    dep_engine->arch_reader = NULL;
    dep_engine->ws_to_deploy = NULL;
    dep_engine->ws_to_undeploy = NULL;
    dep_engine->phases_info = NULL;
    dep_engine->module_list = NULL;
    dep_engine->folder_name = NULL;
    dep_engine->conf_name = 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);
        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);
        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;
    }

    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 (0 == axutil_strcmp("", repos_path))
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_REPO_CAN_NOT_BE_NULL,
            AXIS2_FAILURE);
        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);
        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);
        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);
        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);
        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);
        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);
        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->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_ENV_CHECK(env, AXIS2_FAILURE);
    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);
            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_name)
{
    AXIS2_PARAM_CHECK(env->error, module_name, NULL);

    return  axis2_conf_get_module(dep_engine->conf, env, module_name);
}

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)
{
    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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, file, 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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, file, 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)
{
    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)
{
    return dep_engine->conf;
}

/**
 * To set hotDeployment 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_ENV_CHECK(env, 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("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("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;
    axutil_array_list_t *new_out_fault_phases = NULL;
    AXIS2_ENV_CHECK(env, NULL);

    if (! dep_engine->conf_name)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_PATH_TO_CONFIG_CAN_NOT_BE_NULL,
            AXIS2_FAILURE);
        return NULL;
    }

    dep_engine->conf = axis2_conf_create(env);

    if (!dep_engine->conf)
    {
        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;
    }
    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;
        return NULL;
    }
    status = axis2_dep_engine_set_dep_features(dep_engine, env);
    if (AXIS2_SUCCESS != status)
    {
        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);
        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);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED,
            AXIS2_FAILURE);
        return NULL;
    }

    status =  axis2_conf_set_phases_info(dep_engine->conf, env,
        dep_engine->phases_info);
    out_fault_phases =
        axis2_phases_info_get_op_out_faultphases(dep_engine->phases_info, env);
    new_out_fault_phases = axis2_phases_info_copy_flow(env, out_fault_phases);
    if (out_fault_phases)
    {
        axutil_array_list_free(out_fault_phases, env);
    }
    axis2_conf_set_out_fault_phases(dep_engine->conf, env, new_out_fault_phases);
    if (AXIS2_SUCCESS != status)
    {
        axis2_repos_listener_free(dep_engine->repos_listener, env);
        axis2_conf_free(dep_engine->conf, env);
        return NULL;
    }

    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);
        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_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, client_home, NULL);

    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);
        return NULL;
    }
    if (client_home && 0 != 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
    {
        dep_engine->conf_name = axutil_strdup(env, AXIS2_CONFIGURATION_RESOURCE);
        if (!dep_engine->conf_name)
        {
            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
            return NULL;
        }
    }
    dep_engine->conf = axis2_conf_create(env);
    if (!dep_engine->conf)
    {
        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;
    }
    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;
        return NULL;
    }

    if (AXIS2_TRUE == 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_FAILURE == status)
    {
        axis2_repos_listener_free(dep_engine->repos_listener, env);
        axis2_conf_free(dep_engine->conf, env);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_MODULE_VALIDATION_FAILED,
            AXIS2_FAILURE);
        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);
        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)
            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);
        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_ENV_CHECK(env, AXIS2_FAILURE);

    if (!dep_engine->module_list)
    {
        /* there are no modules */
        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)
            {
                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_ENV_CHECK(env, 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;
}

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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, svc_metadata, 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);

        /*axis2_dep_engine_load_svc_props(dep_engine, env, svc);*/
        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 svc 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_DEBUG(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)
                {
                    return status;
                }
            }
            else
            {
                AXIS2_LOG_DEBUG(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);
                    return AXIS2_FAILURE;
                }
            }
        }
         axis2_svc_grp_add_svc(svc_metadata, env, svc);
    }
    return  axis2_conf_add_svc_grp(dep_engine->conf, env, 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)
{
    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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, module_desc, 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);
        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);
}


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_ENV_CHECK(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;
        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_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, 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);
    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;
}


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;

    status = axis2_dep_engine_load_module_dll(dep_engine, env, module_metadata);
    if (AXIS2_SUCCESS != status)
    {
        return status;
    }
    module = axis2_module_desc_get_module(module_metadata, env);
    if (!module)
    {
        return AXIS2_FAILURE;
    }
    status = AXIS2_MODULE_FILL_HANDLER_CREATE_FUNC_MAP(module, env);
    if (AXIS2_SUCCESS != status)
    {
        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);
    }

     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_ENV_CHECK(env, 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;
            axis2_arch_reader_t *arch_reader = 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:
                    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(arch_reader, env,
                        file_name, dep_engine, svc_grp);
                    if (AXIS2_SUCCESS != status)
                    {
                        axis2_arch_reader_free(arch_reader, env);
                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC,
                            AXIS2_FAILURE);
                        return status;
                    }
                    status = axis2_dep_engine_add_new_svc(dep_engine, env,
                        svc_grp);
                    if (AXIS2_SUCCESS != status)
                    {
                        axis2_arch_reader_free(arch_reader, env);
                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SVC,
                            AXIS2_FAILURE);
                        return status;
                    }
                    dep_engine->curr_file = NULL;
                    break;
                case AXIS2_MODULE:
                    arch_reader = axis2_arch_reader_create(env);
                    if (dep_engine->arch_reader)
                    {
                        axis2_arch_reader_free(dep_engine->arch_reader, env);
                    }
                    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(
                        dep_engine->arch_reader, env, file_name, dep_engine,
                            meta_data);
                    if (AXIS2_SUCCESS != status)
                    {
                        axis2_arch_reader_free(arch_reader, env);
                        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_arch_reader_free(arch_reader, env);
                        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_MODULE,
                            AXIS2_FAILURE);
                        return AXIS2_FAILURE;
                    }

                    dep_engine->curr_file = NULL;
                    break;
            }
            axis2_arch_reader_free(arch_reader, env);
        }
    }
    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_ENV_CHECK(env, 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 = 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_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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, phases_info, AXIS2_FAILURE);
    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
 */
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_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, file_name, 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);
    /*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
 */
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_ENV_CHECK(env, NULL);
    AXIS2_PARAM_CHECK(env->error, module_archive, NULL);
    AXIS2_PARAM_CHECK(env->error, conf, 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(arch_reader, 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);
        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);
        return NULL;
    }

    module = axis2_module_desc_get_module(module_desc, env);
    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)
{
    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_ENV_CHECK(env, 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_ENV_CHECK(env, 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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, module_builder, 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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, svc_builder, 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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, svc_grp_builder, 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_ENV_CHECK(env, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, desc_builder, AXIS2_FAILURE);

    return axutil_array_list_add(dep_engine->desc_builders, env, desc_builder);
}