lei.chen/myxce
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

save works

Browse source
This commit is contained in:
Rongsong Shen 2026-02-28 17:55:50 +08:00
parent b1faeb94b6
commit b748e30d20
35 changed files with 1247 additions and 2149 deletions
Download patch file Download diff file Expand all files Collapse all files

47
src/lib/configobj.c
View file

@ -4,8 +4,53 @@
#include <stdlib.h>
#include <string.h>
#include "configobj.h"
#include "mylock.h"
#include "qobj.h"
#include "utils.h"
#include "xce/types.h"
#include "xstring.h"
static size_t xconfig_datasize(va_list ap)
{
size_t sz = sizeof(xce_config_t);
return sz;
}
static int xconfig_init(meta_obj_t* obj, va_list ap)
{
xce_config_t* dst = RTTI_OBJ_TO_DATA(xce_config_t, obj);
xce_config_t* src = va_arg(ap, xce_config_t*);
if (src == NULL) {
return -EINVAL;
}
dst->name = makeString(src->name);
dst->value = makeString(src->value);
return 1;
}
static void xconfig_destroy(meta_obj_t* obj)
{
xce_config_t* c = RTTI_OBJ_TO_DATA(xce_config_t, obj);
dereference(c->name);
dereference(c->value);
}
static typeinfo_t xconfig_type = {
.name = "xce config item",
.privateSize = 0,
.dataSize = (datasize_fn_t)xconfig_datasize,
.init = (obj_init_fn_t)xconfig_init,
.destroy = (obj_destroy_fn_t)xconfig_destroy,
};
xce_config_t* makeConfig(xce_config_t* c)
{
xce_config_t* c1 = makeInstance(&xconfig_type, c);
return c1;
}

318
src/lib/group.c
View file

@ -1,4 +1,5 @@
#include <errno.h>
#include <rtti.h>
#include <stdio.h>
#include <stdlib.h>
@ -7,6 +8,11 @@
#include "objmgr.h"
#include "utils.h"
#include "xce/types.h"
#include "xstring.h"
typedef struct {
} group_private_t;
static void group_killer(xce_group_t* g)
{
@ -20,7 +26,7 @@ static void group_killer(xce_group_t* g)
xce_g_member_t* m = (xce_g_member_t*)xlist_get(&(g->members), i);
if (!m->is_group) {
FREEUP(m->u.name);
dereference(m->u.name);
}
FREEUP(m);
}
@ -29,7 +35,7 @@ static void group_killer(xce_group_t* g)
xce_g_member_t* m = (xce_g_member_t*)xlist_get(&(g->ex_members), i);
if (!m->is_group) {
FREEUP(m->u.name);
dereference(m->u.name);
}
FREEUP(m);
}
@ -45,76 +51,10 @@ static void group_killer(xce_group_t* g)
xlist_fini(&(g->ex_members));
xlist_fini(&(g->affecteds));
FREEUP(g->name);
FREEUP(g);
dereference(g->name);
}
int groupmgr_init(groupmgr_t* mgr, int nslots, int delta)
{
int rc = 0;
xce_group_config_t all = { .name = "all" };
xce_group_config_t empty = { .name = "empty" };
xce_group_t* g = NULL;
memset(mgr, 0x0, sizeof(*mgr));
rc = kvmgr_init(&(mgr->groups), string_hash_key, nslots, delta,
(zarray_item_killer_t)group_killer);
if (rc < 0) {
return rc;
}
/* create builtin all group */
g = build_group(mgr, &all, NULL);
if (g == NULL) {
return -ENOMEM;
}
/* create builtin empty group */
g = build_group(mgr, &empty, NULL);
if (g == NULL) {
return -ENOMEM;
}
return 1;
}
void groupmgr_fini(groupmgr_t* mgr) { kvmgr_fini(&(mgr->groups)); }
int groupmgr_add(groupmgr_t* mgr, xce_group_t* g)
{
return kvmgr_add(&(mgr->groups), (void*)g->name, g);
}
xce_group_t* groupmgr_lock(groupmgr_t* mgr, char* name, int op)
{
return (xce_group_t*)kvmgr_lock(&(mgr->groups), (void*)name, op);
}
void groupmgr_del(groupmgr_t* mgr, xce_group_t* g)
{
kvmgr_del(&(mgr->groups), (void*)g->name);
}
int groupmgr_iter(groupmgr_t* mgr, xlist_t* l, void* arg)
{
return kvmgr_iter(&(mgr->groups), NULL, l, arg);
}
xce_group_t* get_group(groupmgr_t* mgr, char* name)
{
xce_group_t* g = NULL;
if ((mgr == NULL) || (name == NULL)) {
return NULL;
}
g = groupmgr_lock(mgr, name, OBJREF_NOP);
return g;
}
xce_g_member_t* make_g_member(groupmgr_t* mgr, char* name)
xce_g_member_t* make_g_member(var mgr, char* name)
{
xce_g_member_t* m = NULL;
xce_group_t* g = NULL;
@ -135,7 +75,7 @@ xce_g_member_t* make_g_member(groupmgr_t* mgr, char* name)
m->u.g = g;
} else {
m->is_group = 0;
m->u.name = strdup(name);
m->u.name = makeString(name);
}
return m;
@ -162,6 +102,238 @@ static int update_group_dirty(xce_group_t* g)
return count;
}
static int init_group_by_config(xce_group_t* g, var mgr,
xce_group_config_t* g_config)
{
int i;
for (i = 0; i < g_config->members.count; i++) {
char* g_name = g_config->members.data[i];
xce_g_member_t* m = make_g_member(mgr, g_name);
if (m == NULL) {
continue;
}
xlist_store(&(g->members), m);
if (m->is_group) {
xlist_store(&(m->u.g->affecteds), g);
}
}
for (i = 0; i < g_config->ex_members.count; i++) {
char* g_name = g_config->ex_members.data[i];
xce_g_member_t* m = make_g_member(mgr, g_name);
if (m == NULL) {
continue;
}
xlist_store(&(g->ex_members), m);
if (m->is_group) {
xlist_store(&(m->u.g->affecteds), g);
}
}
return 0;
}
static size_t group_datasize(va_list ap)
{
size_t sz = sizeof(xce_group_t);
return sz;
}
static int group_init(meta_obj_t* obj, va_list ap)
{
xce_group_t* g = RTTI_OBJ_TO_DATA(xce_group_t, obj);
var mgr = va_arg(ap, var);
xce_group_config_t* config = va_arg(ap, xce_group_config_t*);
char* g_name = va_arg(ap, char*);
int rc;
if ((mgr == NULL) || (config == NULL)) {
return -EINVAL;
}
rc = key_add(mgr, (void*)g_name, (void*)g);
if (rc < 0) {
return rc;
}
xlist_init(&(g->affecteds), 4);
xlist_init(&(g->members), 4);
xlist_init(&(g->ex_members), 4);
g->name = makeString(g_name);
g->dirty = 0;
init_group_by_config(g, mgr, config);
return 1;
}
static void group_destroy(meta_obj_t* obj)
{
xce_group_t* g = RTTI_OBJ_TO_DATA(xce_group_t, obj);
group_killer(g);
}
static typeinfo_t group_type = { .name = "group",
.privateSize = sizeof(group_private_t),
.dataSize = (datasize_fn_t)group_datasize,
.init = (obj_init_fn_t)group_init,
.destroy = (obj_destroy_fn_t)group_destroy,
.interfaces = {} };
xce_group_t* makeGroup(var mgr, xce_group_config_t* config,
char* default_g_name)
{
xce_group_t* g = NULL;
char* g_name = NULL;
int rc = 0;
if ((mgr == NULL) || (config == NULL)) {
errno = EINVAL;
return NULL;
}
g_name = config->name;
if ((g_name == NULL) || (strlen(g_name) == 0)) {
g_name = default_g_name;
}
if (g_name == NULL) {
errno = EINVAL;
return NULL;
}
rc = key_find(mgr, (void*)g_name, (void**)&g);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
if (g != NULL) {
int i;
for (i = 0; i < g->members.count; i++) {
xce_g_member_t* m = (xce_g_member_t*)xlist_get(&(g->members), i);
if (m == NULL) {
continue;
}
if (m->is_group == 0) {
FREEUP(m->u.name);
}
FREEUP(m);
}
g->members.count = 0;
for (i = 0; i < g->ex_members.count; i++) {
xce_g_member_t* m = (xce_g_member_t*)xlist_get(&(g->ex_members), i);
if (m == NULL) {
continue;
}
if (m->is_group == 0) {
FREEUP(m->u.name);
}
FREEUP(m);
}
g->ex_members.count = 0;
g->dirty = 1;
init_group_by_config(g, mgr, config);
return g;
}
g = makeInstance(&group_type, mgr, config, g_name);
return g;
}
int groupmgr_init(var* mgr, int nslots, int delta)
{
xce_group_config_t all = { .name = "all" };
xce_group_config_t empty = { .name = "empty" };
xce_group_t* g = NULL;
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
.dynamic = 1,
.nslots = nslots,
.delta = delta,
.datakiller = destroy };
*mgr = makeInstance(&xkvmgr_type, &params);
if ((*mgr) == NULL) {
return -errno;
}
/* create builtin all group */
g = makeGroup(*mgr, &all, NULL);
if (g == NULL) {
return -errno;
}
/* create builtin empty group */
g = makeGroup(*mgr, &empty, NULL);
if (g == NULL) {
return -ENOMEM;
}
return 1;
}
int groupmgr_add(var mgr, xce_group_t* g)
{
int rc = 0;
rc = key_add(mgr, (void*)g->name, (void*)g);
return rc;
}
xce_group_t* groupmgr_lock(var mgr, char* name, int op)
{
int rc;
xce_group_t* g = NULL;
rc = key_find(mgr, (void*)name, (void**)&g);
if (rc <= 0) {
return NULL;
}
return g;
}
void groupmgr_del(var mgr, xce_group_t* g)
{
key_del(mgr, (void*)g->name);
return;
}
xce_group_t* get_group(var mgr, char* name)
{
xce_group_t* g = NULL;
int rc = 0;
if ((mgr == NULL) || (name == NULL)) {
return NULL;
}
rc = key_find(mgr, (void*)name, (void**)&g);
if (rc <= 0) {
return NULL;
}
return g;
}
int fmt_group(char* buf, int len, xce_group_t* g)
{
int i, pos;
@ -210,7 +382,7 @@ int fmt_group(char* buf, int len, xce_group_t* g)
return strlen(buf);
}
xce_group_t* build_group(groupmgr_t* mgr, xce_group_config_t* g_config,
xce_group_t* build_group(var mgr, xce_group_config_t* g_config,
char* default_group_name)
{
xce_group_t* g = NULL;
@ -268,7 +440,7 @@ xce_group_t* build_group(groupmgr_t* mgr, xce_group_config_t* g_config,
xlist_init(&(g->affecteds), 4);
xlist_init(&(g->members), 4);
xlist_init(&(g->ex_members), 4);
g->name = strdup(g_name);
g->name = makeString(g_name);
g->dirty = 0;
}

158
src/lib/kvmgr.c
View file

@ -238,164 +238,6 @@ int kvmgr_iter(kvmgr_t* mgr, zarray_iter_skip_fn_t skipfn, xlist_t* l,
return rc;
}
int resmgr_init(resmgr_t* mgr, int nslots, int delta,
zarray_item_killer_t killer)
{
int rc = 0;
rc = kvmgr_init(&(mgr->resdef), string_hash_key, nslots, delta, killer);
if (rc < 0) {
return rc;
}
mgr->nshared = 0;
mgr->nunshared = 0;
return 0;
}
void resmgr_fini(resmgr_t* mgr)
{
kvmgr_fini(&(mgr->resdef));
mgr->nshared = 0;
mgr->nunshared = 0;
}
int32_t resmgr_add_res(resmgr_t* mgr, xce_resource_t* res)
{
int rc = 0;
rc = kvmgr_add(&(mgr->resdef), (void*)res->name, (void*)res);
if (rc < 0) {
return rc;
}
if (res->flags & XCE_RESF_SHARED) {
res->idx = mgr->nshared;
mgr->nshared++;
} else {
res->idx = mgr->nunshared;
mgr->nunshared++;
}
return rc;
}
xce_resource_t* resmgr_lockres(resmgr_t* mgr, char* resname, int op)
{
xce_resource_t* r = NULL;
r = (xce_resource_t*)kvmgr_lock(&(mgr->resdef), (void*)resname, op);
return r;
}
xce_resource_t* resmgr_lock_byid(resmgr_t* mgr, int idx, int op)
{
xce_resource_t* r = NULL;
r = (xce_resource_t*)kvmgr_lock_byid(&(mgr->resdef), idx, op);
return r;
}
void resmgr_del_res(resmgr_t* mgr, xce_resource_t* r)
{
kvmgr_del(&(mgr->resdef), (void*)r->name);
}
int resmgr_iter(resmgr_t* mgr, xlist_t* l, void* arg)
{
return kvmgr_iter(&(mgr->resdef), NULL, l, arg);
}
int qmgr_init(qmgr_t* mgr, int nslots, int delta, zarray_item_killer_t killer)
{
return kvmgr_init(&(mgr->queues), string_hash_key, nslots, delta, killer);
}
void qmgr_fini(qmgr_t* mgr) { kvmgr_fini(&(mgr->queues)); }
int qmgr_add(qmgr_t* mgr, queue_t* q)
{
return kvmgr_add(&(mgr->queues), (void*)q->queue.queue, q);
}
queue_t* qmgr_lockq(qmgr_t* mgr, char* name, int op)
{
return (queue_t*)kvmgr_lock(&(mgr->queues), (void*)name, op);
}
void qmgr_delq(qmgr_t* mgr, queue_t* q)
{
kvmgr_del(&(mgr->queues), (void*)q->queue.queue);
}
int qmgr_iter(qmgr_t* mgr, xlist_t* l, void* arg)
{
return kvmgr_iter(&(mgr->queues), NULL, l, arg);
}
int workermgr_init(workermgr_t* mgr, int nslots, int delta,
zarray_item_killer_t killer)
{
return kvmgr_init(&(mgr->workers), string_hash_key, nslots, delta, killer);
}
void workermgr_fini(workermgr_t* mgr) { kvmgr_fini(&(mgr->workers)); }
int workermgr_add(workermgr_t* mgr, worker_t* w)
{
return kvmgr_add(&(mgr->workers), (void*)w->host.name, w);
}
worker_t* workermgr_lock(workermgr_t* mgr, char* name, int op)
{
return (worker_t*)kvmgr_lock(&(mgr->workers), (void*)name, op);
}
worker_t* workermgr_lock_byid(workermgr_t* mgr, int idx, int op)
{
return (worker_t*)kvmgr_lock_byid(&(mgr->workers), idx, op);
}
void workermgr_del(workermgr_t* mgr, worker_t* w)
{
kvmgr_del(&(mgr->workers), (void*)w->host.name);
}
int workermgr_iter(workermgr_t* mgr, xlist_t* l, void* arg)
{
return kvmgr_iter(&(mgr->workers), NULL, l, arg);
}
int jobmgr_init(jobmgr_t* mgr, int nslots, int delta,
zarray_item_killer_t killer)
{
return kvmgr_init(&(mgr->jobs), int_hash_key, nslots, delta, killer);
}
void jobmgr_fini(jobmgr_t* mgr) { kvmgr_fini(&(mgr->jobs)); }
int jobmgr_add_job(jobmgr_t* mgr, job_t* j)
{
return kvmgr_add(&(mgr->jobs), (void*)j->job.jobid, j);
}
job_t* jobmgr_lockjob(jobmgr_t* mgr, uint64_t jobid, int op)
{
return (job_t*)kvmgr_lock(&(mgr->jobs), (void*)jobid, op);
}
void jobmgr_del_job(jobmgr_t* mgr, job_t* j)
{
kvmgr_del(&(mgr->jobs), (void*)j->job.jobid);
}
int jobmgr_iter(jobmgr_t* mgr, xlist_t* l, void* arg)
{
return kvmgr_iter(&(mgr->jobs), NULL, l, arg);
}
typedef struct {
my_rwlock_t lock;
} xkvmgr_private_t;

18
src/lib/resreq.c
View file

@ -435,7 +435,7 @@ int format_resreq(char** buf, xce_resreq_t* resreq)
return rc;
}
int calc_wanted_global_resvals(xvec_idval_t* resvals, resmgr_t* resmgr,
int calc_wanted_global_resvals(xvec_idval_t* resvals, var resmgr,
xlist_t* rusages, rusage_per_type_t perflag,
int nhosts, int nslots)
{
@ -446,12 +446,17 @@ int calc_wanted_global_resvals(xvec_idval_t* resvals, resmgr_t* resmgr,
xce_resource_t* r = NULL;
float val;
rusage_per_type_t perflag1;
int rc = 0;
if (v == NULL) {
continue;
}
r = resmgr_lockres(resmgr, v->res, OBJREF_NOP);
rc = key_find(resmgr, (void*)v->res, (void**)&r);
if (rc <= 0) {
continue;
}
if (r == NULL) {
continue;
}
@ -486,7 +491,7 @@ int calc_wanted_global_resvals(xvec_idval_t* resvals, resmgr_t* resmgr,
return 0;
}
int calc_wanted_host_resvals(xvec_idval_t* resvals, resmgr_t* resmgr,
int calc_wanted_host_resvals(xvec_idval_t* resvals, var resmgr,
xlist_t* rusages, rusage_per_type_t perflag,
int nhosts, int nslots)
{
@ -497,12 +502,17 @@ int calc_wanted_host_resvals(xvec_idval_t* resvals, resmgr_t* resmgr,
xce_resource_t* r = NULL;
float val;
rusage_per_type_t perflag1;
int rc = 0;
if (v == NULL) {
continue;
}
r = resmgr_lockres(resmgr, v->res, OBJREF_NOP);
rc = key_find(resmgr, (void*)v->res, (void**)&r);
if (rc <= 0) {
continue;
}
if (r == NULL) {
continue;
}

69
src/lib/testsuite/test_group.c
View file

@ -5,16 +5,17 @@
#include "group.h"
#include "utils.h"
#include "xstring.h"
static void test_all(void)
{
groupmgr_t mgr;
var mgr;
xce_group_t* all = NULL;
int rc = 0;
groupmgr_init(&mgr, 16, 16);
all = get_group(&mgr, "all");
all = get_group(mgr, "all");
TEST_ASSERT_TRUE(all != NULL);
@ -22,18 +23,18 @@ static void test_all(void)
TEST_ASSERT_TRUE(rc > 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_empty(void)
{
groupmgr_t mgr;
var mgr;
xce_group_t* empty = NULL;
int rc = 0;
groupmgr_init(&mgr, 16, 16);
empty = get_group(&mgr, "empty");
empty = get_group(mgr, "empty");
TEST_ASSERT_TRUE(empty != NULL);
@ -41,12 +42,12 @@ static void test_empty(void)
TEST_ASSERT_TRUE(rc == 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_all_1(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.name = "g1",
.members = { .count = 1, .data = (char*[]) { "all" } }
@ -57,7 +58,7 @@ static void test_all_1(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata, NULL);
g = makeGroup(mgr, &gdata, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -65,12 +66,12 @@ static void test_all_1(void)
TEST_ASSERT_TRUE(rc > 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_all_2(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.name = "g1",
.members = { .count = 2, .data = (char*[]) { "g2", "all" } }
@ -81,7 +82,7 @@ static void test_all_2(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata, NULL);
g = makeGroup(mgr, &gdata, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -89,12 +90,12 @@ static void test_all_2(void)
TEST_ASSERT_TRUE(rc > 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_empty_1(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.name = "g1",
.ex_members = { .count = 1, .data = (char*[]) { "all" } }
@ -105,7 +106,7 @@ static void test_empty_1(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata, NULL);
g = makeGroup(mgr, &gdata, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -113,12 +114,12 @@ static void test_empty_1(void)
TEST_ASSERT_TRUE(rc == 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_empty_2(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.name = "g1",
.members = { .count = 1, .data = (char*[]) { "empty" } }
@ -129,7 +130,7 @@ static void test_empty_2(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata, NULL);
g = makeGroup(mgr, &gdata, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -137,12 +138,12 @@ static void test_empty_2(void)
TEST_ASSERT_TRUE(rc == 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_include(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.name = "g1",
.members = { .count = 1, .data = (char*[]) { "rshen" } }
@ -153,7 +154,7 @@ static void test_include(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata, NULL);
g = makeGroup(mgr, &gdata, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -161,12 +162,12 @@ static void test_include(void)
TEST_ASSERT_TRUE(rc > 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_exclude(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.name = "g1",
.members = { .count = 1, .data = (char*[]) { "all" } },
@ -178,7 +179,7 @@ static void test_exclude(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata, NULL);
g = makeGroup(mgr, &gdata, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -186,12 +187,12 @@ static void test_exclude(void)
TEST_ASSERT_TRUE(rc == 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_nest(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata1 = {
.name = "g1",
.members = { .count = 1, .data = (char*[]) { "rshen" } }
@ -206,11 +207,11 @@ static void test_nest(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata1, NULL);
g = makeGroup(mgr, &gdata1, NULL);
TEST_ASSERT_TRUE(g != NULL);
g = build_group(&mgr, &gdata2, NULL);
g = makeGroup(mgr, &gdata2, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -218,12 +219,12 @@ static void test_nest(void)
TEST_ASSERT_TRUE(rc != 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
static void test_nest2(void)
{
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata1 = {
.name = "g1",
.members = { .count = 1, .data = (char*[]) { "rshen" } }
@ -239,11 +240,11 @@ static void test_nest2(void)
groupmgr_init(&mgr, 16, 16);
g = build_group(&mgr, &gdata1, NULL);
g = makeGroup(mgr, &gdata1, NULL);
TEST_ASSERT_TRUE(g != NULL);
g = build_group(&mgr, &gdata2, NULL);
g = makeGroup(mgr, &gdata2, NULL);
TEST_ASSERT_TRUE(g != NULL);
@ -251,13 +252,15 @@ static void test_nest2(void)
TEST_ASSERT_TRUE(rc == 0);
groupmgr_fini(&mgr);
destroy(mgr);
}
void test_group(void)
{
printf("\n>> group test\n\n");
xstring_table_init(139);
RUN_TEST(test_all);
RUN_TEST(test_empty);
RUN_TEST(test_all_1);
@ -268,4 +271,6 @@ void test_group(void)
RUN_TEST(test_exclude);
RUN_TEST(test_nest);
RUN_TEST(test_nest2);
xstring_table_fini();
}

97
src/lib/testsuite/test_limit.c
View file

@ -1,3 +1,4 @@
#include <rtti.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
@ -6,11 +7,12 @@
#include "group.h"
#include "xce/types.h"
#include "xcelimit.h"
#include "xstring.h"
static void test_build_consumer1(void)
{
xce_consumer_t* c = NULL;
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.members = { .count = 2, .data = (char*[]) { "rshen", "jsxing" } }
};
@ -18,7 +20,7 @@ static void test_build_consumer1(void)
char buf[1024];
groupmgr_init(&mgr, 4, 4);
rc = build_consumer(&c, &mgr, CONSUMER_USER, 1, &gdata, "user_group1");
rc = build_consumer(&c, mgr, CONSUMER_USER, 1, &gdata, "user_group1");
TEST_ASSERT_TRUE(rc == 1);
@ -29,14 +31,15 @@ static void test_build_consumer1(void)
kill_consumer(c);
groupmgr_fini(&mgr);
destroy(mgr);
return;
}
static void test_build_consumer2(void)
{
xce_consumer_t* c = NULL;
groupmgr_t mgr;
var mgr;
xce_group_config_t gdata = {
.members = { .count = 1, .data = (char*[]) { "all" } },
.ex_members = { .count = 2, .data = (char*[]) { "rshen", "jsxing" } }
@ -45,7 +48,7 @@ static void test_build_consumer2(void)
char buf[1024];
groupmgr_init(&mgr, 4, 4);
rc = build_consumer(&c, &mgr, CONSUMER_USER, 1, &gdata, "user_group1");
rc = build_consumer(&c, mgr, CONSUMER_USER, 1, &gdata, "user_group1");
TEST_ASSERT_TRUE(rc == 1);
@ -57,13 +60,17 @@ static void test_build_consumer2(void)
kill_consumer(c);
groupmgr_fini(&mgr);
destroy(mgr);
return;
}
static void test_build_limit_ok1(void)
{
groupmgr_t umgr, qmgr, hmgr, pmgr;
var umgr;
var qmgr;
var hmgr;
var pmgr;
xce_limit_t* limit;
int rc;
xce_limit_config_t limit_config = {
@ -88,7 +95,7 @@ static void test_build_limit_ok1(void)
groupmgr_init(&hmgr, 4, 4);
groupmgr_init(&pmgr, 4, 4);
rc = build_limit(&limit, &umgr, &qmgr, &hmgr, &pmgr, &limit_config);
rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
TEST_ASSERT_TRUE(rc == 1);
memset(buf, 0x0, sizeof(buf));
@ -100,15 +107,18 @@ static void test_build_limit_ok1(void)
kill_limit(limit);
groupmgr_fini(&pmgr);
groupmgr_fini(&hmgr);
groupmgr_fini(&qmgr);
groupmgr_fini(&umgr);
destroy(pmgr);
destroy(hmgr);
destroy(qmgr);
destroy(umgr);
}
static void test_match_limit_ok1(void)
{
groupmgr_t umgr, qmgr, hmgr, pmgr;
var umgr;
var qmgr;
var hmgr;
var pmgr;
xce_limit_t* limit;
int rc;
xce_limit_config_t limit_config = {
@ -137,7 +147,7 @@ static void test_match_limit_ok1(void)
groupmgr_init(&hmgr, 4, 4);
groupmgr_init(&pmgr, 4, 4);
rc = build_limit(&limit, &umgr, &qmgr, &hmgr, &pmgr, &limit_config);
rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
TEST_ASSERT_TRUE(rc == 1);
memset(buf, 0x0, sizeof(buf));
@ -152,15 +162,18 @@ static void test_match_limit_ok1(void)
kill_limit(limit);
groupmgr_fini(&pmgr);
groupmgr_fini(&hmgr);
groupmgr_fini(&qmgr);
groupmgr_fini(&umgr);
destroy(pmgr);
destroy(hmgr);
destroy(qmgr);
destroy(umgr);
}
static void test_match_limit_ok2(void)
{
groupmgr_t umgr, qmgr, hmgr, pmgr;
var umgr;
var qmgr;
var hmgr;
var pmgr;
xce_limit_t* limit;
int rc;
xce_limit_config_t limit_config = {
@ -183,7 +196,7 @@ static void test_match_limit_ok2(void)
groupmgr_init(&hmgr, 4, 4);
groupmgr_init(&pmgr, 4, 4);
rc = build_limit(&limit, &umgr, &qmgr, &hmgr, &pmgr, &limit_config);
rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
TEST_ASSERT_TRUE(rc == 1);
memset(buf, 0x0, sizeof(buf));
@ -198,15 +211,18 @@ static void test_match_limit_ok2(void)
kill_limit(limit);
groupmgr_fini(&pmgr);
groupmgr_fini(&hmgr);
groupmgr_fini(&qmgr);
groupmgr_fini(&umgr);
destroy(pmgr);
destroy(hmgr);
destroy(qmgr);
destroy(umgr);
}
static void test_match_limit1(void)
{
groupmgr_t umgr, qmgr, hmgr, pmgr;
var umgr;
var qmgr;
var hmgr;
var pmgr;
xce_limit_t* limit;
int rc;
xce_limit_config_t limit_config = {
@ -238,7 +254,7 @@ static void test_match_limit1(void)
groupmgr_init(&hmgr, 4, 4);
groupmgr_init(&pmgr, 4, 4);
rc = build_limit(&limit, &umgr, &qmgr, &hmgr, &pmgr, &limit_config);
rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
TEST_ASSERT_TRUE(rc == 1);
memset(buf, 0x0, sizeof(buf));
@ -253,15 +269,18 @@ static void test_match_limit1(void)
kill_limit(limit);
groupmgr_fini(&pmgr);
groupmgr_fini(&hmgr);
groupmgr_fini(&qmgr);
groupmgr_fini(&umgr);
destroy(pmgr);
destroy(hmgr);
destroy(qmgr);
destroy(umgr);
}
static void test_match_limit2(void)
{
groupmgr_t umgr, qmgr, hmgr, pmgr;
var umgr;
var qmgr;
var hmgr;
var pmgr;
xce_limit_t* limit;
int rc;
xce_limit_config_t limit_config = {
@ -289,7 +308,7 @@ static void test_match_limit2(void)
groupmgr_init(&hmgr, 4, 4);
groupmgr_init(&pmgr, 4, 4);
rc = build_limit(&limit, &umgr, &qmgr, &hmgr, &pmgr, &limit_config);
rc = build_limit(&limit, umgr, qmgr, hmgr, pmgr, &limit_config);
TEST_ASSERT_TRUE(rc == 1);
memset(buf, 0x0, sizeof(buf));
@ -304,15 +323,18 @@ static void test_match_limit2(void)
kill_limit(limit);
groupmgr_fini(&pmgr);
groupmgr_fini(&hmgr);
groupmgr_fini(&qmgr);
groupmgr_fini(&umgr);
destroy(pmgr);
destroy(hmgr);
destroy(qmgr);
destroy(umgr);
}
void test_limit(void)
{
printf("\n>> limit test\n\n");
xstring_table_init(139);
RUN_TEST(test_build_consumer1);
RUN_TEST(test_build_consumer2);
RUN_TEST(test_build_limit_ok1);
@ -320,5 +342,6 @@ void test_limit(void)
RUN_TEST(test_match_limit_ok2);
RUN_TEST(test_match_limit1);
RUN_TEST(test_match_limit2);
}
xstring_table_fini();
}

47
src/lib/xcelimit.c
View file

@ -1,4 +1,5 @@
#include <errno.h>
#include <rtti.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
@ -104,12 +105,11 @@ int build_consumer(xce_consumer_t** pconsumer, groupmgr_t* mgr,
sprintf(consumer_group_name, "%s-%s-group", default_name_prefix,
suffix);
default_g_name = consumer_group_name;
}
else {
} else {
default_g_name = g_config->name;
}
g = build_group(mgr, g_config, default_g_name);
g = makeGroup(mgr, g_config, default_g_name);
if (g == NULL) {
return -ENOMEM;
}
@ -369,16 +369,21 @@ int build_vres_name(char** vname, xce_limit_t* limit, char* user, char* queue,
return -ENOMEM;
}
int is_host_based_limit(resmgr_t* mgr, xce_limit_t* limit)
int is_host_based_limit(var resmgr, xce_limit_t* limit)
{
xce_consumer_t* c = NULL;
xce_resource_t* r = NULL;
int rc = 0;
xce_consumer_t* c = NULL;
xce_resource_t* r = NULL;
if (limit == NULL) {
return -EINVAL;
}
r = resmgr_lockres(mgr, limit->val.resname, OBJREF_NOP);
rc = key_find(resmgr, (void*)limit->val.resname, (void**)&r);
if (rc <= 0) {
return -ENOENT;
}
if ((r->flags & (XCE_RESF_GLOBAL | XCE_RESF_SHARED)) == 0) {
if (limit->val.percent != 0) {
return 1;
@ -393,7 +398,7 @@ int is_host_based_limit(resmgr_t* mgr, xce_limit_t* limit)
return c->per_consumer;
}
int add_vres(xce_resource_t** pvres, resmgr_t* mgr, char* name, int global)
int add_vres(xce_resource_t** pvres, var resmgr, char* name, int global)
{
xce_resource_t* vres = NULL;
int rc;
@ -417,7 +422,7 @@ int add_vres(xce_resource_t** pvres, resmgr_t* mgr, char* name, int global)
vres->flags |= XCE_RESF_DEFAULT_HOST;
}
rc = resmgr_add_res(mgr, vres);
rc = key_add(resmgr, (void*)vres->name, (void*)vres);
if (rc < 0) {
return rc;
}
@ -426,7 +431,7 @@ int add_vres(xce_resource_t** pvres, resmgr_t* mgr, char* name, int global)
return rc;
}
int instantiate_limit(xce_vres_t** pvres, resmgr_t* mgr, xce_limit_t* limit,
int instantiate_limit(xce_vres_t** pvres, var resmgr, xce_limit_t* limit,
char* user, char* queue, char* project)
{
xce_vres_t* vres = NULL;
@ -434,7 +439,7 @@ int instantiate_limit(xce_vres_t** pvres, resmgr_t* mgr, xce_limit_t* limit,
char* vresname = NULL;
int shared = 1;
if ((pvres == NULL) || (mgr == NULL) || (limit == NULL) || (user == NULL)
if ((pvres == NULL) || (resmgr == NULL) || (limit == NULL) || (user == NULL)
|| (queue == NULL) || (project == NULL)) {
return -EINVAL;
}
@ -448,7 +453,7 @@ int instantiate_limit(xce_vres_t** pvres, resmgr_t* mgr, xce_limit_t* limit,
vres->limit = limit;
if (is_host_based_limit(mgr, limit)) {
if (is_host_based_limit(resmgr, limit)) {
shared = 0;
}
@ -457,9 +462,13 @@ int instantiate_limit(xce_vres_t** pvres, resmgr_t* mgr, xce_limit_t* limit,
return rc;
}
vres->vres = resmgr_lockres(mgr, vresname, OBJREF_NOP);
if (vres->vres == NULL) {
rc = add_vres(&(vres->vres), mgr, vresname, shared);
rc = key_find(resmgr, (void*)vresname, (void**)&(vres->vres));
if (rc < 0) {
return rc;
}
if (rc == 0) {
rc = add_vres(&(vres->vres), resmgr, vresname, shared);
if (rc < 0) {
FREEUP(vresname);
return rc;
@ -468,8 +477,12 @@ int instantiate_limit(xce_vres_t** pvres, resmgr_t* mgr, xce_limit_t* limit,
FREEUP(vresname);
vres->res = resmgr_lockres(mgr, limit->val.resname, OBJREF_NOP);
if (vres->res == NULL) {
rc = key_find(resmgr, (void*)limit->val.resname, (void**)&(vres->res));
if (rc < 0) {
return rc;
}
if (rc == 0) {
return -ENOENT;
}

133
src/lib/xstring.c
View file

@ -10,139 +10,6 @@
#include "utils.h"
#include "xstring.h"
static void* xstring_create(objmgr_t*, objtype_t*, va_list);
static void xstring_fini(void*);
static void xstring_type_fini(objtype_t*);
static xstring_typedata_t xstring_typedata;
static objtype_t xstring
= { .type = "xstring",
.fn_create = (obj_create_fn_t)xstring_create,
.fn_fini = xstring_fini,
.fn_type_fini = (objtype_fini_fn_t)xstring_type_fini,
.typedata = &xstring_typedata };
static void xstring_obj_killer(myobj_t* obj)
{
if (obj == NULL) {
return;
}
memset(obj, 0x0, sizeof(*obj));
free(obj);
}
int register_xstring(objmgr_t* mgr, int nslots, int delta)
{
ht_init(&(xstring_typedata.tab), nslots, string_hash_key);
zarray_init(&(xstring_typedata.strings), delta,
(zarray_item_killer_t)xstring_obj_killer);
return objmgr_register(mgr, &xstring);
}
static void* xstring_create(objmgr_t* mgr, objtype_t* type, va_list ap)
{
char* s = va_arg(ap, char*);
char* p = NULL;
myobj_t* obj = NULL;
hent_t* e = NULL;
xstring_typedata_t* typedata = NULL;
int32_t idx;
if (s == NULL) {
SET_ERROR(EINVAL);
return NULL;
}
typedata = (xstring_typedata_t*)type->typedata;
e = ht_get((htab_t*)&(typedata->tab), (void*)s);
if (e != NULL) {
idx = e->data;
obj = (myobj_t*)zarray_get(&(typedata->strings), idx);
if (obj != NULL) {
p = MYOBJ_TO_OBJ(char*, obj);
return obj_ref(p, OBJREF_NOP);
}
SET_ERROR(EINVAL);
return NULL;
}
obj = (myobj_t*)calloc(1, sizeof(*obj) + strlen(s) + 1);
if (obj == NULL) {
return NULL;
}
idx = zarray_store(&(typedata->strings), obj);
if (idx < 0) {
free(obj);
SET_ERROR(-idx);
return NULL;
}
obj_init(mgr, type, idx, obj);
p = MYOBJ_TO_OBJ(char*, obj);
strcpy(p, s);
e = ht_add((htab_t*)&(typedata->tab), (void*)s);
if (e == NULL) {
obj_deref(p);
return NULL;
}
e->data = idx;
return p;
}
/* this will ONLY be called by obj_deref() */
static void xstring_fini(void* s)
{
myobj_t* myobj;
objtype_t* typeval;
xstring_typedata_t* typedata;
int32_t idx;
if (s == NULL) {
return;
}
myobj = TO_MYOBJ(s);
typeval = myobj->type;
typedata = (xstring_typedata_t*)typeval->typedata;
if (typedata == NULL) {
return;
}
ht_del(&(typedata->tab), (void*)s);
idx = (int32_t)myobj->exdata;
if (idx >= 0) {
zarray_del(&(typedata->strings), idx);
}
return;
}
static void xstring_type_fini(objtype_t* typeval)
{
xstring_typedata_t* typedata = (xstring_typedata_t*)typeval->typedata;
if (typedata == NULL) {
return;
}
ht_fini(&(typedata->tab));
zarray_fini(&(typedata->strings));
}
static struct {
mylock_t lock;
var xstr_table;