namespacemanager.cpp

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

    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_NOT_FOUND, " parent namespace " + parent + " not found");
    }

    if (parentSpace && parentSpace->final)
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(
            CIM_ERR_FAILED, " parent namespace " + parent + " not shareable");
    }

    if (updatesAllowed && parentSpace && parentSpace->parent)
    {
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
            " parent namespace " + parent + " not a primary namespace");
    }

#ifndef PEGASUS_SUPPORT_UTF8_FILENAME
    // Do not allow file names to contain characters outsie of 7-bit ascii.
    String tmp = nameSpaceName.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


    // Attempt to create all the namespace diretories:

    String nameSpaceDirName = _namespaceNameToDirName(nameSpaceName);
    String nameSpacePath = _repositoryRoot + "/" + nameSpaceDirName;
    String parentPath;
    if (parent.size())
        parentPath = _namespaceNameToDirName(parent);

    String extDir = _CreateNameSpaceDirectories(
        nameSpacePath, shareable, updatesAllowed, parentPath);

#ifdef PEGASUS_ENABLE_REMOTE_CMPI
    specialNameSpace pns;
    pns.setShared(!updatesAllowed, !shareable, parentSpace, parent, extDir);
#else
    specialNameSpace pns(
        !updatesAllowed, !shareable, parentSpace, parent, extDir);
#endif

    // Create NameSpace object and register it:

    AutoPtr<NameSpace> nameSpace;

    nameSpace.reset(new NameSpace(nameSpacePath, nameSpaceName, &pns));

    _rep->table.insert(nameSpaceName.getString(), nameSpace.release());

    PEG_METHOD_EXIT();
}

void NameSpaceManager::modifyNameSpace(
    const CIMNamespaceName& nameSpaceName,
    const NameSpaceAttributes& attributes)
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::modifyNameSpace()");

    NameSpace* nameSpace;

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

    Boolean shareable = false;
    Boolean updatesAllowed = true;

    for (NameSpaceAttributes::Iterator i = attributes.start(); i; i++)
    {
        String key = i.key();
        if (String::equalNoCase(key, "shareable"))
        {
            if (String::equalNoCase(i.value(), "true"))
                shareable = true;
        }
        else if (String::equalNoCase(key, "updatesAllowed"))
        {
            if (String::equalNoCase(i.value(),"false"))
                updatesAllowed = false;
        }
        else
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(CIM_ERR_NOT_SUPPORTED,
                nameSpaceName.getString() + " option not supported: " + key);
        }
    }

    if (!shareable && !nameSpace->final)
    {
        for (Table::Iterator i = _rep->table.start(); i; i++)
        {
             if (i.value()->parent==nameSpace)
             {
                 PEG_METHOD_EXIT();
                 throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                     "namespace " + nameSpaceName.getString() +
                         " has dependent namespace " +
                         i.value()->_nameSpaceName.getString());
             }
        }
    }

    String nameSpaceDirName = _namespaceNameToDirName(nameSpaceName);
    String nameSpacePath = _repositoryRoot + "/" + nameSpaceDirName;

    nameSpace->modify(shareable,updatesAllowed,nameSpacePath);

    PEG_METHOD_EXIT();
}


void NameSpaceManager::deleteNameSpace(const CIMNamespaceName& nameSpaceName)
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::deleteNameSpace()");

    // If no such namespace:

    NameSpace* nameSpace = 0;

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

    for (Table::Iterator i = _rep->table.start(); i; i++)
        if (i.value()->parent==nameSpace)
        {
            PEG_METHOD_EXIT();
            throw PEGASUS_CIM_EXCEPTION(CIM_ERR_FAILED,
                "namespace " + nameSpaceName.getString() +
                    " has dependent namespace " +
                    i.value()->_nameSpaceName.getString());
        }

    // Form namespace path:

    String nameSpaceDirName = _namespaceNameToDirName(
        nameSpace->getNameSpaceName());
    String nameSpacePath = _repositoryRoot + "/" + nameSpaceDirName;

    // Delete the entire namespace directory hierarchy:

    if (!_NameSpaceDirHierIsEmpty(nameSpacePath))
    {
        PEG_METHOD_EXIT();
        throw NonEmptyNameSpace(nameSpaceName.getString());
    }

    if (!FileSystem::removeDirectoryHier(nameSpacePath))
    {
        PEG_METHOD_EXIT();
        throw CannotRemoveDirectory(nameSpacePath);
    }

    // Remove and delete the namespace object:

    NameSpace **pd = NULL, *p, *d;
    for (p=nameSpace->parent; p; p=p->parent)
    {
        for (d = p->dependent, pd = &(p->dependent); d;
             pd = &(d->nextDependent), d = d->nextDependent)
        {
            if (d == nameSpace)
            {
                *pd = nameSpace->nextDependent;
                break;
            }
        }
    }

    Boolean success = _rep->table.remove(nameSpaceName.getString());
    PEGASUS_ASSERT(success);
    delete nameSpace;

    PEG_METHOD_EXIT();
}

Boolean NameSpaceManager::isRemoteNameSpace(
    const CIMNamespaceName& nameSpaceName,
    String& remoteInfo)
{
    NameSpace* nameSpace = 0;
    if (!_rep->table.lookup(nameSpaceName.getString(), nameSpace))
        return false;

    if (nameSpace->remoteDirName.size() == 0)
        return false;

    remoteInfo=nameSpace->remoteDirName;
    return true;
}

void NameSpaceManager::getNameSpaceNames(
    Array<CIMNamespaceName>& nameSpaceNames) const
{
    nameSpaceNames.clear();

    for (Table::Iterator i = _rep->table.start(); i; i++)
        nameSpaceNames.append(i.key());
}

Boolean NameSpaceManager::getNameSpaceAttributes(
    const CIMNamespaceName& nameSpaceName,
    NameSpaceAttributes& attributes)
{
    String nsn = nameSpaceName.getString();
    NameSpace* ns = lookupNameSpace(nsn);

    if (ns)
    {
        if (ns->parent)
            attributes.insert("parent", ns->parent->_nameSpaceName.getString());
        attributes.insert("name", nsn);
        if (ns->ro)
            attributes.insert("updatesAllowed", "false");
        else
            attributes.insert("updatesAllowed", "true");
        if (ns->final)
            attributes.insert("shareable", "false");
        else
            attributes.insert("shareable", "true");
        return true;
    }
    return false;
}

String NameSpaceManager::getClassFilePath(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& className,
    NameSpaceIntendedOp op) const
{
    NameSpace* nameSpace = 0;

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

    return getClassFilePath(nameSpace,className,op);
}

String NameSpaceManager::getClassFilePath(
    NameSpace* nameSpace,
    const CIMName& className,
    NameSpaceIntendedOp op) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY, "NameSpaceManager::getClassFilePath()");

    if (nameSpace->parent == NULL)
    {
        if (nameSpace->ro)
            switch (op)
            {
            case NameSpaceRead:
                break;
            case NameSpaceDelete:
            case NameSpaceWrite:
                PEG_METHOD_EXIT();
                throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
                    "R/O Namespace " +
                        nameSpace->getNameSpaceName().getString());
            }
        else
            switch (op)
            {
            case NameSpaceRead:
               break;
            case NameSpaceWrite:
               classExists(nameSpace,className,true);
               break;
            case NameSpaceDelete:
               classHasInstances(nameSpace,className,true);
            }
        PEG_METHOD_EXIT();
        return nameSpace->getClassFilePath(className);
    }

    if (nameSpace->ro == false)
    {
        switch (op)
        {
        case NameSpaceRead:
            if (classExists(nameSpace, className, false))
                break;
            PEG_METHOD_EXIT();
            return nameSpace->parent->getClassFilePath(className);
        case NameSpaceWrite:
            classExists(nameSpace->parent, className, true);
            break;
        case NameSpaceDelete:
            classHasInstances(nameSpace, className, true);
        }
        PEG_METHOD_EXIT();
        return nameSpace->getClassFilePath(className);
    }

    switch (op)
    {
    case NameSpaceRead:
        if (classExists(nameSpace, className, false))
            break;
        return nameSpace->parent->getClassFilePath(className);
    case NameSpaceDelete:
        classExists(nameSpace->parent, className, true);
    case NameSpaceWrite:
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
            "R/O Namespace " + nameSpace->getNameSpaceName().getString());
    }
    PEG_METHOD_EXIT();
    return nameSpace->getClassFilePath(className);
}

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

    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->getInstanceDataFileBase(className);
}

String NameSpaceManager::getInstanceDataFileBase(
    const NameSpace* nameSpace,
    const CIMName& className) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY,
        "NameSpaceManager::getInstanceDataFileBase()");

    PEG_METHOD_EXIT();
    return nameSpace->getInstanceDataFileBase(className);
}

String NameSpaceManager::getQualifierFilePath(
    const CIMNamespaceName& nameSpaceName,
    const CIMName& qualifierName,
    NameSpaceIntendedOp op) const
{
    PEG_METHOD_ENTER(TRC_REPOSITORY,
        "NameSpaceManager::getQualifierFilePath()");

    NameSpace* nameSpace = 0;

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

    String filePath = nameSpace->getQualifierFilePath(qualifierName);

    if (nameSpace->parent == NULL)
    {
        if (nameSpace->ro)
            switch (op)
            {
            case NameSpaceRead:
                break;
            case NameSpaceDelete:
            case NameSpaceWrite:
                PEG_METHOD_EXIT();
                throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
                    "R/O Namespace " +
                        nameSpace->getNameSpaceName().getString());
        }
        PEG_METHOD_EXIT();
        return filePath;
    }

    if (nameSpace->ro == false)
    {
        switch (op)
        {
        case NameSpaceRead:
            if (FileSystem::existsNoCase(filePath))
                break;
            PEG_METHOD_EXIT();
            return nameSpace->parent->getQualifierFilePath(qualifierName);
        case NameSpaceWrite:
        case NameSpaceDelete:
            break;
        }
        PEG_METHOD_EXIT();
        return filePath;
    }

    switch (op)
    {
    case NameSpaceRead:
        if (FileSystem::existsNoCase(filePath))
            break;
        PEG_METHOD_EXIT();
        return nameSpace->parent->getQualifierFilePath(qualifierName);
    case NameSpaceDelete:
    case NameSpaceWrite:
        PEG_METHOD_EXIT();
        throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED,
            "R/O Namespace " + nameSpace->getNameSpaceName().getString());
    }
    PEG_METHOD_EXIT();
    return filePath;
}

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

    // -- Lookup NameSpace object:

    NameSpace* nameSpace = 0, *ns = 0;

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

    // -- Get path to class file:

    String classFilePath =
        getClassFilePath(nameSpace, className, NameSpaceDelete);

    // -- Remove the file from the inheritance tree:

    if (nameSpace->parent != NULL)
        nameSpace->getInheritanceTree().remove(
            className, nameSpace->parent->getInheritanceTree(), nameSpace);
    else
        nameSpace->getInheritanceTree().remove(
            className, nameSpace->getInheritanceTree(), NULL);

    // -- Remove the file from disk:

    if (!FileSystem::removeFileNoCase(classFilePath))
    {
        PEG_METHOD_EXIT();
        throw CannotRemoveFile(classFilePath);
    }

    Boolean first = true;
    do
    {
        String indexFilePath =
            getInstanceDataFileBase(nameSpace, className) + ".idx";
        PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
            "instance indexFilePath = " + indexFilePath);

        String dataFilePath =
            getInstanceDataFileBase(nameSpace, className) + ".instances";
        PEG_TRACE_STRING(TRC_REPOSITORY, Tracer::LEVEL4,
            "instance dataFilePath = " + dataFilePath);

        FileSystem::removeFileNoCase(indexFilePath);
        FileSystem::removeFileNoCase(dataFilePath);

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

    PEG_METHOD_EXIT();
}

void NameSpaceManager::print(PEGASUS_STD(ostream)& os) const
{
    for (Table::Iterator i = _rep->table.start(); i; i++)
    {
        NameSpace* nameSpace = i.value();