StorageManager & StorageBackendFile hinzugefügt

15 files changed, 473 insertions, 2 deletions

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 <libxml/parser.h>
@@ -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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_COMMON_STORAGEBACKEND_H_
+#define MAD_COMMON_STORAGEBACKEND_H_
+
+#include "XmlData.h"
+#include <Core/Exception.h>
+
+#include <boost/shared_ptr.hpp>
+
+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<XmlData> 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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "StorageManager.h"
+#include "StorageBackend.h"
+
+#include <boost/thread/locks.hpp>
+
+namespace Mad {
+namespace Common {
+
+void StorageManager::setBackend(boost::shared_ptr<StorageBackend> newBackend) {
+  boost::lock_guard<boost::shared_mutex> lock(mutex);
+  backend = newBackend;
+}
+
+void StorageManager::unsetBackend(boost::shared_ptr<StorageBackend> oldBackend) {
+  boost::lock_guard<boost::shared_mutex> 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<boost::shared_mutex> lock(mutex);
+  if(!backend)
+    throw Core::Exception(Core::Exception::NOT_IMPLEMENTED);
+
+  backend->store(type, name, data);
+}
+
+boost::shared_ptr<XmlData> StorageManager::load(const std::string &type, const std::string &name) throw (Core::Exception) {
+  boost::shared_lock<boost::shared_mutex> 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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_COMMON_DATAMANAGER_H_
+#define MAD_COMMON_DATAMANAGER_H_
+
+#include "export.h"
+
+#include "XmlData.h"
+
+#include <Core/Exception.h>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+namespace Mad {
+namespace Common {
+
+class Application;
+class StorageBackend;
+
+class MAD_COMMON_EXPORT StorageManager {
+  private:
+    friend class Application;
+
+    Application *application;
+
+    boost::shared_ptr<StorageBackend> backend;
+
+    boost::shared_mutex mutex;
+
+    StorageManager(Application *application0) : application(application0) {}
+
+  public:
+    void setBackend(boost::shared_ptr<StorageBackend> newBackend);
+    void unsetBackend(boost::shared_ptr<StorageBackend> oldBackend);
+
+    void store(const std::string &type, const std::string &name, const XmlData *data) throw (Core::Exception);
+    boost::shared_ptr<XmlData> 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 <cerrno>
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
 
@@ -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 <Net/Packet.h>
+#include <Core/Exception.h>
 
 #include <map>
 #include <string>
@@ -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<std::string>(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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_STORAGEBACKENDFILE_MODULE_H_
+#define MAD_MODULES_STORAGEBACKENDFILE_MODULE_H_
+
+#include "StorageBackendFile.h"
+
+#include <Common/Module.h>
+#include <Common/StorageManager.h>
+
+namespace Mad {
+namespace Modules {
+namespace StorageBackendFile {
+
+class Module : public Common::Module {
+  private:
+    Common::Application *application;
+
+    boost::shared_ptr<StorageBackendFile> 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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include "StorageBackendFile.h"
+
+#include <Core/ConfigEntry.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/thread/locks.hpp>
+
+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<boost::shared_mutex> 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<boost::shared_mutex> 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<boost::shared_mutex> 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<Common::XmlData> StorageBackendFile::load(const std::string &type, const std::string &name) throw (Core::Exception) {
+  boost::shared_lock<boost::shared_mutex> lock(mutex);
+
+  if(!configured)
+    throw Core::Exception(Core::Exception::NOT_AVAILABLE);
+
+  boost::filesystem::path path = getFileName(type, name);
+  return boost::shared_ptr<Common::XmlData>(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 <matthias@gamezock.de>
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_STORAGEBACKENDFILE_STORAGEBACKENDFILE_H_
+#define MAD_MODULES_STORAGEBACKENDFILE_STORAGEBACKENDFILE_H_
+
+#include <Common/StorageBackend.h>
+#include <Common/Application.h>
+
+#include <Core/Configurable.h>
+#include <Core/ConfigManager.h>
+
+#include <boost/filesystem/path.hpp>
+#include <boost/thread/shared_mutex.hpp>
+
+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<Common::XmlData> 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_ */