//--------------------------------------------------------------------------------------------------
void ni_SetNodeValueString
(
ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access.
const char* pathPtr, ///< [IN] Optional path to another node in the tree.
const char* valuePtr ///< [IN] Write this value into the tree.
)
//--------------------------------------------------------------------------------------------------
{
tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, pathPtr);
if (nodeRef)
{
tdb_SetValueAsString(nodeRef, valuePtr);
}
}
//--------------------------------------------------------------------------------------------------
void ni_SetNodeValueBool
(
ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access.
const char* pathPtr, ///< [IN] Optional path to another node in the tree.
bool value ///< [IN] The value to write.
)
//--------------------------------------------------------------------------------------------------
{
tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, pathPtr);
if (nodeRef)
{
tdb_SetValueAsBool(nodeRef, value);
}
}
//--------------------------------------------------------------------------------------------------
void ni_SetEmpty
(
ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access.
const char* newPathPtr ///< [IN] Optional, can be used to specify a node relative to the
///< [IN] current one.
)
//--------------------------------------------------------------------------------------------------
{
tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, newPathPtr);
if (nodeRef)
{
tdb_SetEmpty(nodeRef);
tdb_EnsureExists(nodeRef);
}
}
// -------------------------------------------------------------------------------------------------
void le_cfgAdmin_ImportTree
(
le_cfgAdmin_ServerCmdRef_t commandRef, ///< [IN] Reference used to generate a reply for this
///< request.
le_cfg_IteratorRef_t externalRef, ///< [IN] Write iterator that is being used for the
///< import.
const char* filePathPtr, ///< [IN] Import the tree data from the this file.
const char* nodePathPtr ///< [IN] Where in the tree should this import happen?
///< Leave as an empty string to use the iterator's
///< current node.
)
// -------------------------------------------------------------------------------------------------
{
LE_DEBUG("** Importing a tree from '%s' onto node '%s', using iterator, '%p'.",
filePathPtr, nodePathPtr, externalRef);
ni_IteratorRef_t iteratorRef = GetIteratorFromRef(externalRef);
if (iteratorRef == NULL)
{
le_cfgAdmin_ImportTreeRespond(commandRef, LE_OK);
return;
}
tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, nodePathPtr);
if (nodeRef == NULL)
{
le_cfgAdmin_ImportTreeRespond(commandRef, LE_NOT_FOUND);
}
else
{
// Open the requested file.
LE_DEBUG("Opening file '%s'.", filePathPtr);
FILE* filePtr = NULL;
filePtr = fopen(filePathPtr, "r");
if (!filePtr)
{
LE_ERROR("File '%s' could not be opened.", filePathPtr);
le_cfgAdmin_ImportTreeRespond(commandRef, LE_FAULT);
return;
}
// Now, attempt to import the requested data.
LE_DEBUG("Importing config data.");
le_result_t result;
if (tdb_ReadTreeNode(nodeRef, filePtr))
{
result = LE_OK;
}
else
{
result = LE_FORMAT_ERROR;
}
// Let the caller know we're done.
le_cfgAdmin_ImportTreeRespond(commandRef, result);
// Close up the file and we're done.
fclose(filePtr);
}
}
//--------------------------------------------------------------------------------------------------
le_result_t ni_SetNodeName
(
ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access.
const char* pathPtr, ///< [IN] Optional path to another node in the tree.
const char* namePtr ///< [IN] The new name to use.
)
//--------------------------------------------------------------------------------------------------
{
// Try to get or create the requested node. If the optional sub-path results in a new path that
// overflows, then the node get will fail.
tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, pathPtr);
le_result_t result = LE_OK;
if (nodeRef)
{
// Ok, the existing path is ok. Cache the existing node name, in case we have to revert it
// later, then set the new name. We may have to revert the name later, because, while the
// new name itself may be ok. The name may actually be too long for the path limit.
char oldName[LE_CFG_NAME_LEN_BYTES] = "";
LE_ASSERT(tdb_GetNodeName(nodeRef, oldName, sizeof(oldName)) == LE_OK);
result = tdb_SetNodeName(nodeRef, namePtr);
if (result == LE_OK)
{
// The new name passed validation, now we have to make sure that the full path to the
// node is still ok. So, first we have to check, was a relative path used.
if (strcmp(pathPtr, "") == 0)
{
// Looks like the caller was using the iterator's current node. So, remove the old
// name from the end of the iterator's current path, and append the new name. If
// this fails, it's because the new absolute path is too long, so name change fails,
// and we have to revert the changes.
LE_ASSERT(le_pathIter_Append(iteratorRef->pathIterRef, "..") == LE_OK);
result = le_pathIter_Append(iteratorRef->pathIterRef, namePtr);
if (result != LE_OK)
{
LE_ASSERT(le_pathIter_Append(iteratorRef->pathIterRef, oldName) == LE_OK);
}
}
else
{
// The user is accessing a node relative to the iterator's current node. So, we
// need too build up a new path and validate that the new name still fits within our
// limits. The new path ref is for validation only and can be safely discarded once
// the check is complete.
le_pathIter_Ref_t newPathRef = le_pathIter_Clone(iteratorRef->pathIterRef);
result = le_pathIter_Append(newPathRef, pathPtr);
if (result == LE_OK)
{
LE_ASSERT(le_pathIter_Append(newPathRef, "..") == LE_OK);
result = le_pathIter_Append(newPathRef, namePtr);
}
le_pathIter_Delete(newPathRef);
}
// If we got to this point and everything is ok, then we know that the name set was ok,
// and that the resultant path with the new name is also ok. So, make sure that this
// node exists in the next commit. Otherwise, revert the node to it's old name and
// report the error to the caller.
if (result == LE_OK)
{
tdb_EnsureExists(nodeRef);
}
else
{
LE_ASSERT(tdb_SetNodeName(nodeRef, oldName) == LE_OK);
}
}
}
return result;
}
