/**************************************************************
* Private functions
**************************************************************/
static c_bool
v__partitionAdminAdd(
v_partitionAdmin da,
const char *partitionName,
v_partition *newPartition)
{
c_bool result = TRUE;
v_partition partition, found;
assert(v_partitionExpressionIsAbsolute(partitionName));
assert(newPartition != NULL);
partition = v_partitionNew(v_objectKernel(da), partitionName, NULL);
found = c_tableInsert(da->partitions, partition);
if (found != partition) {
c_free(partition);
result = FALSE;
*newPartition = NULL;
} else {
/* Do not free partition here because it is returned */
*newPartition = partition;
}
return result;
}
static c_bool
v_partitionAdminRemoveExpression(
v_partitionAdmin da,
const char *partitionExpr)
{
c_bool result = FALSE;
v_partitionInterest partitionInterest, found;
q_expr expr;
c_collection q;
c_iter list;
c_value params[1];
assert(!v_partitionExpressionIsAbsolute(partitionExpr));
expr = (q_expr)q_parse("expression like %0");
params[0] = c_stringValue((char *)partitionExpr);
q = c_queryNew(da->partitionInterests, expr, params);
q_dispose(expr);
list = ospl_c_select(q,0);
assert(c_iterLength(list) <= 1);
partitionInterest = v_partitionInterest(c_iterTakeFirst(list));
while (partitionInterest) {
result = TRUE;
found = c_tableRemove(da->partitionInterests, partitionInterest, NULL, NULL);
c_free(partitionInterest);
c_free(found);
partitionInterest = v_partitionInterest(c_iterTakeFirst(list));
}
c_free(q);
c_iterFree(list);
return result;
}
v_partition
v_partitionNew(
v_kernel kernel,
const c_char *name,
v_partitionQos qos)
{
v_partition partition, found;
assert(kernel != NULL);
assert(C_TYPECHECK(kernel,v_kernel));
assert(name != NULL);
assert(v_partitionExpressionIsAbsolute(name));
partition = v_partition(v_objectNew(kernel,K_DOMAIN));
v_entityInit(v_entity(partition),name, NULL, TRUE);
found = v_addPartition(kernel,partition);
if (found != partition) {
v_partitionFree(partition);
c_free(partition); /* v_partitionFree has removed all dependancies, now delete local reference */
partition = c_keep(found); /* this one will be returned, so a keep is required */
}
return partition;
}
c_bool
v_partitionStringMatchesExpression(
const c_char* string,
const c_char* expression)
{
c_bool result = FALSE;
c_value matchResult;
c_value expressionValue;
c_value stringValue;
assert(string);
assert(expression);
if(v_partitionExpressionIsAbsolute(expression))
{
if(strcmp(expression, string) == 0)
{
result = TRUE;
}
} else
{
expressionValue.kind = V_STRING;
expressionValue.is.String = (c_char*)expression;
stringValue.kind = V_STRING;
stringValue.is.String = (c_char*)string;
matchResult = c_valueStringMatch(expressionValue, stringValue);
if(matchResult.is.Boolean == TRUE)
{
result = TRUE;
}
}
return result;
}
static c_bool
v_partitionAdminAddExpression(
v_partitionAdmin da,
const char *partitionExpr)
{
c_bool result = TRUE;
v_partitionInterest partitionInterest, found;
assert(!v_partitionExpressionIsAbsolute(partitionExpr));
partitionInterest = v_partitionInterestNew(v_objectKernel(da), partitionExpr);
found = c_tableInsert(da->partitionInterests, partitionInterest);
if (found != partitionInterest) {
result = FALSE;
}
c_free(partitionInterest);
return result;
}
static c_bool
v__partitionAdminRemove(
v_partitionAdmin da,
const char *partitionName,
v_partition *partitionRemoved)
{
c_bool result;
v_partition partition, found;
q_expr expr;
c_collection q;
c_iter list;
c_value params[1];
assert(v_partitionExpressionIsAbsolute(partitionName));
expr = (q_expr)q_parse("name like %0");
params[0] = c_stringValue((char *)partitionName);
q = c_queryNew(da->partitions, expr, params);
q_dispose(expr);
list = ospl_c_select(q,0);
assert(c_iterLength(list) <= 1);
partition = v_partition(c_iterTakeFirst(list));
if (partition) {
found = c_tableRemove(da->partitions, partition, NULL, NULL);
*partitionRemoved = found;
c_free(partition);
result = TRUE;
} else {
*partitionRemoved = NULL;
result = FALSE;
}
c_free(q);
c_iterFree(list);
return result;
}
c_iter
v_partitionAdminRemove(
v_partitionAdmin da,
const c_char *partitionExpr)
{
/* partitionExpr: expression or absolute partition name */
c_iter partitions;
v_partition d;
partitions = NULL;
c_mutexLock(&da->mutex);
if (v_partitionExpressionIsAbsolute(partitionExpr)) {
v__partitionAdminRemove(da, partitionExpr, &d);
partitions = c_iterNew(d);
} else {
if (v_partitionAdminRemoveExpression(da, partitionExpr)) {
partitions = v_resolvePartitions(v_objectKernel(da), partitionExpr);
c_iterWalk(partitions, removePartition, (c_voidp)da->partitions);
} /* else expression already member */
}
c_mutexUnlock(&da->mutex);
return partitions;
}
c_bool
v_partitionAdminSet(
v_partitionAdmin da,
v_partitionPolicy partitionExpr,
c_iter *addedPartitions,
c_iter *removedPartitions)
{
c_iter dexpressions; /* iterator of partition expressions */
c_char *dexpr; /* partition expression */
v_partitionInterest di;
struct resolvePartitionsArg resolveArg;
struct updatePartitionsArg updateArg;
assert(C_TYPECHECK(da, v_partitionAdmin));
assert(removedPartitions != NULL);
assert(addedPartitions != NULL);
*removedPartitions = NULL;
*addedPartitions = NULL;
resolveArg.kernel = v_objectKernel(da);
c_mutexLock(&da->mutex);
/*
* The absolute partition names will be added at the end of
* the algorithm.
* The partition expressions in the parameter of partitionExpr,
* replace the existing in da->partitionInterests.
*/
c_free(da->partitionInterests);
da->partitionInterests = c_tableNew(v_kernelType(resolveArg.kernel, K_DOMAININTEREST),
"expression");
assert(c_count(da->partitionInterests) == 0);
dexpressions = v_partitionPolicySplit(partitionExpr);
if (dexpressions == NULL) {
/* switch to default */
*addedPartitions = c_iterInsert(*addedPartitions, v_partitionNew(resolveArg.kernel, "", NULL));
} else {
dexpr = (c_char *)c_iterTakeFirst(dexpressions);
while (dexpr != NULL) {
if (v_partitionExpressionIsAbsolute(dexpr)) {
*addedPartitions = c_iterInsert(*addedPartitions,
v_partitionNew(resolveArg.kernel, dexpr, NULL));
/* ref transferred to addedPartitions */
} else {
di = v_partitionInterestNew(resolveArg.kernel, (const c_char *)dexpr);
c_tableInsert(da->partitionInterests, di);
c_free(di);
}
os_free(dexpr);
dexpr = (c_char *)c_iterTakeFirst(dexpressions);
}
c_iterFree(dexpressions);
}
/*
* The given expressions are now divided across
* 'addedpartitions' and 'da->partitionInterests'.
* Now first add partitions to 'addedpartitions' that fit the
* expressions in 'da->partitionInterests'.
*/
resolveArg.partitions = addedPartitions;
c_tableWalk(da->partitionInterests, resolvePartitions, (c_voidp)&resolveArg);
/*
* Now 'addedpartitions' contains all partitions to be added
* by the publisher/subscriber.
* 'da->partitions' contains the old set of partitions.
* We must check whether those partitions must remain in
* the set or must be removed.
* For every partition in 'da->partitions' do
* if partition in 'addedpartitions' then remove from 'addedpartitions'
* else add to 'removedpartitions'
* For every partition in 'removedpartitions' remove from 'da->partitions'.
*/
updateArg.addPartitions = addedPartitions;
updateArg.removePartitions = removedPartitions;
c_tableWalk(da->partitions, updatePartitions, (c_voidp)&updateArg);
c_iterWalk(*removedPartitions, removePartition, (c_voidp)da->partitions);
/*
* The da->partitions now contains partitions that still comply to new
* partitionPolicy. So all partitions in added partitions, must be added
* to da->partitions, so it reflects all connected partitions.
*/
c_iterWalk(*addedPartitions, addPartition, (c_voidp)da->partitions);
c_mutexUnlock(&da->mutex);
return TRUE;
}
