Copying the files from the mapper to the config
It was needed as in the next commit we would be
generating the ldap priv mapping object under the
ldap config object.
This is to align with the redfish.
https://redfish.dmtf.org/schemas/AccountService.v1_4_0.json
As per redfish, Each config will have it's own
"RemoteRoleMapping".
TestedBy: Unit-tested
All existing test cases gets passed.
Signed-off-by: Ratan Gupta <ratagupt@linux.vnet.ibm.com>
Change-Id: Ibec2c0b809ce15e71bd3ed84a2d0efdad24f1d17
diff --git a/phosphor-ldap-config/ldap_mapper_entry.cpp b/phosphor-ldap-config/ldap_mapper_entry.cpp
new file mode 100644
index 0000000..8410942
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_entry.cpp
@@ -0,0 +1,76 @@
+#include <experimental/filesystem>
+#include <xyz/openbmc_project/Common/error.hpp>
+#include <xyz/openbmc_project/User/Common/error.hpp>
+#include <phosphor-logging/log.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <phosphor-logging/elog-errors.hpp>
+#include "config.h"
+#include "ldap_mapper_entry.hpp"
+#include "ldap_mapper_mgr.hpp"
+#include "ldap_mapper_serialize.hpp"
+
+namespace phosphor
+{
+namespace user
+{
+
+using namespace phosphor::logging;
+using InvalidArgument =
+ sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument;
+using Argument = xyz::openbmc_project::Common::InvalidArgument;
+
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+ const char *filePath,
+ const std::string &groupName,
+ const std::string &privilege,
+ LDAPMapperMgr &parent) :
+ Ifaces(bus, path, true),
+ id(std::stol(std::experimental::filesystem::path(path).filename())),
+ manager(parent), persistPath(filePath)
+{
+ Ifaces::privilege(privilege, true);
+ Ifaces::groupName(groupName, true);
+ Ifaces::emit_object_added();
+}
+
+LDAPMapperEntry::LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+ const char *filePath, LDAPMapperMgr &parent) :
+ Ifaces(bus, path, true),
+ id(std::stol(std::experimental::filesystem::path(path).filename())),
+ manager(parent), persistPath(filePath)
+{
+}
+
+void LDAPMapperEntry::delete_(void)
+{
+ manager.deletePrivilegeMapper(id);
+}
+
+std::string LDAPMapperEntry::groupName(std::string value)
+{
+ if (value == Ifaces::groupName())
+ {
+ return value;
+ }
+
+ manager.checkPrivilegeMapper(value);
+ auto val = Ifaces::groupName(value);
+ serialize(*this, id, persistPath);
+ return val;
+}
+
+std::string LDAPMapperEntry::privilege(std::string value)
+{
+ if (value == Ifaces::privilege())
+ {
+ return value;
+ }
+
+ manager.checkPrivilegeLevel(value);
+ auto val = Ifaces::privilege(value);
+ serialize(*this, id, persistPath);
+ return val;
+}
+
+} // namespace user
+} // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_mapper_entry.hpp b/phosphor-ldap-config/ldap_mapper_entry.hpp
new file mode 100644
index 0000000..dea85c2
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_entry.hpp
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server/object.hpp>
+#include <xyz/openbmc_project/User/PrivilegeMapperEntry/server.hpp>
+#include <xyz/openbmc_project/Object/Delete/server.hpp>
+
+namespace phosphor
+{
+namespace user
+{
+
+namespace Base = sdbusplus::xyz::openbmc_project;
+using Entry =
+ sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry;
+using Delete = sdbusplus::xyz::openbmc_project::Object::server::Delete;
+using Ifaces = sdbusplus::server::object::object<Entry, Delete>;
+
+// Forward declaration for LDAPMapperMgr
+class LDAPMapperMgr;
+
+using Id = size_t;
+
+/** @class LDAPMapperEntry
+ *
+ * @brief This D-Bus object represents the privilege level for the LDAP group.
+ */
+class LDAPMapperEntry : public Ifaces
+{
+ public:
+ LDAPMapperEntry() = delete;
+ ~LDAPMapperEntry() = default;
+ LDAPMapperEntry(const LDAPMapperEntry &) = delete;
+ LDAPMapperEntry &operator=(const LDAPMapperEntry &) = delete;
+ LDAPMapperEntry(LDAPMapperEntry &&) = default;
+ LDAPMapperEntry &operator=(LDAPMapperEntry &&) = default;
+
+ /** @brief Constructs LDAP privilege mapper entry object.
+ *
+ * @param[in] bus - sdbusplus handler
+ * @param[in] path - D-Bus path
+ * @param[in] filePath - serialization directory path
+ * @param[in] groupName - LDAP group name
+ * @param[in] privilege - the privilege for the group
+ * @param[in] parent - LDAP privilege mapper manager
+ */
+ LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+ const char *filePath, const std::string &groupName,
+ const std::string &privilege, LDAPMapperMgr &parent);
+
+ /** @brief Constructs LDAP privilege mapper entry object
+ *
+ * @param[in] bus - sdbusplus handler
+ * @param[in] path - D-Bus path
+ * @param[in] filePath - serialization directory path
+ * @param[in] parent - LDAP privilege mapper manager
+ */
+ LDAPMapperEntry(sdbusplus::bus::bus &bus, const char *path,
+ const char *filePath, LDAPMapperMgr &parent);
+
+ /** @brief Delete privilege mapper entry object
+ *
+ * This method deletes the privilege mapper entry.
+ */
+ void delete_(void) override;
+
+ /** @brief Update the group name of the mapper object
+ *
+ * @param[in] value - group name
+ *
+ * @return On success the updated group name
+ */
+ std::string groupName(std::string value) override;
+
+ /** @brief Update privilege associated with LDAP group
+ *
+ * @param[in] value - privilege level
+ *
+ * @return On success the updated privilege level
+ */
+ std::string privilege(std::string value) override;
+
+ using sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+ privilege;
+
+ using sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+ groupName;
+
+ private:
+ Id id;
+ LDAPMapperMgr &manager;
+
+ /** @brief serialization directory path */
+ std::string persistPath;
+};
+
+} // namespace user
+} // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_mapper_serialize.cpp b/phosphor-ldap-config/ldap_mapper_serialize.cpp
new file mode 100644
index 0000000..3ef809e
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_serialize.cpp
@@ -0,0 +1,94 @@
+#include <cereal/archives/binary.hpp>
+#include <cereal/types/string.hpp>
+#include <fstream>
+#include <phosphor-logging/log.hpp>
+#include "config.h"
+#include "ldap_mapper_serialize.hpp"
+
+// Register class version
+// From cereal documentation;
+// "This macro should be placed at global scope"
+CEREAL_CLASS_VERSION(phosphor::user::LDAPMapperEntry, CLASS_VERSION);
+
+namespace phosphor
+{
+namespace user
+{
+
+using namespace phosphor::logging;
+
+/** @brief Function required by Cereal to perform serialization.
+ *
+ * @tparam Archive - Cereal archive type (binary in this case).
+ * @param[in] archive - reference to cereal archive.
+ * @param[in] entry- const reference to LDAP mapper entry
+ * @param[in] version - Class version that enables handling a serialized data
+ * across code levels
+ */
+template <class Archive>
+void save(Archive& archive, const LDAPMapperEntry& entry,
+ const std::uint32_t version)
+{
+ archive(entry.groupName(), entry.privilege());
+}
+
+/** @brief Function required by Cereal to perform deserialization.
+ *
+ * @tparam Archive - Cereal archive type (binary in our case).
+ * @param[in] archive - reference to cereal archive.
+ * @param[out] entry - LDAP mapper entry to be read
+ * @param[in] version - Class version that enables handling a serialized data
+ * across code levels
+ */
+template <class Archive>
+void load(Archive& archive, LDAPMapperEntry& entry, const std::uint32_t version)
+{
+ std::string groupName{};
+ std::string privilege{};
+
+ archive(groupName, privilege);
+
+ entry.sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+ groupName(groupName, true);
+ entry.sdbusplus::xyz::openbmc_project::User::server::PrivilegeMapperEntry::
+ privilege(privilege, true);
+}
+
+fs::path serialize(const LDAPMapperEntry& entry, Id id, const fs::path& dir)
+{
+ auto path = dir / std::to_string(id);
+ std::ofstream os(path.c_str(), std::ios::binary);
+ cereal::BinaryOutputArchive oarchive(os);
+ oarchive(entry);
+ return path;
+}
+
+bool deserialize(const fs::path& path, LDAPMapperEntry& entry)
+{
+ try
+ {
+ if (fs::exists(path))
+ {
+ std::ifstream is(path.c_str(), std::ios::in | std::ios::binary);
+ cereal::BinaryInputArchive iarchive(is);
+ iarchive(entry);
+ return true;
+ }
+ return false;
+ }
+ catch (cereal::Exception& e)
+ {
+ log<level::ERR>(e.what());
+ fs::remove(path);
+ return false;
+ }
+ catch (const std::length_error& e)
+ {
+ log<level::ERR>(e.what());
+ fs::remove(path);
+ return false;
+ }
+}
+
+} // namespace user
+} // namespace phosphor
diff --git a/phosphor-ldap-config/ldap_mapper_serialize.hpp b/phosphor-ldap-config/ldap_mapper_serialize.hpp
new file mode 100644
index 0000000..5ab71c0
--- /dev/null
+++ b/phosphor-ldap-config/ldap_mapper_serialize.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <experimental/filesystem>
+#include "config.h"
+#include "ldap_mapper_entry.hpp"
+
+namespace phosphor
+{
+namespace user
+{
+
+namespace fs = std::experimental::filesystem;
+
+/** @brief Serialize and persist LDAP privilege mapper D-Bus object
+ *
+ * @param[in] entry - LDAP privilege mapper entry
+ * @param[in] id - filename of the persisted LDAP mapper entry
+ * @param[in] dir - pathname of directory where the serialized privilege
+ * mappings are stored.
+ *
+ * @return fs::path - pathname of persisted error file
+ */
+fs::path serialize(const LDAPMapperEntry& entry, Id id, const fs::path& dir);
+
+/** @brief Deserialize a persisted LDAP privilege mapper into a D-Bus object
+ *
+ * @param[in] path - pathname of persisted file
+ * @param[in/out] entry - reference to LDAP privilege mapper entry object
+ * which is the target of deserialization.
+ *
+ * @return bool - true if the deserialization was successful, false otherwise.
+ */
+bool deserialize(const fs::path& path, LDAPMapperEntry& entry);
+
+} // namespace user
+} // namespace phosphor