示例#1
0
/* Walk admin namespaces */
static void
areFellowNameSpacesCompatible(
    d_nameSpace adminNs,
    c_voidp args)
{
    struct compatibilityHelper* walkData;
    d_networkAddress address;
    char* localPartitions;
    char* remotePartitions;

    walkData    = (struct compatibilityHelper*)args;

    walkData->ns = adminNs;

    if (!d_fellowNameSpaceWalk(walkData->fellow, isFellowNameSpaceCompatible, walkData))
    {
        walkData->compatible = FALSE;
        localPartitions = d_nameSpaceGetPartitions(adminNs);
        remotePartitions = d_nameSpaceGetPartitions(walkData->fellowNs);
        address = d_fellowGetAddress (walkData->fellow);

        OS_REPORT_2(OS_ERROR, D_CONTEXT, 0,
            "Namespace '%s' from fellow '%d' is incompatible with local namespace.",
            d_nameSpaceGetName(adminNs), address->systemId);

        OS_REPORT_2(OS_ERROR, D_CONTEXT, 0,
            "Partition expressions are '%s'(local) and '%s'(remote).",
            localPartitions, remotePartitions);

        d_networkAddressFree(address);
        os_free (localPartitions);
        os_free (remotePartitions);
    }
}
示例#2
0
static c_char*
getPersistentPartitionExpression(
    d_admin admin,
    d_durability durability)
{
    c_char *result, *expr;
    d_nameSpace ns;
    d_durabilityKind dkind;
    c_ulong length;
    c_long i, j;
    c_iter nameSpaces;

    result = NULL;

    assert (admin);

    /* Collect namespaces */
    nameSpaces = d_adminNameSpaceCollect(admin);

    if(admin){
        length = 0;
        j = 0;

        for(i=0; i<c_iterLength(nameSpaces); i++){
            ns    = d_nameSpace(c_iterObject(nameSpaces, i));
            dkind = d_nameSpaceGetDurabilityKind(ns);

            if((dkind == D_DURABILITY_PERSISTENT) || (dkind == D_DURABILITY_ALL)){
                expr = d_nameSpaceGetPartitions(ns);
                if(j==0){
                    length += strlen(expr);
                } else {
                    length += strlen(expr) + 1; /*for the comma*/
                }
                os_free(expr);
                j++;
            }
        }

        if(length > 0){
            result = (c_char*)(os_malloc(length + 1));
            result[0] = '\0';
            j = 0;

            for(i=0; i<c_iterLength(nameSpaces); i++){
                ns    = d_nameSpace(c_iterObject(nameSpaces, i));
                dkind = d_nameSpaceGetDurabilityKind(ns);

                if((dkind == D_DURABILITY_PERSISTENT) || (dkind == D_DURABILITY_ALL)){
                    expr = d_nameSpaceGetPartitions(ns);

                    if(j != 0){
                        os_strcat(result, ",");
                    }
                    os_strcat(result, expr);
                    os_free(expr);
                    j++;
                }
            }
        }

        d_adminNameSpaceCollectFree(admin, nameSpaces);
    }

    if(result){
        d_printTimedEvent(durability, D_LEVEL_FINE,
            D_THREAD_PERISTENT_DATA_LISTENER,
            "Persistent partition expression is: '%s'\n", result);
    } else {
        d_printTimedEvent(durability, D_LEVEL_FINE,
            D_THREAD_PERISTENT_DATA_LISTENER,
            "Persistent partition expression is empty.\n");
    }
    return result;
}