src/core/deployment/ws_info_list.c

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <axis2_ws_info_list.h>
#include <string.h>
#include <axutil_class_loader.h>

struct axis2_ws_info_list
{
    /**
     * This is to store all the deployment info about the deployment files 
     * for services or modules in a specified folder.
     */
    axutil_array_list_t *ws_info_list;

    /**
     * All the curently updated deployment info list.
     */
    axutil_array_list_t *current_info_list;

    /**
     * Referance to deployment engine to make update.
     */
    struct axis2_dep_engine *dep_engine;

};

AXIS2_EXTERN axis2_ws_info_list_t *AXIS2_CALL
axis2_ws_info_list_create_with_dep_engine(
    const axutil_env_t * env,
    struct axis2_dep_engine *dep_engine)
{
    axis2_ws_info_list_t *ws_info_list = NULL;

    ws_info_list = (axis2_ws_info_list_t *)AXIS2_MALLOC(env->allocator,
        sizeof(axis2_ws_info_list_t));

    if(!ws_info_list)
    {
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    memset((void *)ws_info_list, 0, sizeof(axis2_ws_info_list_t));

    ws_info_list->dep_engine = dep_engine;

    ws_info_list->ws_info_list = axutil_array_list_create(env, 0);
    if(!(ws_info_list->ws_info_list))
    {
        axis2_ws_info_list_free(ws_info_list, env);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    ws_info_list->current_info_list = axutil_array_list_create(env, 0);
    if(!(ws_info_list->current_info_list))
    {
        axis2_ws_info_list_free(ws_info_list, env);
        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
        return NULL;
    }

    return ws_info_list;
}

AXIS2_EXTERN void AXIS2_CALL
axis2_ws_info_list_free(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env)
{
    if(ws_info_list->current_info_list)
    {
        int list_size = 0;
        int i = 0;

        list_size = axutil_array_list_size(ws_info_list->current_info_list, env);
        for(i = 0; i < list_size; i++)
        {
            axis2_char_t *file_name = NULL;

            file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list->current_info_list, env,
                i);
            AXIS2_FREE(env->allocator, file_name);
        }
        axutil_array_list_free(ws_info_list->current_info_list, env);
    }

    if(ws_info_list->ws_info_list)
    {
        int list_size = 0;
        int i = 0;

        list_size = axutil_array_list_size(ws_info_list->ws_info_list, env);
        for(i = 0; i < list_size; i++)
        {
            axis2_ws_info_t *ws_info = NULL;

            ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);
            axis2_ws_info_free(ws_info, env);
        }
        axutil_array_list_free(ws_info_list->ws_info_list, env);
    }

    if(ws_info_list)
    {
        AXIS2_FREE(env->allocator, ws_info_list);
    }

    return;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_ws_info_list_init(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env)
{
    int size = 0;
    int i = 0;

    size = axutil_array_list_size(ws_info_list->ws_info_list, env);
    for(i = 0; i < size; i++)
    {
        axis2_ws_info_t *ws_info = NULL;

        ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list->ws_info_list, env, i);
        axis2_ws_info_free(ws_info, env);
    }
    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_ws_info_list_add_ws_info_item(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env,
    axutil_file_t * file,
    int type)
{
    axis2_status_t status = AXIS2_FAILURE;
    axis2_char_t *file_name = NULL;
    axis2_char_t *temp_name = NULL;

    AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE);

    temp_name = axutil_file_get_name(file, env);
    file_name = axutil_strdup(env, temp_name);
    if(!file_name)
    {
        return AXIS2_FAILURE;
    }

    switch(type)
    {
        case AXIS2_SVC:
        {
            axis2_ws_info_t *ws_info = NULL;
            long last_modified_date = 0;
            axis2_arch_file_data_t *file_data = NULL;

            last_modified_date = (long)axutil_file_get_timestamp(file, env);
            /* We are sure that the difference lies within the long range */
            ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env,
                file_name, last_modified_date, AXIS2_SVC);
            status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info);

            if(AXIS2_SUCCESS != status)
            {
                return status;
            }
            file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_SVC, file);
            /* To inform that new web service is to be deployed */
            status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data);
            if(AXIS2_SUCCESS != status)
            {
                return status;
            }
            break;
        }
        case AXIS2_MODULE:
        {
            axis2_ws_info_t *ws_info = NULL;
            long last_modified_date = 0;
            axis2_arch_file_data_t *file_data = NULL;

            last_modified_date = (long)axutil_file_get_timestamp(file, env);
            /* We are sure that the difference lies within the long range */
            ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date_and_type(env,
                file_name, last_modified_date, AXIS2_MODULE);
            status = axutil_array_list_add(ws_info_list->ws_info_list, env, ws_info);

            if(AXIS2_SUCCESS != status)
            {
                return status;
            }
            file_data = axis2_arch_file_data_create_with_type_and_file(env, AXIS2_MODULE, file);
            /* To inform that new module is to be deployed */
            status = axis2_dep_engine_add_ws_to_deploy(ws_info_list->dep_engine, env, file_data);
            if(AXIS2_SUCCESS != status)
            {
                return status;
            }

            break;
        }
    }
    return axutil_array_list_add(ws_info_list->current_info_list, env, file_name);
}

AXIS2_EXTERN axis2_ws_info_t *AXIS2_CALL
axis2_ws_info_list_get_file_item(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env,
    axis2_char_t * file_name)
{
    int i = 0;
    int size = 0;
    AXIS2_PARAM_CHECK(env->error, file_name, NULL);

    size = axutil_array_list_size(ws_info_list->ws_info_list, env);
    for(i = 0; i < size; i++)
    {
        axis2_ws_info_t *ws_info = NULL;
        axis2_char_t *file_name_l = NULL;

        ws_info = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);

        file_name_l = axis2_ws_info_get_file_name(ws_info, env);
        if(!axutil_strcmp(file_name_l, file_name))
        {
            return ws_info;
        }
    }
    return NULL;
}

AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_ws_info_list_is_modified(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env,
    axutil_file_t * file,
    axis2_ws_info_t * ws_info)
{
    long last_modified_date = 0;

    AXIS2_PARAM_CHECK(env->error, file, AXIS2_FAILURE);
    AXIS2_PARAM_CHECK(env->error, ws_info, AXIS2_FAILURE);

    last_modified_date = axis2_ws_info_get_last_modified_date(ws_info, env);
    return (last_modified_date != axutil_file_get_timestamp(file, env));
}

AXIS2_EXTERN axis2_bool_t AXIS2_CALL
axis2_ws_info_list_is_file_exist(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env,
    axis2_char_t * file_name)
{
    axis2_ws_info_t *ws_info = NULL;

    AXIS2_PARAM_CHECK(env->error, file_name, AXIS2_FAILURE);
    ws_info = axis2_ws_info_list_get_file_item(ws_info_list, env, file_name);
    return !(ws_info == NULL);
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_ws_info_list_check_for_undeploy(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env)
{
    int list_size = 0;
    axutil_array_list_t *temp_list = NULL;
    int i = 0;

    /* Create temp list */
    temp_list = axutil_array_list_create(env, 0);
    if(!temp_list)
    {
        return AXIS2_FAILURE;
    }
    list_size = axutil_array_list_size(ws_info_list->ws_info_list, env);

    for(i = 0; i < list_size; i++)
    {
        /* For each ws_info item in the ws_info_list check whether it is also
         * in the current_info_list. If not mark it to be undeployed by adding
         * it to a temporarily list. Also add that item to the undeploy list of
         * deployment engine.*/
        int current_lists_size = 0;
        axis2_ws_info_t *file_item = NULL;
        axis2_char_t *file_item_name = NULL;
        axis2_bool_t exist = AXIS2_FALSE;
        int j = 0;

        file_item = (axis2_ws_info_t *)axutil_array_list_get(ws_info_list-> ws_info_list, env, i);

        file_item_name = axis2_ws_info_get_file_name(file_item, env);
        current_lists_size = axutil_array_list_size(ws_info_list->current_info_list, env);
        for(j = 0; j < current_lists_size; j++)
        {
            axis2_char_t *file_name = NULL;
            file_name = (axis2_char_t *)axutil_array_list_get(ws_info_list-> current_info_list,
                env, j);
            if(!axutil_strcmp(file_name, file_item_name))
            {
                exist = AXIS2_TRUE;
                break;
            }
        }

        if(!exist)
        {
            axis2_ws_info_t *ws_info = NULL;
            long last_modified_date = 0;

            last_modified_date = axis2_ws_info_get_last_modified_date(file_item, env);
            axutil_array_list_add(temp_list, env, file_item);
            ws_info = axis2_ws_info_create_with_file_name_and_last_modified_date(env,
                file_item_name, last_modified_date);
            /* This ws_info is to be undeployed */
            axis2_dep_engine_add_ws_to_undeploy(ws_info_list->dep_engine, env, ws_info);
        }

    }

    list_size = axutil_array_list_size(temp_list, env);
    for(i = 0; i < list_size; i++)
    {
        /* Get each ws_info item from the temp list created and remove that
         * item from the ws_info_list */
        axis2_ws_info_t *file_item = NULL;
        int index = 0;

        file_item = (axis2_ws_info_t *)axutil_array_list_get(temp_list, env, i);
        index = axutil_array_list_index_of(ws_info_list->ws_info_list, env, file_item);
        axutil_array_list_remove(ws_info_list->ws_info_list, env, index);
    }
    axutil_array_list_free(temp_list, env);
    return AXIS2_SUCCESS;
}

AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_ws_info_list_update(
    axis2_ws_info_list_t * ws_info_list,
    const axutil_env_t * env)
{
    axis2_status_t status = AXIS2_FAILURE;

    status = axis2_ws_info_list_check_for_undeploy(ws_info_list, env);
    if(AXIS2_SUCCESS != status)
    {
        return AXIS2_FAILURE;
    }

    return axis2_dep_engine_do_deploy(ws_info_list->dep_engine, env);
}