amxd_transaction.c File Reference

#include <stdlib.h>
#include <string.h>
#include "amxd_priv.h"
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_event.h>
#include <amxd/amxd_transaction.h>
#include <amxd/amxd_path.h>
#include "amxd_assert.h"

Go to the source code of this file.

Data Structures
struct	_validate

Typedefs
typedef struct _validate	validate_t

Functions
static void	amxd_trans_delete_action (amxd_trans_action_t **trans)
static void	amxd_trans_free_action_it (amxc_llist_it_t *it)
static void	amxd_trans_free_validate_it (amxc_llist_it_t *it)
static amxd_object_t *	amxd_get_instance_from_args (amxd_object_t *templ, amxc_var_t *args)
static amxd_trans_action_t *	amxd_trans_new_action (amxd_trans_t *trans, amxd_action_t reason)
static amxd_trans_action_t *	amxd_trans_find_write_action (amxd_trans_t *trans)
static amxd_object_t *	amxd_trans_select (amxd_dm_t *dm, amxd_object_t *object, amxc_var_t *data)
static amxd_object_t *	amxd_trans_select_instance (amxd_object_t *object, amxd_trans_t *rollback, amxc_var_t *data)
static void	amxd_trans_store_all_params (amxd_object_t *object, const char *param, amxc_var_t *revert_params)
static void	amxd_trans_revert_write (amxd_object_t *object, amxd_trans_t *rollback, amxc_var_t *data)
static void	amxd_trans_add_garbage (amxd_trans_t *trans, amxc_var_t *data)
static void	amxd_trans_add_validate (amxd_trans_t *trans, amxd_object_t *object, amxd_action_t reason, amxc_var_t *data)
static void	amxd_trans_action_start (amxd_trans_t *trans, amxd_trans_action_t *action, amxd_trans_t *rollback)
static amxd_status_t	amxd_trans_action_end (amxd_trans_t *trans, amxd_trans_action_t *action, amxd_trans_t *rollback, amxc_var_t *retval)
static amxd_status_t	amxd_trans_invoke_action (amxd_trans_t *trans, amxd_dm_t *dm, amxd_trans_action_t *action, amxd_trans_t *rollback)
static void	amxd_trans_collect_garbage (amxd_trans_t *trans, amxd_dm_t *dm)
static void	amxd_trans_revert (amxd_trans_t *trans, amxd_dm_t *dm)
static void	amxd_trans_emit_changed (UNUSED amxd_object_t *object, amxc_var_t *params)
static amxd_status_t	amxd_trans_validate_objects (amxd_trans_t *trans, amxd_dm_t *dm)
static void	amxd_trans_dump_action (amxd_trans_action_t *action, int fd)
amxd_status_t	amxd_trans_init (amxd_trans_t *const trans)
	Initializes a transaction object. More...
void	amxd_trans_clean (amxd_trans_t *const trans)
	Cleans the transaction object. More...
amxd_status_t	amxd_trans_new (amxd_trans_t **trans)
	Allocates a transaction object on the heap and initializes it. More...
void	amxd_trans_delete (amxd_trans_t **trans)
	Frees the memory previously allocated for a transaction object. More...
amxd_status_t	amxd_trans_set_attr (amxd_trans_t *trans, amxd_tattr_id_t attr, bool enable)
	Set the transaction attributes. More...
amxd_status_t	amxd_trans_add_action (amxd_trans_t *const trans, const amxd_action_t reason, const amxc_var_t *data)
	Adds an action to a transaction. More...
amxd_status_t	amxd_trans_select_pathf (amxd_trans_t *const trans, const char *path,...)
amxd_status_t	amxd_trans_select_object (amxd_trans_t *const trans, const amxd_object_t *const object)
	Selects an object using an object pointer. More...
amxd_status_t	amxd_trans_set_param (amxd_trans_t *trans, const char *param_name, amxc_var_t *const value)
	Adds a set value action to a transaction. More...
amxd_status_t	amxd_trans_add_inst (amxd_trans_t *const trans, const uint32_t index, const char *name)
	Adds an instance add action to a transaction. More...
amxd_status_t	amxd_trans_del_inst (amxd_trans_t *const trans, const uint32_t index, const char *name)
	Adds an instance delete action to a transaction. More...
amxd_status_t	amxd_trans_add_mib (amxd_trans_t *const trans, const char *mib_name)
amxd_status_t	amxd_trans_apply (amxd_trans_t *const trans, amxd_dm_t *const dm)
	Applies all previously added actions. More...
void	amxd_trans_dump (const amxd_trans_t *const trans, const int fd, const bool reverse)
	Dumps the transaction to a file descriptor. More...

Typedef Documentation

validate_t

typedef struct _validate validate_t

Function Documentation

amxd_get_instance_from_args()

static amxd_object_t* amxd_get_instance_from_args ( amxd_object_t *  templ, amxc_var_t *  args  )

static

Definition at line 92 of file amxd_transaction.c.

                                                                    {
    amxd_object_t* instance = NULL;
    amxc_var_t* var_index = amxc_var_get_key(args, "index", AMXC_VAR_FLAG_DEFAULT);
    amxc_var_t* var_name = amxc_var_get_key(args, "name", AMXC_VAR_FLAG_DEFAULT);
 
    uint32_t index = amxc_var_dyncast(uint32_t, var_index);
    char* name = amxc_var_dyncast(cstring_t, var_name);
    instance = amxd_object_get_instance(templ, name, index);
    free(name);
 
    return instance;
}

amxd_trans_action_end()

static amxd_status_t amxd_trans_action_end ( amxd_trans_t *  trans, amxd_trans_action_t *  action, amxd_trans_t *  rollback, amxc_var_t *  retval  )

static

Definition at line 323 of file amxd_transaction.c.

                                                               {
    amxd_status_t status = amxd_status_ok;
    if(action->action == action_object_add_inst) {
        trans->current = amxd_trans_select_instance(trans->current,
                                                    rollback,
                                                    retval);
        when_null_status(trans->current,
                         exit,
                         status = amxd_status_object_not_found);
        if(rollback != NULL) {
            amxd_trans_add_validate(trans, trans->current, action->action, NULL);
        }
    } else if(action->action == action_object_del_inst) {
        amxd_object_t* inst = amxd_trans_select_instance(trans->current,
                                                         NULL,
                                                         &action->data);
        amxd_trans_add_garbage(trans, &action->data);
        amxd_trans_add_validate(trans, inst, action->action, NULL);
    }
 
exit:
    return status;
}

amxd_trans_action_start()

static void amxd_trans_action_start ( amxd_trans_t *  trans, amxd_trans_action_t *  action, amxd_trans_t *  rollback  )

static

Definition at line 308 of file amxd_transaction.c.

                                                            {
    if(action->action == action_object_write) {
        if(rollback != NULL) {
            amxc_llist_it_t* it = NULL;
            amxd_trans_action_t* raction = NULL;
            amxd_trans_revert_write(trans->current, rollback, &action->data);
            it = amxc_llist_get_last(&rollback->actions);
            raction = amxc_llist_it_get_data(it, amxd_trans_action_t, it);
            amxd_trans_add_validate(trans, trans->current, action->action, &raction->data);
        }
    }
}

amxd_trans_add_garbage()

static void amxd_trans_add_garbage ( amxd_trans_t *  trans, amxc_var_t *  data  )

static

Definition at line 253 of file amxd_transaction.c.

                                                     {
    amxd_object_t* object = amxd_get_instance_from_args(trans->current, data);
    amxc_string_t* path = (amxc_string_t*) calloc(1, sizeof(amxc_string_t));
    char* object_path = amxd_object_get_path(object,
                                             AMXD_OBJECT_INDEXED |
                                             AMXD_OBJECT_TERMINATE);
    amxc_string_init(path, 0);
    amxc_string_push_buffer(path, object_path, strlen(object_path) + 1);
    amxc_llist_append(&trans->garbage, &path->it);
}

amxd_trans_add_mib()

amxd_status_t amxd_trans_add_mib	(	amxd_trans_t *const	trans,
		const char *	mib_name
	)

Definition at line 815 of file amxd_transaction.c.

                                                       {
    amxd_status_t status = amxd_status_unknown_error;
    amxd_trans_action_t* action = NULL;
 
    when_null(trans, exit);
 
    action = amxd_trans_new_action(trans, action_object_add_mib);
    when_null(action, exit);
    when_str_empty(mib_name, exit);
 
    when_null(amxc_var_add_key(cstring_t,
                               &action->data,
                               "mib",
                               mib_name),
              exit);
 
    status = amxd_status_ok;
 
exit:
    if(trans != NULL) {
        trans->status = status;
    }
    return status;
}

amxd_trans_add_validate()

static void amxd_trans_add_validate ( amxd_trans_t *  trans, amxd_object_t *  object, amxd_action_t  reason, amxc_var_t *  data  )

static

Definition at line 265 of file amxd_transaction.c.

                                                      {
    validate_t* val_info = NULL;
    char* object_path = amxd_object_get_path(object,
                                             AMXD_OBJECT_INDEXED |
                                             AMXD_OBJECT_TERMINATE);
    size_t path_len = strlen(object_path);
 
    amxc_llist_for_each(it, (&trans->validate)) {
        size_t length = 0;
        val_info = amxc_llist_it_get_data(it, validate_t, it);
        length = strlen(val_info->path);
        if(length <= path_len) {
            if((length == path_len) &&
               ( strcmp(object_path, val_info->path) == 0) &&
               ( val_info->reason == action_object_write)) {
                break;
            }
        }
        val_info = NULL;
    }
 
    if(val_info != NULL) {
        amxc_var_t* event_params = GET_ARG(val_info->event_data, "parameters");
        amxc_var_for_each(var, GET_ARG(data, "parameters")) {
            amxc_var_set_key(event_params, amxc_var_key(var), var, AMXC_VAR_FLAG_DEFAULT);
        }
        free(object_path);
    } else {
        val_info = (validate_t*) calloc(1, sizeof(validate_t));
        when_null(val_info, exit);
        val_info->path = object_path;
        val_info->reason = reason;
        val_info->event_data = data;
        amxc_llist_append(&trans->validate, &val_info->it);
    }
 
exit:
    return;
}

amxd_trans_collect_garbage()

static void amxd_trans_collect_garbage ( amxd_trans_t *  trans, amxd_dm_t *  dm  )

static

Definition at line 389 of file amxd_transaction.c.

                                                      {
    amxc_llist_for_each_reverse(it, (&trans->garbage)) {
        amxc_string_t* path = amxc_string_from_llist_it(it);
        amxd_object_t* object = amxd_dm_findf(dm, "%s", amxc_string_get(path, 0));
        if(object != NULL) {
            amxd_dm_invoke_action(object, NULL, action_object_destroy, NULL, NULL);
        }
    }
    amxc_llist_clean(&trans->garbage, amxc_string_list_it_free);
}

amxd_trans_delete_action()

static void amxd_trans_delete_action ( amxd_trans_action_t **  trans )

static

Definition at line 75 of file amxd_transaction.c.

                                                                  {
    amxc_var_clean(&(*trans)->data);
    free(*trans);
    *trans = NULL;
}

amxd_trans_dump_action()

static void amxd_trans_dump_action ( amxd_trans_action_t *  action, int  fd  )

static

Definition at line 483 of file amxd_transaction.c.

                                                                        {
    switch(action->action) {
    case action_any:
        when_true(write(fd, "SELECT - \n", 10) == -1, exit);
        break;
    case action_object_write:
        when_true(write(fd, "SET - \n", 7) == -1, exit);
        break;
    case action_object_add_inst:
        when_true(write(fd, "ADD - \n", 7) == -1, exit);
        break;
    case action_object_del_inst:
        when_true(write(fd, "DEL - \n", 7) == -1, exit);
        break;
    default:
        break;
    }
    amxc_var_dump(&action->data, fd);
    when_true(write(fd, "\n", 1) == -1, exit);
 
exit:
    return;
}

amxd_trans_emit_changed()

static void amxd_trans_emit_changed ( UNUSED amxd_object_t *  object, amxc_var_t *  params  )

static

Definition at line 411 of file amxd_transaction.c.

                                                                                      {
    amxd_path_t path;
    amxc_var_t objects;
 
    amxc_var_init(&objects);
    amxc_var_set_type(&objects, AMXC_VAR_ID_HTABLE);
 
    amxd_path_init(&path, NULL);
 
    amxc_var_for_each(param, params) {
        amxc_var_t* obj_params = NULL;
        const char* rel_obj_path = NULL;
 
        amxd_path_setf(&path, false, "%s", amxc_var_key(param));
        rel_obj_path = amxd_path_get(&path, AMXD_OBJECT_TERMINATE);
        obj_params = GET_ARG(&objects, rel_obj_path);
 
        if(obj_params == NULL) {
            obj_params = amxc_var_add_key(amxc_htable_t, &objects, rel_obj_path, NULL);
        }
 
        amxc_var_set_key(obj_params, amxd_path_get_param(&path), param, AMXC_VAR_FLAG_DEFAULT);
    }
 
    amxc_var_for_each(object_params, &objects) {
        amxd_object_t* rel_obj = amxd_object_findf(object, "%s", amxc_var_key(object_params));
        amxd_object_emit_changed(rel_obj, object_params);
    }
 
    amxd_path_clean(&path);
    amxc_var_clean(&objects);
}

amxd_trans_find_write_action()

static amxd_trans_action_t* amxd_trans_find_write_action ( amxd_trans_t *  trans )

static

Definition at line 120 of file amxd_transaction.c.

                                                                              {
    amxd_trans_action_t* action = NULL;
    amxc_llist_for_each_reverse(it, (&trans->actions)) {
        action = amxc_llist_it_get_data(it, amxd_trans_action_t, it);
        if((action->action == action_object_write) ||
           ( action->action == action_object_add_inst)) {
            break;
        }
        if(action->action == action_any) {
            action = NULL;
            break;
        }
    }
 
    return action;
}

amxd_trans_free_action_it()

static void amxd_trans_free_action_it ( amxc_llist_it_t *  it )

static

Definition at line 81 of file amxd_transaction.c.

                                                           {
    amxd_trans_action_t* trans = amxc_llist_it_get_data(it, amxd_trans_action_t, it);
    amxd_trans_delete_action(&trans);
}

amxd_trans_free_validate_it()

static void amxd_trans_free_validate_it ( amxc_llist_it_t *  it )

static

Definition at line 86 of file amxd_transaction.c.

                                                             {
    validate_t* val = amxc_llist_it_get_data(it, validate_t, it);
    free(val->path);
    free(val);
}

amxd_trans_invoke_action()

static amxd_status_t amxd_trans_invoke_action ( amxd_trans_t *  trans, amxd_dm_t *  dm, amxd_trans_action_t *  action, amxd_trans_t *  rollback  )

static

Definition at line 350 of file amxd_transaction.c.

                                                                      {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_var_t* retval = amxc_var_add_new(&trans->retvals);
 
    if(action->action == action_any) {
        if((trans->current != NULL) && (rollback != NULL)) {
            amxd_trans_select_object(rollback, trans->current);
        }
        trans->current = amxd_trans_select(dm, trans->current, &action->data);
        when_null_status(trans->current,
                         exit,
                         status = amxd_status_object_not_found);
        status = amxd_status_ok;
    } else if(action->action == action_object_add_mib) {
        when_null_status(trans->current, exit, status = amxd_status_object_not_found);
        if(!amxd_object_has_mib(trans->current, GET_CHAR(&action->data, "mib"))) {
            status = amxd_object_add_mib(trans->current, GET_CHAR(&action->data, "mib"));
        } else {
            status = amxd_status_ok;
        }
    } else {
        when_null_status(trans->current, exit, status = amxd_status_object_not_found);
        amxd_trans_action_start(trans, action, rollback);
        status = amxd_dm_invoke_action(trans->current,
                                       NULL,
                                       action->action,
                                       &action->data,
                                       retval);
        when_failed(status, exit);
        status = amxd_trans_action_end(trans, action, rollback, retval);
    }
 
exit:
    return status;
}

amxd_trans_new_action()

static amxd_trans_action_t* amxd_trans_new_action ( amxd_trans_t *  trans, amxd_action_t  reason  )

static

Definition at line 106 of file amxd_transaction.c.

                                                                        {
    amxd_trans_action_t* action = (amxd_trans_action_t*) calloc(1, sizeof(amxd_trans_action_t));
    when_null(action, exit);
 
    action->action = reason;
    amxc_var_init(&action->data);
    amxc_var_set_type(&action->data, AMXC_VAR_ID_HTABLE);
    amxc_llist_append(&trans->actions, &action->it);
 
exit:
    return action;
}

amxd_trans_revert()

static void amxd_trans_revert ( amxd_trans_t *  trans, amxd_dm_t *  dm  )

static

Definition at line 401 of file amxd_transaction.c.

                                                                  {
    amxc_llist_for_each_reverse(it, (&trans->actions)) {
        amxd_trans_action_t* action =
            amxc_llist_it_get_data(it, amxd_trans_action_t, it);
        amxd_trans_invoke_action(trans, dm, action, NULL);
    }
 
    amxd_trans_collect_garbage(trans, dm);
}

amxd_trans_revert_write()

static void amxd_trans_revert_write ( amxd_object_t *  object, amxd_trans_t *  rollback, amxc_var_t *  data  )

static

Definition at line 222 of file amxd_transaction.c.

                                                      {
    const char* param_fields[] = { "parameters", "oparameters", NULL };
    amxd_trans_action_t* action = amxd_trans_new_action(rollback, action_object_write);
    amxc_var_t* revert_params = NULL;
    amxc_var_t* params = NULL;
    int index = 0;
    amxc_var_add_key(bool, &action->data, "set_read_only", true);
    amxc_var_add_key(uint32_t, &action->data, "access", amxd_dm_access_private);
    revert_params = amxc_var_add_key(amxc_htable_t, &action->data, "parameters", NULL);
    while(param_fields[index] != NULL) {
        params = GET_ARG(data, param_fields[index]);
        amxc_var_for_each(param, params) {
            amxd_param_t* param_def = NULL;
            if(GET_ARG(revert_params, amxc_var_key(param)) != NULL) {
                continue;
            }
            param_def = amxd_object_get_param_def(object, amxc_var_key(param));
            if(param_def == NULL) {
                amxd_trans_store_all_params(object, amxc_var_key(param), revert_params);
                continue;
            }
            if(!amxd_param_is_attr_set(param_def, amxd_pattr_variable)) {
                amxc_var_set_key(revert_params, amxc_var_key(param), &param_def->value, AMXC_VAR_FLAG_COPY);
            }
        }
        index++;
    }
}

amxd_trans_select()

static amxd_object_t* amxd_trans_select ( amxd_dm_t *  dm, amxd_object_t *  object, amxc_var_t *  data  )

static

Definition at line 137 of file amxd_transaction.c.

                                                          {
    amxd_object_t* result = NULL;
    amxc_var_t* var_path = amxc_var_get_key(data, "path", AMXC_VAR_FLAG_DEFAULT);
    const char* path = amxc_var_constcast(cstring_t, var_path);
 
    if((path == NULL) || (*path == 0)) {
        goto exit;
    }
 
    if(path[0] == '.') {
        result = amxd_object_findf(object, "%s", path + 1);
    } else {
        result = amxd_dm_findf(dm, "%s", path);
    }
 
exit:
    return result;
}

amxd_trans_select_instance()

static amxd_object_t* amxd_trans_select_instance ( amxd_object_t *  object, amxd_trans_t *  rollback, amxc_var_t *  data  )

static

Definition at line 158 of file amxd_transaction.c.

                                                                   {
    amxc_var_t* temp = NULL;
    uint32_t index = 0;
    const char* name = NULL;
 
    temp = amxc_var_get_key(data, "index", AMXC_VAR_FLAG_DEFAULT);
    index = amxc_var_dyncast(uint32_t, temp);
    temp = amxc_var_get_key(data, "name", AMXC_VAR_FLAG_DEFAULT);
    name = amxc_var_constcast(cstring_t, temp);
 
    if(rollback != NULL) {
        amxd_trans_del_inst(rollback, index, name);
        amxd_trans_select_object(rollback, object);
    }
    return amxd_object_get_instance(object, name, index);
}

amxd_trans_select_pathf()

amxd_status_t amxd_trans_select_pathf	(	amxd_trans_t *const	trans,
		const char *	path,
			...
	)

Definition at line 623 of file amxd_transaction.c.

                                           {
    amxd_status_t status = amxd_status_unknown_error;
    amxc_string_t full_path;
    amxd_trans_action_t* action = NULL;
    int length = 0;
    va_list args;
 
    amxc_string_init(&full_path, 64);
 
    when_null(trans, exit);
    when_null(path, exit);
 
    va_start(args, path);
    amxc_string_vsetf(&full_path, path, args);
    va_end(args);
 
    amxc_string_trim(&full_path, NULL);
    when_str_empty(amxc_string_get(&full_path, 0), exit);
    length = amxc_string_text_length(&full_path);
    if(amxc_string_get(&full_path, 0)[length - 1] != '.') {
        amxc_string_append(&full_path, ".", 1);
    }
 
    action = amxd_trans_new_action(trans, action_any);
    when_null(action, exit);
    when_null(amxc_var_add_key(cstring_t,
                               &action->data,
                               "path",
                               amxc_string_get(&full_path, 0)),
              exit);
 
    status = amxd_status_ok;
 
exit:
    if(trans != NULL) {
        trans->status = status;
    }
    amxc_string_clean(&full_path);
    return status;
}

amxd_trans_store_all_params()

static void amxd_trans_store_all_params ( amxd_object_t *  object, const char *  param, amxc_var_t *  revert_params  )

static

Definition at line 177 of file amxd_transaction.c.

                                                                   {
    amxc_var_t temp;
    amxd_path_t param_path;
    amxc_string_t p;
    const char* path = "";
 
    amxc_string_init(&p, 0);
    amxd_path_init(&param_path, param);
    amxc_var_init(&temp);
 
    path = amxd_path_get(&param_path, AMXD_OBJECT_TERMINATE);
 
    if(path != NULL) {
        if((strlen(path) <= 1) && (path[0] == '.')) {
            path = "";
        }
    } else {
        path = "";
    }
    object = amxd_object_findf(object, "%s", amxd_path_get(&param_path, AMXD_OBJECT_TERMINATE));
    amxc_var_set_type(&temp, AMXC_VAR_ID_HTABLE);
    amxd_object_get_params_filtered(object,
                                    &temp,
                                    "attributes.volatile==false",
                                    amxd_dm_access_private);
    amxc_var_for_each(t, &temp) {
        amxc_string_setf(&p,
                         "%s%s",
                         path,
                         amxc_var_key(t));
        if(GET_ARG(revert_params, amxc_string_get(&p, 0)) != NULL) {
            continue;
        }
        amxc_var_set_key(revert_params,
                         amxc_string_get(&p, 0),
                         t,
                         AMXC_VAR_FLAG_DEFAULT | AMXC_VAR_FLAG_UPDATE);
    }
    amxc_string_clean(&p);
    amxd_path_clean(&param_path);
    amxc_var_clean(&temp);
}

amxd_trans_validate_objects()

static amxd_status_t amxd_trans_validate_objects ( amxd_trans_t *  trans, amxd_dm_t *  dm  )

static

Definition at line 444 of file amxd_transaction.c.

                                                                {
    amxd_status_t status = amxd_status_ok;
 
    amxc_llist_for_each(it, (&trans->validate)) {
        validate_t* val = amxc_llist_it_get_data(it, validate_t, it);
        amxd_object_t* object = amxd_dm_findf(dm, "%s", val->path);
        if(val->reason != action_object_del_inst) {
            status = amxd_object_validate(object,
                                          val->reason != action_object_write ?
                                          INT32_MAX : 0);
            if(status != amxd_status_ok) {
                goto exit;
            }
        }
    }
 
    amxc_llist_for_each(it, (&trans->validate)) {
        validate_t* val = amxc_llist_it_get_data(it, validate_t, it);
        amxd_object_t* object = amxd_dm_findf(dm, "%s", val->path);
        if(val->reason == action_object_add_inst) {
            amxd_object_emit_add_inst(object);
        } else if(val->reason == action_object_del_inst) {
            amxd_object_emit_del_inst(object);
        } else if(val->reason == action_object_write) {
            amxc_var_t* params = GET_ARG(val->event_data, "parameters");
            if(params != NULL) {
                amxd_trans_emit_changed(object, params);
            }
        }
 
    }
 
    amxd_trans_collect_garbage(trans, dm);
 
exit:
    return status;
}