range* rangefunc_mem(range_request* rr, range** r)
{
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** clusters = range_get_hostnames(pool, r[0]);
const char* cluster = clusters[0];
const char** wanted = range_get_hostnames(pool, r[1]);
range* keys = _expand_cluster(rr, cluster, "KEYS");
const char** all_sections = range_get_hostnames(pool, keys);
const char** p_section = all_sections;
SECTION:
while (*p_section) {
range* r_s = _expand_cluster(rr, cluster, *p_section);
const char** p_wanted = wanted;
while (*p_wanted) {
if (set_get(r_s->nodes, *p_wanted) != NULL) {
range_add(ret, *p_section++);
goto SECTION;
}
++p_wanted;
}
++p_section;
}
return ret;
}
range* rangefunc_has(range_request* rr, range** r)
{
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** tag_names = range_get_hostnames(pool, r[0]);
const char** tag_values = range_get_hostnames(pool, r[1]);
const char* tag_name = tag_names[0];
const char* tag_value = tag_values[0];
const char** all_clusters = _all_clusters(rr);
const char** cluster = all_clusters;
int warn_enabled = range_request_warn_enabled(rr);
if (!cluster) return ret;
range_request_disable_warns(rr);
while (*cluster) {
range* vals = _expand_cluster(rr, *cluster, tag_name);
if (set_get(vals->nodes, tag_value) != NULL) {
range_add(ret, *cluster);
}
cluster++;
}
if (warn_enabled) range_request_enable_warns(rr);
return ret;
}
range* _do_has_mem(range_request* rr, range** r, char* sql_query)
{
sqlite3* db;
sqlite3_stmt* stmt;
int err;
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
if (NULL == r[0]) {
// don't attempt anything without arg #1 (key)
return ret;
}
const char** tag_names = range_get_hostnames(pool, r[0]);
const char* tag_name = tag_names[0];
if (NULL == tag_name) {
return ret;
}
const char** tag_values;
const char* tag_value;
if (NULL == r[1]) {
// if we don't have arg #2 (val) then search for keys with empty string value
tag_value = EMPTY_STRING;
} else {
tag_values = range_get_hostnames(pool, r[1]);
tag_value = tag_values[0];
}
const char** all_clusters = _all_clusters(rr);
const char** cluster = all_clusters;
int warn_enabled = range_request_warn_enabled(rr);
db = _open_db(rr);
err = sqlite3_prepare(db, sql_query, strlen(sql_query), &stmt,
NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "has(%s,%s): cannot query sqlite db", tag_name, tag_value);
return ret;
}
assert(err == SQLITE_OK);
sqlite3_bind_text(stmt, 1, tag_name, strlen(tag_name), SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, tag_value, strlen(tag_value), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
const char* answer = (const char*)sqlite3_column_text(stmt, 0);
range_add(ret, answer);
}
sqlite3_finalize(stmt);
return ret;
}
range* range_from_match(range_request* rr,
const range* r, const char* regex)
{
range* ret;
int i;
int err_offset;
int ovector[30];
int count;
const char* error;
const char** members;
pcre* re;
apr_pool_t* pool = range_request_pool(rr);
members = range_get_hostnames(pool, r);
ret = range_new(rr);
re = pcre_compile(regex, 0, &error, &err_offset, NULL);
if (!re) {
range_request_warn(rr, "regex [%s] [%s]", regex, error);
return ret;
}
for (i = 0; members[i]; i++) {
count = pcre_exec(re, NULL, members[i],
strlen(members[i]), 0, 0, ovector, 30);
if (count > 0) /* it matched */
range_add(ret, members[i]);
}
pcre_free(re);
return ret;
}
range* rangefunc_get_groups(range_request* rr, range** r)
{
sqlite3* db;
sqlite3_stmt* stmt;
int err;
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** tag_names = range_get_hostnames(pool, r[0]);
const char* tag_name = tag_names[0];
int warn_enabled = range_request_warn_enabled(rr);
if (NULL == tag_name) {
return ret;
}
db = _open_db(rr);
err = sqlite3_prepare(db, GROUPS_SQL, strlen(GROUPS_SQL), &stmt, NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "?%s: cannot query sqlite db", tag_name );
return ret;
}
assert(err == SQLITE_OK);
sqlite3_bind_text(stmt, 1, tag_name, strlen(tag_name), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
const char* answer = (const char*)sqlite3_column_text(stmt, 0);
range_add(ret, answer);
}
sqlite3_finalize(stmt);
return ret;
}
static set* _get_clusters(range_request* rr)
{
const char** all_clusters = _all_clusters(rr);
const char** p_cl = all_clusters;
apr_pool_t* pool = range_request_pool(rr);
set* node_cluster = set_new(pool, 40000);
if(p_cl == NULL) {
return node_cluster;
}
while (*p_cl) {
range* nodes_r = _expand_cluster(rr, *p_cl, "CLUSTER");
const char** nodes = range_get_hostnames(pool, nodes_r);
const char** p_nodes = nodes;
while (*p_nodes) {
apr_array_header_t* clusters = set_get_data(node_cluster, *p_nodes);
if (!clusters) {
clusters = apr_array_make(pool, 1, sizeof(char*));
set_add(node_cluster, *p_nodes, clusters);
}
*(const char**)apr_array_push(clusters) = *p_cl;
++p_nodes;
}
++p_cl;
}
return node_cluster;
}
range* rangefunc_clusters(range_request* rr, range** r)
{
sqlite3* db;
sqlite3_stmt* stmt;
int err;
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** nodes = range_get_hostnames(pool, r[0]);
const char** p_nodes = nodes;
db = _open_db(rr);
err = sqlite3_prepare(db, CLUSTERS_SQL, strlen(CLUSTERS_SQL), &stmt, NULL);
if (err != SQLITE_OK) {
range_request_warn(rr, "clusters(): cannot query sqlite db");
return ret;
}
while (*p_nodes) {
char * node_name = *p_nodes;
sqlite3_bind_text(stmt, 1, node_name, strlen(node_name), SQLITE_STATIC);
while(sqlite3_step(stmt) == SQLITE_ROW) {
const char* answer = (const char*)sqlite3_column_text(stmt, 0);
range_add(ret, answer);
}
sqlite3_reset(stmt);
sqlite3_clear_bindings(stmt);
++p_nodes;
}
sqlite3_finalize(stmt);
return ret;
}
range* rangefunc_get_cluster(range_request* rr, range** r)
{
range* ret = range_new(rr);
if (!validate_range_args(rr, r, 1)) {
return ret;
}
apr_pool_t* pool = range_request_lr_pool(rr);
const char** nodes = range_get_hostnames(pool, r[0]);
const char** p_nodes = nodes;
set* node_cluster = _get_clusters(rr);
while (*p_nodes) {
apr_array_header_t* clusters = set_get_data(node_cluster, *p_nodes);
if (!clusters)
range_request_warn_type(rr, "NO_CLUSTER", *p_nodes);
else {
/* just get one */
const char* cluster = ((const char**)clusters->elts)[0];
assert(cluster);
range_add(ret, cluster);
}
++p_nodes;
}
return ret;
}
range* rangefunc_clusters(range_request* rr, range** r)
{
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** nodes = range_get_hostnames(pool, r[0]);
const char** p_nodes = nodes;
set* node_cluster = _get_clusters(rr);
while (*p_nodes) {
apr_array_header_t* clusters = set_get_data(node_cluster, *p_nodes);
if (!clusters)
range_request_warn_type(rr, "NO_CLUSTER", *p_nodes);
else {
/* get all */
int i;
for (i=0; i<clusters->nelts; ++i) {
const char* cluster = ((const char**)clusters->elts)[i];
range_add(ret, cluster);
}
}
++p_nodes;
}
return ret;
}
range* rangefunc_get_groups(range_request* rr, range** r)
{
range* ret = range_new(rr);
if (!validate_range_args(rr, r, 1)) {
return ret;
}
range* n = r[0];
apr_pool_t* pool = range_request_pool(rr);
const char** in_nodes = range_get_hostnames(pool, n);
set* node_group = set_new(pool, 40000);
range* groups_r = _expand_cluster(rr, "GROUPS", "KEYS");
const char** groups = range_get_hostnames(pool, groups_r);
const char** p_group = groups;
while (*p_group) {
range* nodes_r = _expand_cluster(rr, "GROUPS", *p_group);
const char** nodes = range_get_hostnames(pool, nodes_r);
const char** p_nodes = nodes;
while (*p_nodes) {
apr_array_header_t* my_groups = set_get_data(node_group, *p_nodes);
if (!my_groups) {
my_groups = apr_array_make(pool, 4, sizeof(char*));
set_add(node_group, *p_nodes, my_groups);
}
*(const char**)apr_array_push(my_groups) = *p_group;
++p_nodes;
}
++p_group;
}
while (*in_nodes) {
apr_array_header_t* my_groups = set_get_data(node_group, *in_nodes);
if (!my_groups)
range_request_warn_type(rr, "NO_GROUPS", *in_nodes);
else {
int i;
for (i=0; i<my_groups->nelts; ++i)
range_add(ret, ((const char**)my_groups->elts)[i]);
}
in_nodes++;
}
return ret;
}
range* rangefunc_group(range_request* rr, range** r)
{
range* ret = range_new(rr);
apr_pool_t* pool = range_request_pool(rr);
const char** groups = range_get_hostnames(pool, r[0]);
while (*groups) {
range_union_inplace(rr, ret, _expand_cluster(rr, "GROUPS", *groups));
++groups;
}
return ret;
}
range* rangefunc_get_admin(range_request* rr, range** r)
{
range* ret = range_new(rr);
if (!validate_range_args(rr, r, 1)) {
return ret;
}
range* n = r[0];
apr_pool_t* pool = range_request_pool(rr);
const char** in_nodes = range_get_hostnames(pool, n);
set* node_admin = set_new(pool, 40000);
range* admins_r = _expand_cluster(rr, "HOSTS", "KEYS");
const char** admins = range_get_hostnames(pool, admins_r);
const char** p_admin = admins;
while (*p_admin) {
range* nodes_r = _expand_cluster(rr, "HOSTS", *p_admin);
const char** nodes = range_get_hostnames(pool, nodes_r);
const char** p_nodes = nodes;
while (*p_nodes) {
set_add(node_admin, *p_nodes, (void*)*p_admin);
++p_nodes;
}
++p_admin;
}
while (*in_nodes) {
const char* admin = set_get_data(node_admin, *in_nodes);
if (!admin) {
range_request_warn_type(rr, "NO_ADMIN", *in_nodes);
}
else {
range_add(ret, admin);
}
in_nodes++;
}
return ret;
}
range * rangefunc_group(range_request* rr, range** r)
{
sqlite3* db;
db = _open_db(rr);
range* ret = range_new(rr), *expanded;
apr_pool_t* pool = range_request_pool(rr);
const char** groups = range_get_hostnames(pool, r[0]);
while (*groups) {
expanded = _expand_cluster(rr, "GROUPS", *groups);
range_union_inplace(rr, ret, expanded);
++groups;
}
return ret;
}
PyObject * range_to_py_array(apr_pool_t* pool, const range* r)
{
int i,node_count;
const char** nodes;
PyObject * py_list = PyList_New(0);
assert(r);
node_count = r->nodes->members;
nodes = range_get_hostnames(pool, r);
for (i=0; i < node_count; i++) {
PyObject *item;
item = PyString_FromString(nodes[i]);
PyList_Append(py_list, item);
Py_DECREF(item);
}
return py_list;
}
range* rangefunc_group(range_request* rr, range** r)
{
range* ret = range_new(rr);
if (!validate_range_args(rr, r, 1)) {
return ret;
}
apr_pool_t* pool = range_request_pool(rr);
const char** groups = range_get_hostnames(pool, r[0]);
while (*groups) {
if (islower(*groups[0]))
range_union_inplace(rr, ret, _expand_cluster(rr, "HOSTS", *groups));
else
range_union_inplace(rr, ret, _expand_cluster(rr, "GROUPS", *groups));
++groups;
}
return ret;
}
range* rangefunc_cluster(range_request* rr, range** r)
{
range* ret = range_new(rr);
if (!validate_range_args(rr, r, 1)) {
return ret;
}
apr_pool_t* pool = range_request_pool(rr);
const char** clusters = range_get_hostnames(pool, r[0]);
const char** p = clusters;
while (*p) {
const char* colon = strchr(*p, ':');
range* r1;
if (colon) {
int len = strlen(*p);
int cluster_len = colon - *p;
int section_len = len - cluster_len - 1;
char* cl = apr_palloc(pool, cluster_len + 1);
char* sec = apr_palloc(pool, section_len + 1);
memcpy(cl, *p, cluster_len);
cl[cluster_len] = '\0';
memcpy(sec, colon + 1, section_len);
sec[section_len] = '\0';
r1 = _expand_cluster(rr, cl, sec);
}
else
r1 = _expand_cluster(rr, *p, "CLUSTER");
if (range_members(r1) > range_members(ret)) {
/* swap them */
range* tmp = r1;
r1 = ret;
ret = tmp;
}
range_union_inplace(rr, ret, r1);
range_destroy(r1);
++p;
}
return ret;
}
range* rangefunc_group(range_request* rr, range** r)
{
range* ret;
const char** members;
int i, err;
sqlite3* db;
sqlite3_stmt* tag_stmt;
sqlite3_stmt* all_nodes_stmt;
apr_pool_t* pool = range_request_pool(rr);
libcrange* lr = range_request_lr(rr);
ret = range_new(rr);
members = range_get_hostnames(pool, r[0]);
if (!(db = libcrange_get_cache(lr, "sqlite:nodes"))) {
const char* sqlite_db_path = libcrange_getcfg(lr, "sqlitedb");
if (!sqlite_db_path) sqlite_db_path = DEFAULT_SQLITE_DB;
err = sqlite3_open(sqlite_db_path, &db);
if (err != SQLITE_OK) {
fprintf(stderr, "%s: %s\n", sqlite_db_path, sqlite3_errmsg(db));
return ret;
}
libcrange_set_cache(lr, "sqlite:nodes", db);
}
/* prepare our selects */
err = sqlite3_prepare(db, ALL_NODES_SQL, strlen(ALL_NODES_SQL),
&all_nodes_stmt, NULL);
if (err != SQLITE_OK) {
fprintf(stderr, "%s: %s\n", ALL_NODES_SQL, sqlite3_errmsg(db));
abort();
}
err = sqlite3_prepare(db, RANGE_FROM_TAGS, strlen(RANGE_FROM_TAGS),
&tag_stmt, NULL);
assert(err == SQLITE_OK);
/* for each group */
for (i = 0; members[i]; ++i) {
sqlite3_stmt* stmt;
if (strcmp(members[i], "ALL") == 0) {
stmt = all_nodes_stmt;
} else {
stmt = tag_stmt;
/* bind the current group name */
sqlite3_bind_text(tag_stmt, 1, members[i], strlen(members[i]), SQLITE_STATIC);
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
range* this_group;
const char* result = (const char*)sqlite3_column_text(stmt, 0);
if (stmt == all_nodes_stmt) {
range_add(ret, result);
} else {
this_group = do_range_expand(rr, result);
set_union_inplace(ret->nodes, this_group->nodes);
}
}
sqlite3_reset(stmt);
}
sqlite3_finalize(all_nodes_stmt);
sqlite3_finalize(tag_stmt);
return ret;
}
