namespacemanager.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

        nameSpace->print(os);
    }

    os << PEGASUS_STD(endl);
}

void NameSpaceManager::createClass(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className,
    const CIMName& superClassName,
    String& classFilePath)
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::createClass()");

    // -- Lookup namespace:

    NameSpace *nameSpace=0,*ens=0;

    if (!_rep->table.lookup(nameSpaceName.getString (), nameSpace))
    {
        PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4, "Invalid NameSpace.");
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION
            (CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    if (nameSpace->readOnly())
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_ACCESS_DENIED, "R/O Namespace "+nameSpaceName.getString());
    }

    InheritanceTree& it = nameSpace->getInheritanceTree();

    // -- Be certain class doesn't already exist:

    if (it.containsClass(className))
    {
        PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
            "Class already exists.");
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_ALREADY_EXISTS, className.getString());
    }

    if (nameSpace->parent)
    {
        InheritanceTree& it = nameSpace->parent->getInheritanceTree();
        if (it.containsClass(className))
        {
            PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
                "Class already exists.");
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(
                CIM_ERR_ALREADY_EXISTS, className.getString());
        }
    }
    else
    {
        NameSpace* ns = nameSpace->dependent;
        while (ns)
        {
            if (!ns->readOnly())
            {
                InheritanceTree& it = ns->getInheritanceTree();
                if (it.containsClass(className))
                {
                    PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
                        "Class already exists.");
                    PEG_METHOD_EXIT();
                    throw PEGASUS_CIM_EXCEPTION(
                        CIM_ERR_ALREADY_EXISTS, className.getString());
                }
            }
            ns = ns->nextDependent;
        }
    }

    // -- Be certain superclass exists:

    Boolean xNameSpace = false;
    Boolean missing = false;

    if (superClassName.isNull())
    {
        if (nameSpace->parent)
            xNameSpace = true;
    }
    else if (!it.containsClass(superClassName))
    {
        if (nameSpace->parent)
        {
            InheritanceTree& it = nameSpace->parent->getInheritanceTree();
            if (!it.containsClass(superClassName))
                missing = true;
            xNameSpace = true;
        }
        else
            missing = false;
    }

    if (missing)
    {
        PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
            "SuperClass does not exist.");
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_SUPERCLASS, superClassName.getString());
    }

#ifndef PEGASUS_SUPPORT_UTF8_FILENAME
    // Do not allow file names to contain characters outsie of 7-bit ascii.
    String tmp = className.getString();
    Uint32 len = tmp.size();
    for (Uint32 i = 0; i < len; ++i)
        if ((Uint16)tmp[i] > 0x007F)
            throw PEGASUS_CIM_EXCEPTION(
                CIM_ERR_INVALID_PARAMETER, nameSpaceName.getString());
#endif


    // -- Insert the entry:

    if (xNameSpace)
        it.insert(
            className.getString(),
            superClassName.getString(),
            nameSpace->parent->getInheritanceTree(),
            nameSpace);
    else
        it.insert(className.getString(), superClassName.getString());

    // -- Build the path to the class:

    classFilePath = _MakeClassFilePath(
        nameSpace->getNameSpacePath(), className, superClassName);

    PEG_METHOD_EXIT();
}

void NameSpaceManager::checkModify(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className,
    const CIMName& superClassName,
    String& classFilePath)
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::checkModify()");

    // -- Lookup namespace:

    NameSpace* nameSpace = 0;

    if (!_rep->table.lookup(nameSpaceName.getString (), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    InheritanceTree& it = nameSpace->getInheritanceTree();

    // -- Disallow changing of superclass:

    CIMName oldSuperClassName;

    if (!it.getSuperClass(className, oldSuperClassName))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_NOT_FOUND, className.getString());
    }

    if (!superClassName.equal(oldSuperClassName))
    {
        PEG_METHOD_EXIT();

        throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_FAILED,
            MessageLoaderParms(
                "Repository.NameSpaceManager.ATTEMPT_TO_CHANGE_SUPERCLASS",
                "attempt to change superclass"));
    }

    // -- Disallow modification of class with subclasses:

    Boolean hasSubClasses;
    it.hasSubClasses(className, hasSubClasses);

    if (hasSubClasses)
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_CLASS_HAS_CHILDREN, className.getString());
    }

    // -- Build the path to the class:

    classFilePath = _MakeClassFilePath(
        nameSpace->getNameSpacePath(), className, superClassName);

    PEG_METHOD_EXIT();
}

void NameSpaceManager::getSubClassNames(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className,
    Boolean deepInheritance,
    Array<CIMName>& subClassNames,
    Boolean enm) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::getSubClassNames()");

    // -- Lookup namespace:

    NameSpace* nameSpace = 0, *dns = 0;

    if (!_rep->table.lookup(nameSpaceName.getString(), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    if (className.getString()=="" && nameSpace->parent)
        enm=true;

    if (enm && nameSpace->parent)
    {
        dns=nameSpace->rwParent();
        nameSpace=nameSpace->primaryParent();
    }
    InheritanceTree& it = nameSpace->getInheritanceTree();

    if (!it.getSubClassNames(className, deepInheritance, subClassNames, dns))
    {
        if (nameSpace->parent)
        {
            if (enm == false)
            {
                dns=nameSpace->rwParent();
                nameSpace=nameSpace->primaryParent();
                InheritanceTree& it = nameSpace->getInheritanceTree();
                if (it.getSubClassNames(
                    className, deepInheritance, subClassNames, 0))
                {
                    return;
                }
            }
        }
        else if (dns && enm)
        {
            InheritanceTree& it = dns->rwParent()->getInheritanceTree();
            if (it.getSubClassNames(
                    className, deepInheritance, subClassNames, 0))
            {
                return;
            }
        }
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_CLASS, className.getString());
    }

    PEG_METHOD_EXIT();
}

void NameSpaceManager::getSuperClassNames(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className,
    Array<CIMName>& subClassNames) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::getSuperClassNames()");

    // -- Lookup namespace:

    NameSpace* nameSpace = 0;

    if (!_rep->table.lookup(nameSpaceName.getString (), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }
    nameSpace=nameSpace->rwParent();

    InheritanceTree& it = nameSpace->getInheritanceTree();

    // -- Get names of all superclasses:
    if (!it.getSuperClassNames(className, subClassNames))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_CLASS, className.getString());
    }

    PEG_METHOD_EXIT();
}

String NameSpaceManager::getQualifiersRoot(
    const CIMNamespaceName& nameSpaceName) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::getQualifiersRoot()");

    // -- Lookup namespace:

    NameSpace* nameSpace = 0;

    if (!_rep->table.lookup(nameSpaceName.getString (), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    PEG_METHOD_EXIT();
    return nameSpace->getNameSpacePath() + _QUALIFIERS_SUFFIX;
}

Array<String> NameSpaceManager::getAssocClassPath(
    const CIMNamespaceName& nameSpaceName,
    NameSpaceIntendedOp op) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::getAssocClassPath()");

    // -- Lookup namespace:

    NameSpace* nameSpace = 0;

    Array<String> assocClassPathes;

    if (!_rep->table.lookup(nameSpaceName.getString(), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    if (nameSpace->ro) nameSpace = nameSpace->rwParent();

    assocClassPathes.append(nameSpace->getNameSpacePath() +
        _CLASSES_SUFFIX + _ASSOCIATIONS_SUFFIX);

    if (op==NameSpaceRead)
    {
        if (nameSpace->parent)
        {
            nameSpace = nameSpace->primaryParent();
            assocClassPathes.append(nameSpace->getNameSpacePath() +
                _CLASSES_SUFFIX + _ASSOCIATIONS_SUFFIX);
        }
    }

    PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
        String("Association class path = ") + assocClassPathes[0]);

    PEG_METHOD_EXIT();
    return assocClassPathes;
}

String NameSpaceManager::getAssocInstPath(
    const CIMNamespaceName& nameSpaceName) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::getAssocInstPath()");

    // -- Lookup namespace:

    NameSpace* nameSpace = 0;

    if (!_rep->table.lookup(nameSpaceName.getString(), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    String assocInstPath = nameSpace->getNameSpacePath() +
        _INSTANCES_SUFFIX + _ASSOCIATIONS_SUFFIX;
    PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
        String("Association instance path = ") + assocInstPath);

    PEG_METHOD_EXIT();
    return assocInstPath;
}

Boolean NameSpaceManager::classHasInstances(
    NameSpace *nameSpace,
    const CIMName& className,
    Boolean throwExcp) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::classHasChildren()");

    Boolean first=true;

    do
    {
        String indexFilePath =
            getInstanceDataFileBase(nameSpace, className) + ".idx";

        if (InstanceIndexFile::hasNonFreeEntries(indexFilePath))
        {
            PEG_METHOD_EXIT();
            if (throwExcp)
                throw PEGASUS_CIM_EXCEPTION(
                    CIM_ERR_CLASS_HAS_INSTANCES, className.getString());
            return true;
        }

        if (first)
        {
            nameSpace = nameSpace->dependent;
            first = false;
        }
        else
            nameSpace = nameSpace->nextDependent;
    } while (nameSpace);

    PEG_METHOD_EXIT();
    return false;
}

Boolean NameSpaceManager::classHasInstances(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className,
    Boolean throwExcp) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::classHasChildren()");

    NameSpace* nameSpace = 0;

    if (!_rep->table.lookup(nameSpaceName.getString(), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    PEG_METHOD_EXIT();
    return classHasInstances(nameSpace,className,throwExcp);
}

Boolean NameSpaceManager::classExists(
    NameSpace *nameSpace,
    const CIMName& className,
    Boolean throwExcp) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::classExists()");

    Boolean first=true;

    do
    {
        InheritanceTree& it = nameSpace->getInheritanceTree();

        if (it.containsClass(className))
        {
            PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
                "Class already exists.");
            PEG_METHOD_EXIT();
            if (throwExcp)
                throw PEGASUS_CIM_EXCEPTION(
                    CIM_ERR_ALREADY_EXISTS, className.getString());
            return true;
        }

        if (first)
        {
            nameSpace = nameSpace->dependent;
            first = false;
        }
        else
            nameSpace = nameSpace->nextDependent;
    } while (nameSpace);

    PEG_METHOD_EXIT();
    return false;
}

Boolean NameSpaceManager::classExists(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::classExists()");

    NameSpace *nameSpace = 0;

    if (!_rep->table.lookup(nameSpaceName.getString(), nameSpace))
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_INVALID_NAMESPACE, nameSpaceName.getString());
    }

    Boolean exists = classExists(nameSpace, className, false);

    PEG_METHOD_EXIT();
    return exists;
}

PEGASUS_NAMESPACE_END