From f540560feb093143569f8a85eb5280d9c7504a0e Mon Sep 17 00:00:00 2001 From: Matthias Schiffer Date: Mon, 7 Sep 2009 21:30:45 +0200 Subject: =?UTF-8?q?StorageManager=20&=20StorageBackendFile=20hinzugef?= =?UTF-8?q?=C3=BCgt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Common/Application.cpp | 12 ++- src/Common/Application.h | 6 ++ src/Common/CMakeLists.txt | 2 + src/Common/StorageBackend.h | 47 +++++++++++ src/Common/StorageManager.cpp | 56 +++++++++++++ src/Common/StorageManager.h | 61 ++++++++++++++ src/Common/XmlData.cpp | 23 +++++ src/Common/XmlData.h | 4 + src/mad-server.conf | 6 ++ src/modules/CMakeLists.txt | 1 + src/modules/StorageBackendFile/CMakeLists.txt | 7 ++ src/modules/StorageBackendFile/Module.cpp | 30 +++++++ src/modules/StorageBackendFile/Module.h | 52 ++++++++++++ .../StorageBackendFile/StorageBackendFile.cpp | 98 ++++++++++++++++++++++ .../StorageBackendFile/StorageBackendFile.h | 70 ++++++++++++++++ 15 files changed, 473 insertions(+), 2 deletions(-) create mode 100644 src/Common/StorageBackend.h create mode 100644 src/Common/StorageManager.cpp create mode 100644 src/Common/StorageManager.h create mode 100644 src/modules/StorageBackendFile/CMakeLists.txt create mode 100644 src/modules/StorageBackendFile/Module.cpp create mode 100644 src/modules/StorageBackendFile/Module.h create mode 100644 src/modules/StorageBackendFile/StorageBackendFile.cpp create mode 100644 src/modules/StorageBackendFile/StorageBackendFile.h diff --git a/src/Common/Application.cpp b/src/Common/Application.cpp index fdbcbeb..428d9e8 100644 --- a/src/Common/Application.cpp +++ b/src/Common/Application.cpp @@ -22,6 +22,7 @@ #include "ModuleManager.h" #include "RequestManager.h" #include "SystemManager.h" +#include "StorageManager.h" #include "UserManager.h" #include @@ -29,14 +30,21 @@ namespace Mad { namespace Common { -Application::Application(bool server) : authManager(new AuthManager), moduleManager(new ModuleManager(this)), requestManager(new RequestManager(this, server)), -systemManager(new SystemManager), userManager(new UserManager(this)) { +Application::Application(bool server) { xmlInitParser(); + + authManager = new AuthManager; + moduleManager = new ModuleManager(this); + requestManager = new RequestManager(this, server); + storageManager = new StorageManager(this); + systemManager = new SystemManager; + userManager = new UserManager(this); } Application::~Application() { delete userManager; delete systemManager; + delete storageManager; delete requestManager; delete moduleManager; delete authManager; diff --git a/src/Common/Application.h b/src/Common/Application.h index 39cf2de..a8edd1b 100644 --- a/src/Common/Application.h +++ b/src/Common/Application.h @@ -30,6 +30,7 @@ namespace Common { class AuthManager; class ModuleManager; class RequestManager; +class StorageManager; class SystemManager; class UserManager; @@ -38,6 +39,7 @@ class MAD_COMMON_EXPORT Application : public Core::Application { AuthManager *authManager; ModuleManager *moduleManager; RequestManager *requestManager; + StorageManager *storageManager; SystemManager *systemManager; UserManager *userManager; @@ -58,6 +60,10 @@ class MAD_COMMON_EXPORT Application : public Core::Application { return requestManager; } + StorageManager* getStorageManager() const { + return storageManager; + } + SystemManager* getSystemManager() const { return systemManager; } diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt index 493081d..dd12a36 100644 --- a/src/Common/CMakeLists.txt +++ b/src/Common/CMakeLists.txt @@ -35,6 +35,8 @@ mad_library(Common RequestHandler.cpp RequestHandler.h RequestHandlerGroup.h RequestManager.cpp RequestManager.h + StorageBackend.h + StorageManager.cpp StorageManager.h SystemBackend.h SystemManager.cpp SystemManager.h UserConfigBackend.h diff --git a/src/Common/StorageBackend.h b/src/Common/StorageBackend.h new file mode 100644 index 0000000..027109e --- /dev/null +++ b/src/Common/StorageBackend.h @@ -0,0 +1,47 @@ +/* + * StorageBackend.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#ifndef MAD_COMMON_STORAGEBACKEND_H_ +#define MAD_COMMON_STORAGEBACKEND_H_ + +#include "XmlData.h" +#include + +#include + +namespace Mad { +namespace Common { + +class StorageManager; + +class StorageBackend { + protected: + friend class StorageManager; + + virtual void store(const std::string &type, const std::string &name, const XmlData *data) throw (Core::Exception) = 0; + virtual boost::shared_ptr load(const std::string &type, const std::string &name) throw (Core::Exception) = 0; + + public: + virtual ~StorageBackend() {} +}; + +} +} + +#endif /* MAD_COMMON_STORAGEBACKEND_H_ */ diff --git a/src/Common/StorageManager.cpp b/src/Common/StorageManager.cpp new file mode 100644 index 0000000..a1610fe --- /dev/null +++ b/src/Common/StorageManager.cpp @@ -0,0 +1,56 @@ +/* + * StorageManager.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#include "StorageManager.h" +#include "StorageBackend.h" + +#include + +namespace Mad { +namespace Common { + +void StorageManager::setBackend(boost::shared_ptr newBackend) { + boost::lock_guard lock(mutex); + backend = newBackend; +} + +void StorageManager::unsetBackend(boost::shared_ptr oldBackend) { + boost::lock_guard lock(mutex); + if(backend == oldBackend) + backend.reset(); +} + +void StorageManager::store(const std::string &type, const std::string &name, const XmlData *data) throw (Core::Exception) { + boost::shared_lock lock(mutex); + if(!backend) + throw Core::Exception(Core::Exception::NOT_IMPLEMENTED); + + backend->store(type, name, data); +} + +boost::shared_ptr StorageManager::load(const std::string &type, const std::string &name) throw (Core::Exception) { + boost::shared_lock lock(mutex); + if(!backend) + throw Core::Exception(Core::Exception::NOT_IMPLEMENTED); + + return backend->load(type, name); +} + +} +} diff --git a/src/Common/StorageManager.h b/src/Common/StorageManager.h new file mode 100644 index 0000000..c81c707 --- /dev/null +++ b/src/Common/StorageManager.h @@ -0,0 +1,61 @@ +/* + * StorageManager.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#ifndef MAD_COMMON_DATAMANAGER_H_ +#define MAD_COMMON_DATAMANAGER_H_ + +#include "export.h" + +#include "XmlData.h" + +#include + +#include +#include + +namespace Mad { +namespace Common { + +class Application; +class StorageBackend; + +class MAD_COMMON_EXPORT StorageManager { + private: + friend class Application; + + Application *application; + + boost::shared_ptr backend; + + boost::shared_mutex mutex; + + StorageManager(Application *application0) : application(application0) {} + + public: + void setBackend(boost::shared_ptr newBackend); + void unsetBackend(boost::shared_ptr oldBackend); + + void store(const std::string &type, const std::string &name, const XmlData *data) throw (Core::Exception); + boost::shared_ptr load(const std::string &type, const std::string &name) throw (Core::Exception); +}; + +} +} + +#endif /* MAD_COMMON_DATAMANAGER_H_ */ diff --git a/src/Common/XmlData.cpp b/src/Common/XmlData.cpp index 4d1da6e..aa3fcdf 100644 --- a/src/Common/XmlData.cpp +++ b/src/Common/XmlData.cpp @@ -19,6 +19,9 @@ #include "XmlData.h" #include "Base64Encoder.h" + +#include +#include #include #include @@ -267,6 +270,15 @@ XmlData::XmlData(const Net::Packet &packet) { entry = new Entry(rootNode); } +XmlData::XmlData(const std::string &filename) throw (Core::Exception) { + doc = xmlParseFile(filename.c_str()); + if(!doc) + throw Core::Exception(Core::Exception::NOT_AVAILABLE); + + rootNode = xmlDocGetRootElement(doc); + entry = new Entry(rootNode); +} + XmlData& XmlData::operator=(const XmlData &o) { delete entry; xmlFreeDoc(doc); @@ -305,5 +317,16 @@ Net::Packet XmlData::toPacket(boost::uint16_t requestId) const { return packet; } +void XmlData::toFile(const std::string &filename) const throw (Core::Exception) { + std::FILE *file = std::fopen(filename.c_str(), "w"); + if(!file) + throw Core::Exception(Core::Exception::INTERNAL_ERRNO, errno); + + if(!xmlDocDump(file, doc)) + throw Core::Exception(Core::Exception::NOT_AVAILABLE); + + std::fclose(file); +} + } } diff --git a/src/Common/XmlData.h b/src/Common/XmlData.h index 6be2b1d..51e5327 100644 --- a/src/Common/XmlData.h +++ b/src/Common/XmlData.h @@ -23,6 +23,7 @@ #include "export.h" #include +#include #include #include @@ -438,6 +439,7 @@ class MAD_COMMON_EXPORT XmlData { XmlData(); XmlData(const XmlData &o); XmlData(const Net::Packet &packet); + XmlData(const std::string &filename) throw (Core::Exception); XmlData& operator=(const XmlData &o); @@ -477,6 +479,8 @@ class MAD_COMMON_EXPORT XmlData { } Net::Packet toPacket(boost::uint16_t requestId) const; + + void toFile(const std::string &filename) const throw (Core::Exception); }; template <> MAD_COMMON_EXPORT std::string XmlData::Entry::get(const std::string &name) const; diff --git a/src/mad-server.conf b/src/mad-server.conf index 9fa8f29..1fb02e2 100644 --- a/src/mad-server.conf +++ b/src/mad-server.conf @@ -4,6 +4,8 @@ LoadModule "AuthBackendChallengeResponse" LoadModule "AuthBackendPassword" LoadModule "AuthProviderFile" +LoadModule "StorageBackendFile" + LoadModule "SystemBackendPosix" LoadModule "SystemBackendProc" @@ -31,6 +33,10 @@ AuthProviderFile { File "users" } +Storage { + Root "/tmp/storage" +} + UserManager { MinUid 1000 MaxUid 29999 diff --git a/src/modules/CMakeLists.txt b/src/modules/CMakeLists.txt index b09fff3..2f497de 100644 --- a/src/modules/CMakeLists.txt +++ b/src/modules/CMakeLists.txt @@ -37,6 +37,7 @@ add_subdirectory(AuthBackendChallengeResponse) add_subdirectory(AuthBackendPassword) add_subdirectory(AuthProviderFile) add_subdirectory(FileLogger) +add_subdirectory(StorageBackendFile) if(UNIX) add_subdirectory(SystemBackendPosix) diff --git a/src/modules/StorageBackendFile/CMakeLists.txt b/src/modules/StorageBackendFile/CMakeLists.txt new file mode 100644 index 0000000..f82ffd5 --- /dev/null +++ b/src/modules/StorageBackendFile/CMakeLists.txt @@ -0,0 +1,7 @@ +include_directories(${INCLUDES}) + +mad_module(StorageBackendFile + StorageBackendFile.cpp StorageBackendFile.h + Module.cpp Module.h +) +mad_module_libraries(StorageBackendFile) diff --git a/src/modules/StorageBackendFile/Module.cpp b/src/modules/StorageBackendFile/Module.cpp new file mode 100644 index 0000000..2200f49 --- /dev/null +++ b/src/modules/StorageBackendFile/Module.cpp @@ -0,0 +1,30 @@ +/* + * Module.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#include "../export.h" + +#include "Module.h" + +extern "C" { + +MAD_MODULE_EXPORT Mad::Common::Module* StorageBackendFile_create(Mad::Common::Application *application) { + return new Mad::Modules::StorageBackendFile::Module(application); +} + +} diff --git a/src/modules/StorageBackendFile/Module.h b/src/modules/StorageBackendFile/Module.h new file mode 100644 index 0000000..8b5cac1 --- /dev/null +++ b/src/modules/StorageBackendFile/Module.h @@ -0,0 +1,52 @@ +/* + * Module.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#ifndef MAD_MODULES_STORAGEBACKENDFILE_MODULE_H_ +#define MAD_MODULES_STORAGEBACKENDFILE_MODULE_H_ + +#include "StorageBackendFile.h" + +#include +#include + +namespace Mad { +namespace Modules { +namespace StorageBackendFile { + +class Module : public Common::Module { + private: + Common::Application *application; + + boost::shared_ptr backend; + + public: + Module(Common::Application *application0) : application(application0), backend(new StorageBackendFile(application)) { + application->getStorageManager()->setBackend(backend); + } + + virtual ~Module() { + application->getStorageManager()->unsetBackend(backend); + } +}; + +} +} +} + +#endif /* MAD_MODULES_AUTHPROVIDERFILE_MODULE_H_ */ diff --git a/src/modules/StorageBackendFile/StorageBackendFile.cpp b/src/modules/StorageBackendFile/StorageBackendFile.cpp new file mode 100644 index 0000000..7f4b6b5 --- /dev/null +++ b/src/modules/StorageBackendFile/StorageBackendFile.cpp @@ -0,0 +1,98 @@ +/* + * StorageBackendFile.cpp + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#include "StorageBackendFile.h" + +#include + +#include +#include + +namespace Mad { +namespace Modules { +namespace StorageBackendFile { + +bool StorageBackendFile::handleConfigEntry(const Core::ConfigEntry &entry, bool /*handled*/) { + if(!entry[0].getKey().matches("Storage")) + return false; + + boost::lock_guard lock(mutex); + + if(entry[1].getKey().matches("Root")) { + if(!entry[2].empty()) + return false; + + storageRoot = entry[1][0]; + } + else if(!entry[1].empty()) { + return false; + } + + return true; +} + +void StorageBackendFile::configFinished() { + boost::lock_guard lock(mutex); + + if(!boost::filesystem::exists(storageRoot)) { + boost::filesystem::create_directories(storageRoot); + } + + if(!boost::filesystem::is_directory(storageRoot)) { + application->logf("StorageBackendFile: Can't create directory: '%s'.", storageRoot.string().c_str()); + return; + } + + configured = true; +} + +boost::filesystem::path StorageBackendFile::getFileName(const std::string &type, const std::string &name) { + boost::filesystem::path path(storageRoot); + + path /= type; + path /= (name + ".xml"); + + return path; +} + +void StorageBackendFile::store(const std::string &type, const std::string &name, const Common::XmlData *data) throw (Core::Exception) { + boost::lock_guard lock(mutex); + + if(!configured) + throw Core::Exception(Core::Exception::NOT_AVAILABLE); + + boost::filesystem::path path = getFileName(type, name); + boost::filesystem::create_directories(path.parent_path().directory_string()); + + data->toFile(path.file_string()); +} + +boost::shared_ptr StorageBackendFile::load(const std::string &type, const std::string &name) throw (Core::Exception) { + boost::shared_lock lock(mutex); + + if(!configured) + throw Core::Exception(Core::Exception::NOT_AVAILABLE); + + boost::filesystem::path path = getFileName(type, name); + return boost::shared_ptr(new Common::XmlData(path.file_string())); +} + +} +} +} diff --git a/src/modules/StorageBackendFile/StorageBackendFile.h b/src/modules/StorageBackendFile/StorageBackendFile.h new file mode 100644 index 0000000..7246b2e --- /dev/null +++ b/src/modules/StorageBackendFile/StorageBackendFile.h @@ -0,0 +1,70 @@ +/* + * StorageBackendFile.h + * + * Copyright (C) 2009 Matthias Schiffer + * + * This program is free software: you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License along + * with this program. If not, see . + */ + +#ifndef MAD_MODULES_STORAGEBACKENDFILE_STORAGEBACKENDFILE_H_ +#define MAD_MODULES_STORAGEBACKENDFILE_STORAGEBACKENDFILE_H_ + +#include +#include + +#include +#include + +#include +#include + +namespace Mad { +namespace Modules { +namespace StorageBackendFile { + +class StorageBackendFile : public Common::StorageBackend, private Core::Configurable, private boost::noncopyable { + private: + Common::Application *application; + + boost::filesystem::path storageRoot; + bool configured; + + boost::shared_mutex mutex; + + boost::filesystem::path getFileName(const std::string &type, const std::string &name); + + protected: + virtual bool handleConfigEntry(const Core::ConfigEntry &entry, bool handled); + virtual void configFinished(); + + virtual void store(const std::string &type, const std::string &name, const Common::XmlData *data) throw (Core::Exception); + virtual boost::shared_ptr load(const std::string &type, const std::string &name) throw (Core::Exception); + + public: + StorageBackendFile(Common::Application *application0) : application(application0), configured(false) { + application->getConfigManager()->registerConfigurable(this); + } + + virtual ~StorageBackendFile() { + application->getConfigManager()->unregisterConfigurable(this); + } + + +}; + +} +} +} + +#endif /* MAD_MODULES_STORAGEBACKENDFILE_STORAGEBACKENDFILE_H_ */ -- cgit v1.2.3