Git does not support the ability to replace a token with a version string during check-in. While it does have support for replacing a token on clone, this is somewhat sub-optimal: the token is replaced with the object hash, which is not particularly easy for human consumption. What's more, in practice, the source file version was often not terribly useful. Generally, when triaging bugs, the overall version of Asterisk is far more useful than an individual SVN version of a file. As a result, this patch removes Asterisk's support for showing source file versions. Specifically, it does the following: * Rename ASTERISK_FILE_VERSION macro to ASTERISK_REGISTER_FILE, and remove passing the version in with the macro. Other facilities than 'core show file version' make use of the file names, such as setting a debug level only on a specific file. As such, the act of registering source files with the Asterisk core still has use. The macro rename now reflects the new macro purpose. * main/asterisk: - Refactor the file_version structure to reflect that it no longer tracks a version field. - Remove the "core show file version" CLI command. Without the file version, it is no longer useful. - Remove the ast_file_version_find function. The file version is no longer tracked. - Rename ast_register_file_version/ast_unregister_file_version to ast_register_file/ast_unregister_file, respectively. * main/manager: Remove value from the Version key of the ModuleCheck Action. The actual key itself has not been removed, as doing so would absolutely constitute a backwards incompatible change. However, since the file version is no longer tracked, there is no need to attempt to include it in the Version key. * UPGRADE: Add notes for: - Modification to the ModuleCheck AMI Action - Removal of the "core show file version" CLI command Change-Id: I6cf0ff280e1668bf4957dc21f32a5ff43444a40e
393 lines
12 KiB
C
393 lines
12 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
*
|
|
* Joshua Colp <jcolp@digium.com>
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*!
|
|
* \file
|
|
*
|
|
* \brief Sorcery Astdb Object Wizard
|
|
*
|
|
* \author Joshua Colp <jcolp@digium.com>
|
|
*/
|
|
|
|
/*** MODULEINFO
|
|
<support_level>core</support_level>
|
|
***/
|
|
|
|
#include "asterisk.h"
|
|
|
|
ASTERISK_REGISTER_FILE()
|
|
|
|
#include <regex.h>
|
|
|
|
#include "asterisk/module.h"
|
|
#include "asterisk/sorcery.h"
|
|
#include "asterisk/astdb.h"
|
|
#include "asterisk/json.h"
|
|
|
|
static void *sorcery_astdb_open(const char *data);
|
|
static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object);
|
|
static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
|
|
static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
|
|
static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
|
|
const struct ast_variable *fields);
|
|
static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
|
|
static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object);
|
|
static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object);
|
|
static void sorcery_astdb_close(void *data);
|
|
|
|
static struct ast_sorcery_wizard astdb_object_wizard = {
|
|
.name = "astdb",
|
|
.open = sorcery_astdb_open,
|
|
.create = sorcery_astdb_create,
|
|
.retrieve_id = sorcery_astdb_retrieve_id,
|
|
.retrieve_fields = sorcery_astdb_retrieve_fields,
|
|
.retrieve_multiple = sorcery_astdb_retrieve_multiple,
|
|
.retrieve_regex = sorcery_astdb_retrieve_regex,
|
|
.update = sorcery_astdb_update,
|
|
.delete = sorcery_astdb_delete,
|
|
.close = sorcery_astdb_close,
|
|
};
|
|
|
|
/*! \brief Helper function which converts from a sorcery object set to a json object */
|
|
static struct ast_json *sorcery_objectset_to_json(const struct ast_variable *objectset)
|
|
{
|
|
struct ast_json *json = ast_json_object_create();
|
|
const struct ast_variable *field;
|
|
|
|
for (field = objectset; field; field = field->next) {
|
|
struct ast_json *value = ast_json_string_create(field->value);
|
|
|
|
if (!value) {
|
|
ast_json_unref(json);
|
|
return NULL;
|
|
} else if (ast_json_object_set(json, field->name, value)) {
|
|
ast_json_unref(json);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return json;
|
|
}
|
|
|
|
/*! \brief Helper function which converts a json object to a sorcery object set */
|
|
static struct ast_variable *sorcery_json_to_objectset(struct ast_json *json)
|
|
{
|
|
struct ast_json_iter *field;
|
|
struct ast_variable *objset = NULL;
|
|
|
|
for (field = ast_json_object_iter(json); field; field = ast_json_object_iter_next(json, field)) {
|
|
struct ast_json *value = ast_json_object_iter_value(field);
|
|
struct ast_variable *variable = ast_variable_new(ast_json_object_iter_key(field), ast_json_string_get(value), "");
|
|
|
|
if (!variable) {
|
|
ast_variables_destroy(objset);
|
|
return NULL;
|
|
}
|
|
|
|
variable->next = objset;
|
|
objset = variable;
|
|
}
|
|
|
|
return objset;
|
|
}
|
|
|
|
/*! \brief Helper function which compares two json objects and sees if they are equal, but only looks at the criteria provided */
|
|
static int sorcery_json_equal(struct ast_json *object, struct ast_json *criteria)
|
|
{
|
|
struct ast_json_iter *field;
|
|
|
|
for (field = ast_json_object_iter(criteria); field; field = ast_json_object_iter_next(criteria, field)) {
|
|
struct ast_json *object_field = ast_json_object_get(object, ast_json_object_iter_key(field));
|
|
|
|
if (!object_field || !ast_json_equal(object_field, ast_json_object_iter_value(field))) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object)
|
|
{
|
|
RAII_VAR(struct ast_json *, objset, ast_sorcery_objectset_json_create(sorcery, object), ast_json_unref);
|
|
RAII_VAR(char *, value, NULL, ast_json_free);
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
|
|
|
|
if (!objset || !(value = ast_json_dump_string(objset))) {
|
|
return -1;
|
|
}
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
|
|
|
|
return ast_db_put(family, ast_sorcery_object_get_id(object), value);
|
|
}
|
|
|
|
/*! \brief Internal helper function which retrieves an object, or multiple objects, using fields for criteria */
|
|
static void *sorcery_astdb_retrieve_fields_common(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields, struct ao2_container *objects)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(type) + 2];
|
|
RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
|
|
RAII_VAR(struct ast_json *, criteria, NULL, ast_json_unref);
|
|
struct ast_db_entry *entry;
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, type);
|
|
|
|
if (!(entries = ast_db_gettree(family, NULL)) || (fields && !(criteria = sorcery_objectset_to_json(fields)))) {
|
|
return NULL;
|
|
}
|
|
|
|
for (entry = entries; entry; entry = entry->next) {
|
|
const char *key = entry->key + strlen(family) + 2;
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_json_error error;
|
|
RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
|
|
void *object = NULL;
|
|
|
|
if (!(json = ast_json_load_string(entry->data, &error))) {
|
|
return NULL;
|
|
} else if (criteria && !sorcery_json_equal(json, criteria)) {
|
|
continue;
|
|
} else if (!(objset = sorcery_json_to_objectset(json)) ||
|
|
!(object = ast_sorcery_alloc(sorcery, type, key)) ||
|
|
ast_sorcery_objectset_apply(sorcery, object, objset)) {
|
|
ao2_cleanup(object);
|
|
return NULL;
|
|
}
|
|
|
|
if (!objects) {
|
|
return object;
|
|
}
|
|
|
|
ao2_link(objects, object);
|
|
ao2_cleanup(object);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
|
|
{
|
|
return sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, NULL);
|
|
}
|
|
|
|
static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(type) + 2];
|
|
RAII_VAR(char *, value, NULL, ast_free_ptr);
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_json_error error;
|
|
RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
|
|
void *object = NULL;
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, type);
|
|
|
|
if (ast_db_get_allocated(family, id, &value) || !(json = ast_json_load_string(value, &error)) ||
|
|
!(objset = sorcery_json_to_objectset(json)) || !(object = ast_sorcery_alloc(sorcery, type, id)) ||
|
|
ast_sorcery_objectset_apply(sorcery, object, objset)) {
|
|
ao2_cleanup(object);
|
|
return NULL;
|
|
}
|
|
|
|
return object;
|
|
}
|
|
|
|
static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
|
|
{
|
|
sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, objects);
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \brief Convert regex prefix pattern to astDB prefix pattern if possible.
|
|
*
|
|
* \param tree astDB prefix pattern buffer to fill.
|
|
* \param regex Extended regular expression with the start anchor character '^'.
|
|
*
|
|
* \note Since this is a helper function, the tree buffer is
|
|
* assumed to always be large enough.
|
|
*
|
|
* \retval 0 on success.
|
|
* \retval -1 on error. regex is invalid.
|
|
*/
|
|
static int make_astdb_prefix_pattern(char *tree, const char *regex)
|
|
{
|
|
const char *src;
|
|
char *dst;
|
|
|
|
for (dst = tree, src = regex + 1; *src; ++src) {
|
|
if (*src == '\\') {
|
|
/* Escaped regex char. */
|
|
++src;
|
|
if (!*src) {
|
|
/* Invalid regex. The caller escaped the string terminator. */
|
|
return -1;
|
|
}
|
|
} else if (*src == '$') {
|
|
if (!src[1]) {
|
|
/* Remove the tail anchor character. */
|
|
*dst = '\0';
|
|
return 0;
|
|
}
|
|
} else if (strchr(".?*+{[(|", *src)) {
|
|
/*
|
|
* The regex is not a simple prefix pattern.
|
|
*
|
|
* XXX With more logic, it is possible to simply
|
|
* use the current prefix pattern. The last character
|
|
* needs to be removed if possible when the current regex
|
|
* token is "?*{". Also the rest of the regex pattern
|
|
* would need to be checked for subgroup/alternation.
|
|
* Subgroup/alternation is too complex for a simple prefix
|
|
* match.
|
|
*/
|
|
dst = tree;
|
|
break;
|
|
}
|
|
*dst++ = *src;
|
|
}
|
|
if (dst != tree) {
|
|
*dst++ = '%';
|
|
}
|
|
*dst = '\0';
|
|
return 0;
|
|
}
|
|
|
|
static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(type) + 2];
|
|
char tree[strlen(regex) + 1];
|
|
RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
|
|
regex_t expression;
|
|
struct ast_db_entry *entry;
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, type);
|
|
|
|
if (regex[0] == '^') {
|
|
/*
|
|
* For performance reasons, try to create an astDB prefix
|
|
* pattern from the regex to reduce the number of entries
|
|
* retrieved from astDB for regex to then match.
|
|
*/
|
|
if (make_astdb_prefix_pattern(tree, regex)) {
|
|
return;
|
|
}
|
|
} else {
|
|
tree[0] = '\0';
|
|
}
|
|
|
|
if (!(entries = ast_db_gettree(family, tree))
|
|
|| regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
|
|
return;
|
|
}
|
|
|
|
for (entry = entries; entry; entry = entry->next) {
|
|
/* The key in the entry includes the family, so we need to strip it out for regex purposes */
|
|
const char *key = entry->key + strlen(family) + 2;
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_json_error error;
|
|
RAII_VAR(void *, object, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
|
|
|
|
if (regexec(&expression, key, 0, NULL, 0)) {
|
|
continue;
|
|
} else if (!(json = ast_json_load_string(entry->data, &error)) ||
|
|
!(objset = sorcery_json_to_objectset(json)) ||
|
|
!(object = ast_sorcery_alloc(sorcery, type, key)) ||
|
|
ast_sorcery_objectset_apply(sorcery, object, objset)) {
|
|
regfree(&expression);
|
|
return;
|
|
}
|
|
|
|
ao2_link(objects, object);
|
|
}
|
|
|
|
regfree(&expression);
|
|
}
|
|
|
|
static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2], value[2];
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
|
|
|
|
/* It is okay for the value to be truncated, we are only checking that it exists */
|
|
if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
|
|
return -1;
|
|
}
|
|
|
|
/* The only difference between update and create is that for update the object must already exist */
|
|
return sorcery_astdb_create(sorcery, data, object);
|
|
}
|
|
|
|
static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
|
|
char value[2];
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
|
|
|
|
if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
|
|
return -1;
|
|
}
|
|
|
|
return ast_db_del(family, ast_sorcery_object_get_id(object));
|
|
}
|
|
|
|
static void *sorcery_astdb_open(const char *data)
|
|
{
|
|
/* We require a prefix for family string generation, or else stuff could mix together */
|
|
if (ast_strlen_zero(data)) {
|
|
return NULL;
|
|
}
|
|
|
|
return ast_strdup(data);
|
|
}
|
|
|
|
static void sorcery_astdb_close(void *data)
|
|
{
|
|
ast_free(data);
|
|
}
|
|
|
|
static int load_module(void)
|
|
{
|
|
if (ast_sorcery_wizard_register(&astdb_object_wizard)) {
|
|
return AST_MODULE_LOAD_DECLINE;
|
|
}
|
|
|
|
return AST_MODULE_LOAD_SUCCESS;
|
|
}
|
|
|
|
static int unload_module(void)
|
|
{
|
|
ast_sorcery_wizard_unregister(&astdb_object_wizard);
|
|
return 0;
|
|
}
|
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Astdb Object Wizard",
|
|
.support_level = AST_MODULE_SUPPORT_CORE,
|
|
.load = load_module,
|
|
.unload = unload_module,
|
|
.load_pri = AST_MODPRI_REALTIME_DRIVER,
|
|
);
|