From 1fbc16e09809c424c840c2632ccce904245bdf63 Mon Sep 17 00:00:00 2001 From: wrongway88 Date: Tue, 21 Feb 2017 17:12:35 +0100 Subject: [PATCH] logic: interprocess utility Added basic interprocess utility --- bin/test/data/log/test_log.txt | 1 + src/lib/CMakeLists.txt | 15 ++ src/lib/utility/UUIDUtility.cpp | 20 ++ src/lib/utility/UUIDUtility.h | 17 ++ .../interprocess/InterprocessDataManager.cpp | 110 +++++++++++ .../interprocess/InterprocessDataManager.h | 33 ++++ .../InterprocessProcessManager.cpp | 65 +++++++ .../interprocess/InterprocessProcessManager.h | 27 +++ .../interprocess/InterprocessUtility.h | 15 ++ .../utility/interprocess/SharedContainer.h | 95 ++++++++++ src/lib/utility/interprocess/SharedMap.h | 125 +++++++++++++ .../interprocess/SharedParserArguments.cpp | 173 ++++++++++++++++++ .../interprocess/SharedParserArguments.h | 67 +++++++ src/lib/utility/interprocess/SharedQueue.h | 128 +++++++++++++ .../interprocess/SharedUUIDManager.cpp | 128 +++++++++++++ .../utility/interprocess/SharedUUIDManager.h | 47 +++++ 16 files changed, 1066 insertions(+) create mode 100644 src/lib/utility/UUIDUtility.cpp create mode 100644 src/lib/utility/UUIDUtility.h create mode 100644 src/lib/utility/interprocess/InterprocessDataManager.cpp create mode 100644 src/lib/utility/interprocess/InterprocessDataManager.h create mode 100644 src/lib/utility/interprocess/InterprocessProcessManager.cpp create mode 100644 src/lib/utility/interprocess/InterprocessProcessManager.h create mode 100644 src/lib/utility/interprocess/InterprocessUtility.h create mode 100644 src/lib/utility/interprocess/SharedContainer.h create mode 100644 src/lib/utility/interprocess/SharedMap.h create mode 100644 src/lib/utility/interprocess/SharedParserArguments.cpp create mode 100644 src/lib/utility/interprocess/SharedParserArguments.h create mode 100644 src/lib/utility/interprocess/SharedQueue.h create mode 100644 src/lib/utility/interprocess/SharedUUIDManager.cpp create mode 100644 src/lib/utility/interprocess/SharedUUIDManager.h diff --git a/bin/test/data/log/test_log.txt b/bin/test/data/log/test_log.txt index e1103410..079df710 100644 --- a/bin/test/data/log/test_log.txt +++ b/bin/test/data/log/test_log.txt @@ -1,3 +1,4 @@ +Settings.cpp WARNING: File for Settings not found: data/TestSettings.xml Token.cpp ERROR: Location Id was not referenced by this Token. Node.cpp WARNING: Cannot change NodeType after it was already set from namespace to class Edge.cpp ERROR: Nodes are not plain copies. diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index e7bc0c67..c9412ebb 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -239,6 +239,19 @@ add_files( utility/file/FileSystem.cpp utility/file/FileSystem.h + utility/interprocess/InterprocessDataManager.cpp + utility/interprocess/InterprocessDataManager.h + utility/interprocess/InterprocessProcessManager.cpp + utility/interprocess/InterprocessProcessManager.h + utility/interprocess/InterprocessUtility.h + utility/interprocess/SharedContainer.h + utility/interprocess/SharedMap.h + utility/interprocess/SharedParserArguments.cpp + utility/interprocess/SharedParserArguments.h + utility/interprocess/SharedQueue.h + utility/interprocess/SharedUUIDMANAGER.cpp + utility/interprocess/SharedUUIDMANAGER.h + utility/logging/ConsoleLogger.cpp utility/logging/ConsoleLogger.h utility/logging/FileLogger.cpp @@ -410,6 +423,8 @@ add_files( utility/utilityLibrary.h utility/utilityString.cpp utility/utilityString.h + utility/UUIDUtility.cpp + utility/UUIDUtility.h utility/Version.cpp utility/Version.h diff --git a/src/lib/utility/UUIDUtility.cpp b/src/lib/utility/UUIDUtility.cpp new file mode 100644 index 00000000..2349e4e4 --- /dev/null +++ b/src/lib/utility/UUIDUtility.cpp @@ -0,0 +1,20 @@ +#include "UUIDUtility.h" + +#include +#include +#include + +UUID UUIDUtility::getUUID() +{ + return boost::uuids::random_generator()(); +} + +std::string UUIDUtility::UUIDtoString(const UUID& uuid) +{ + return boost::lexical_cast(uuid); +} + +std::string UUIDUtility::getUUIDString() +{ + return UUIDtoString(getUUID()); +} diff --git a/src/lib/utility/UUIDUtility.h b/src/lib/utility/UUIDUtility.h new file mode 100644 index 00000000..c3a4dbd0 --- /dev/null +++ b/src/lib/utility/UUIDUtility.h @@ -0,0 +1,17 @@ +#ifndef UUID_UTILITY_H +#define UUID_UTILITY_H + +#include +#include + +typedef boost::uuids::uuid UUID; + +class UUIDUtility +{ +public: + static UUID getUUID(); + static std::string UUIDtoString(const UUID& uuid); + static std::string getUUIDString(); +}; + +#endif // UUID_UTILITY_H diff --git a/src/lib/utility/interprocess/InterprocessDataManager.cpp b/src/lib/utility/interprocess/InterprocessDataManager.cpp new file mode 100644 index 00000000..ee53a6b5 --- /dev/null +++ b/src/lib/utility/interprocess/InterprocessDataManager.cpp @@ -0,0 +1,110 @@ +#include "InterprocessDataManager.h" + +#include + +#include "utility/logging/logging.h" +#include "SharedUUIDManager.h" + +#include "InterprocessUtility.h" +#include "SharedQueue.h" + +std::string InterprocessDataManager::m_sharedArgumentQueueName = "coati_parser_arguments"; + +InterprocessDataManager::InterprocessDataManager(const bool isOwner) + : m_isOwner(isOwner) + , m_initialized(false) +{ +} + +InterprocessDataManager::~InterprocessDataManager() +{ + SharedUUIDManager::getInstance()->removeUUIDsForInstance( + SharedUUIDManager::getInstance()->getInstanceUUID()); +} + +void InterprocessDataManager::initialize() +{ + try + { + m_sharedArgumentQueueName = UUIDUtility::getUUIDString() + "_" + m_sharedArgumentQueueName; + + std::string uuid = SharedUUIDManager::getInstance()->getNewUUID(); + m_parserArguments.initialize(m_isOwner, uuid.c_str()); + + m_initialized = true; + } + catch (std::exception& e) + { + LOG_ERROR_STREAM(<< e.what()); + } +} + +void InterprocessDataManager::pushParserArguments(const Parser::Arguments& arguments) +{ + IF_INITIALIZED() + { + SharedParserArguments::VoidAllocator allocator(m_parserArguments.getSegmentManager()); + SharedParserArguments args(allocator); + + args.setCompilationDatabasePath(arguments.compilationDatabasePath.str()); + args.setCompilerFlags(arguments.compilerFlags); + args.setFrameworkSearchPaths(arguments.frameworkSearchPaths); + args.setHeaderSearchPaths(arguments.headerSearchPaths); + args.setJavaClassPaths(arguments.javaClassPaths); + args.setLanguage(arguments.language); + args.setLanguageStandard(arguments.languageStandard); + args.setLogErrors(arguments.logErrors); + args.setSystemHeaderSearchPaths(arguments.systemHeaderSearchPaths); + + m_parserArguments.pushValue(args); + } +} + +Parser::Arguments InterprocessDataManager::popParserArguments() +{ + IF_INITIALIZED(Parser::Arguments()) + { + if (m_parserArguments.size() > 0) + { + SharedParserArguments args = m_parserArguments.popValue(); + + Parser::Arguments result; + + result.compilationDatabasePath = FilePath(args.getCompilationDatabasePath()); + result.compilerFlags = args.getCompilerFlags(); + result.frameworkSearchPaths = args.getFrameworkSearchPaths(); + result.headerSearchPaths = args.getHeaderSearchPaths(); + result.javaClassPaths = args.getJavaClassPaths(); + result.language = args.getLanguage(); + result.languageStandard = args.getLanguageStandard(); + result.logErrors = args.getLogErrors(); + result.systemHeaderSearchPaths = args.getSystemHeaderSearchPaths(); + + return result; + } + } +} + +unsigned int InterprocessDataManager::parserArgumentCount() const +{ + IF_INITIALIZED(0) + { + return m_parserArguments.size(); + } +} + +void InterprocessDataManager::cleanSharedMemory() +{ + std::vector instances = SharedUUIDManager::getInstance()->getStoredInstanceUUIDs(); + + for (unsigned int i = 0; i < instances.size(); i++) + { + std::vector uuids = SharedUUIDManager::getInstance()->getUUIDsForInstance(instances[i]); + + if (uuids.size() == 1) // uuid list has to equal the count of used containers + { + std::string parserArgumentMemName = SharedQueue::getMemoryNamePrefix() + uuids[0]; + boost::interprocess::shared_memory_object::remove(parserArgumentMemName.c_str()); + } + } +} diff --git a/src/lib/utility/interprocess/InterprocessDataManager.h b/src/lib/utility/interprocess/InterprocessDataManager.h new file mode 100644 index 00000000..225e6a4e --- /dev/null +++ b/src/lib/utility/interprocess/InterprocessDataManager.h @@ -0,0 +1,33 @@ +#ifndef INTERPROCESS_DATA_MANAGER_H +#define INTERPROCESS_DATA_MANAGER_H + +#include "data/parser/Parser.h" + +#include "SharedQueue.h" + +#include "SharedParserArguments.h" + +class InterprocessDataManager +{ +public: + InterprocessDataManager(const bool isOwner = false); + ~InterprocessDataManager(); + + void initialize(); + + void pushParserArguments(const Parser::Arguments& arguments); + Parser::Arguments popParserArguments(); + unsigned int parserArgumentCount() const; + +private: + void cleanSharedMemory(); + + static std::string m_sharedArgumentQueueName; + + bool m_isOwner; + bool m_initialized; + + SharedQueue m_parserArguments; +}; + +#endif // INTERPROCESS_DATA_MANAGER_H diff --git a/src/lib/utility/interprocess/InterprocessProcessManager.cpp b/src/lib/utility/interprocess/InterprocessProcessManager.cpp new file mode 100644 index 00000000..9590fec9 --- /dev/null +++ b/src/lib/utility/interprocess/InterprocessProcessManager.cpp @@ -0,0 +1,65 @@ +#include "InterprocessProcessManager.h" + +#include + +#include "utility/logging/logging.h" + +InterprocessProcessManager::InterprocessProcessManager() + : m_processName("") + , m_processCount(1) +{ +} + +InterprocessProcessManager::~InterprocessProcessManager() +{ +} + +void InterprocessProcessManager::setProcessName(const std::string& processName) +{ + m_processName = processName; +} + +std::string InterprocessProcessManager::getProcessName() const +{ + return m_processName; +} + +void InterprocessProcessManager::setProcessCount(const unsigned int processCount) +{ + m_processCount = processCount; +} + +unsigned int InterprocessProcessManager::getProcessCount() const +{ + return m_processCount; +} + +void InterprocessProcessManager::runProcesses() +{ + std::vector processThreads; + + for (unsigned int i = 0; i < m_processCount; i++) + { + std::thread* thread = new std::thread(&InterprocessProcessManager::runProcess, this); + processThreads.push_back(thread); + } + + for (unsigned int i = 0; i < m_processCount; i++) + { + processThreads[i]->join(); + + delete processThreads[i]; + } +} + +void InterprocessProcessManager::runProcess() +{ + int result = 1; + + while (result != 0) + { + result = system(m_processName.c_str()); + + LOG_INFO_STREAM(<< "Process returned with " << std::to_string(result)); + } +} diff --git a/src/lib/utility/interprocess/InterprocessProcessManager.h b/src/lib/utility/interprocess/InterprocessProcessManager.h new file mode 100644 index 00000000..35aa5223 --- /dev/null +++ b/src/lib/utility/interprocess/InterprocessProcessManager.h @@ -0,0 +1,27 @@ +#ifndef INTERPROCESS_PROCESS_MANAGER_H +#define INTERPROCESS_PROCESS_MANAGER_H + +#include + +class InterprocessProcessManager +{ +public: + InterprocessProcessManager(); + ~InterprocessProcessManager(); + + void setProcessName(const std::string& processName); + std::string getProcessName() const; + + void setProcessCount(const unsigned int processCount); + unsigned int getProcessCount() const; + + void runProcesses(); + +private: + void runProcess(); + + std::string m_processName; + unsigned int m_processCount; +}; + +#endif // INTERPROCESS_PROCESS_MANAGER_H diff --git a/src/lib/utility/interprocess/InterprocessUtility.h b/src/lib/utility/interprocess/InterprocessUtility.h new file mode 100644 index 00000000..106c061e --- /dev/null +++ b/src/lib/utility/interprocess/InterprocessUtility.h @@ -0,0 +1,15 @@ +#ifndef INTERPROCESS_UTILITY_H +#define INTERPROCESS_UTILITY_H + +// requires a bool field 'm_initialized' to be defined +// if 'm_initialized' is false, the value '__retVal__' will be returned +// '__retVal__' is not required +#define IF_INITIALIZED(__retVal__) \ + if(m_initialized == false) \ + { \ + LOG_ERROR_STREAM(<< "not initialized"); \ + return __retVal__; \ + } \ + else \ + +#endif // INTERPROCESS_UTILITY_H diff --git a/src/lib/utility/interprocess/SharedContainer.h b/src/lib/utility/interprocess/SharedContainer.h new file mode 100644 index 00000000..89da8227 --- /dev/null +++ b/src/lib/utility/interprocess/SharedContainer.h @@ -0,0 +1,95 @@ +#ifndef SHARED_CONTAINER_H +#define SHARED_CONTAINER_H + +#include + +#include + +#include "utility/logging/logging.h" + +#include "InterprocessUtility.h" + +class SharedContainer +{ +public: + static std::string getMemoryNamePrefix(); + static std::string getContainerNamePrefix(); + + SharedContainer(); + virtual ~SharedContainer(); + + virtual bool initialize(const bool isOwner, const std::string& containerName) = 0; + +protected: + static const std::string m_memoryNamePrefix; + static const std::string m_containerNamePrefix; + + bool initializeSharedMemory(const bool isOwner); + + boost::interprocess::managed_shared_memory m_sharedMemory; + + bool m_isOwner; + bool m_initialized; + + std::string m_memoryName; + std::string m_containerName; +}; + +const std::string SharedContainer::m_memoryNamePrefix("coati_memory_"); + +const std::string SharedContainer::m_containerNamePrefix("coati_container_"); + +std::string SharedContainer::getMemoryNamePrefix() +{ + return m_memoryNamePrefix; +} + +std::string SharedContainer::getContainerNamePrefix() +{ + return m_containerNamePrefix; +} + +SharedContainer::SharedContainer() + : m_isOwner(false) + , m_initialized(false) + , m_memoryName(m_memoryNamePrefix) + , m_containerName(m_containerNamePrefix) +{ +} + +SharedContainer::~SharedContainer() +{ +} + +bool SharedContainer::initializeSharedMemory(const bool isOwner) +{ + bool initialized = false; + + try + { + if (isOwner) + { + boost::interprocess::shared_memory_object::remove(m_memoryName.c_str()); + + m_sharedMemory = boost::interprocess::managed_shared_memory(boost::interprocess::create_only, + m_memoryName.c_str(), + 65536); + } + else + { + m_sharedMemory = boost::interprocess::managed_shared_memory(boost::interprocess::open_only, + m_memoryName.c_str()); + } + + initialized = true; + } + catch (std::exception& e) + { + LOG_ERROR(e.what()); + } + + return initialized; +} + + +#endif // SHARED_CONTAINER_H diff --git a/src/lib/utility/interprocess/SharedMap.h b/src/lib/utility/interprocess/SharedMap.h new file mode 100644 index 00000000..0d859463 --- /dev/null +++ b/src/lib/utility/interprocess/SharedMap.h @@ -0,0 +1,125 @@ +#ifndef SHARED_DICTIONARY_H +#define SHARED_DICTIONARY_H + +#include + +#include +#include + +#include "SharedContainer.h" + +template +class SharedMap : public SharedContainer +{ +public: + SharedMap(); + virtual ~SharedMap(); + + virtual void initialize(const bool isOwner, const std::string& mapName); + + Value& operator[](const Key& key); + + unsigned int size() const; + + void clear(); + + boost::interprocess::managed_shared_memory::segment_manager* getSegmentManager() const; + +private: + typedef std::pair ValueType; + typedef boost::interprocess::allocator ShmemAllocator; + typedef boost::interprocess::map, ShmemAllocator> ShmemMap; + + ShmemMap* m_map; +}; + +template +SharedMap::SharedMap() + : m_map(NULL) +{ +} + +template +SharedMap::~SharedMap() +{ + if (m_map != NULL && m_initialized && m_isOwner) + { + m_sharedMemory.destroy(m_containerName.c_str()); + boost::interprocess::shared_memory_object::remove(m_memoryName.c_str()); + + delete m_map; + } +} + +template +void SharedMap::initialize(const bool isOwner, const std::string& mapName) +{ + m_isOwner = isOwner; + m_containerName = m_containerNamePrefix + dequeName; + m_memoryName = m_memoryNamePrefix + m_containerName; + + if (initializeSharedMemory(m_isOwner)) + { + try + { + if (m_isOwner) + { + m_sharedMemory.destroy(m_containerName.c_str()); + + const ShmemAllocator allocator(m_sharedMemory.get_segment_manager()); + + m_map = m_sharedMemory.construct(m_containerName.c_str())(allocator); + } + else + { + m_map = m_sharedMemory.find(m_containerName.c_str()).first; + } + + m_initialized = true; + } + catch (std::exception& e) + { + LOG_ERROR_STREAM(<< e.what()); + } + } + + return m_initialized; +} + +template +Value& SharedMap::operator[](const Key& key) +{ + IF_INITIALIZED(NULL) + { + return m_map->at(key); + } +} + +template +unsigned int SharedMap::size() const +{ + IF_INITIALIZED(0) + { + return m_map->size(); + } +} + +template +void SharedMap::clear() +{ + IF_INITIALIZED() + { + m_map->clear(); + } +} + +template +boost::interprocess::managed_shared_memory::segment_manager* SharedMap::getSegmentManager() const +{ + IF_INITIALIZED(NULL) + { + return m_sharedMemory.get_segment_manager(); + } +} + +#endif // SHARED_DICTIONARY_H diff --git a/src/lib/utility/interprocess/SharedParserArguments.cpp b/src/lib/utility/interprocess/SharedParserArguments.cpp new file mode 100644 index 00000000..0d90dd60 --- /dev/null +++ b/src/lib/utility/interprocess/SharedParserArguments.cpp @@ -0,0 +1,173 @@ +#include "SharedParserArguments.h" + +SharedParserArguments::SharedParserArguments(const VoidAllocator& allocator) + : m_logErrors(false) + , m_language("", allocator) + , m_languageStandard("", allocator) + , m_compilationDatabasePath("", allocator) + , m_javaClassPaths(allocator) + , m_headerSearchPaths(allocator) + , m_systemHeaderSearchPaths(allocator) + , m_frameworkSearchPaths(allocator) + , m_compilerFlags(allocator) +{ +} + +SharedParserArguments::~SharedParserArguments() +{ +} + +void SharedParserArguments::setLogErrors(const bool logErrors) +{ + m_logErrors = logErrors; +} + +bool SharedParserArguments::getLogErrors() const +{ + return m_logErrors; +} + +void SharedParserArguments::setLanguage(const std::string& language) +{ + m_language = language.c_str(); +} + +std::string SharedParserArguments::getLanguage() const +{ + return std::string(m_language.c_str()); +} + +void SharedParserArguments::setLanguageStandard(const std::string& languageStandard) +{ + m_languageStandard = languageStandard.c_str(); +} + +std::string SharedParserArguments::getLanguageStandard() const +{ + return std::string(m_languageStandard.c_str()); +} + +void SharedParserArguments::setCompilationDatabasePath(const std::string& compilationDatabasePath) +{ + m_compilationDatabasePath = compilationDatabasePath.c_str(); +} + +std::string SharedParserArguments::getCompilationDatabasePath() const +{ + return std::string(m_compilationDatabasePath.c_str()); +} + +void SharedParserArguments::setJavaClassPaths(std::vector javaClassPaths) +{ + m_javaClassPaths.clear(); + for (unsigned int i = 0; i < javaClassPaths.size(); i++) + { + SharedString path(m_javaClassPaths.get_allocator()); + path = javaClassPaths[i].str().c_str(); + m_javaClassPaths.push_back(path); + } +} + +std::vector SharedParserArguments::getJavaClassPaths() const +{ + std::vector result; + + for (unsigned int i = 0; i < m_javaClassPaths.size(); i++) + { + result.push_back(FilePath(m_javaClassPaths[i].c_str())); + } + + return result; +} + +void SharedParserArguments::setHeaderSearchPaths(std::vector headerSearchPaths) +{ + m_headerSearchPaths.clear(); + for (unsigned int i = 0; i < headerSearchPaths.size(); i++) + { + SharedString path(m_headerSearchPaths.get_allocator()); + path = headerSearchPaths[i].str().c_str(); + m_headerSearchPaths.push_back(path); + } +} + +std::vector SharedParserArguments::getHeaderSearchPaths() const +{ + std::vector result; + + for (unsigned int i = 0; i < m_headerSearchPaths.size(); i++) + { + result.push_back(FilePath(m_headerSearchPaths[i].c_str())); + } + + return result; +} + +void SharedParserArguments::setSystemHeaderSearchPaths(std::vector systemHeaderSearchPaths) +{ + m_systemHeaderSearchPaths.clear(); + for (unsigned int i = 0; i < systemHeaderSearchPaths.size(); i++) + { + SharedString path(m_systemHeaderSearchPaths.get_allocator()); + path = systemHeaderSearchPaths[i].str().c_str(); + m_systemHeaderSearchPaths.push_back(path); + } +} + +std::vector SharedParserArguments::getSystemHeaderSearchPaths() const +{ + std::vector result; + + for (unsigned int i = 0; i < m_systemHeaderSearchPaths.size(); i++) + { + result.push_back(FilePath(m_systemHeaderSearchPaths[i].c_str())); + } + + return result; +} + +void SharedParserArguments::setFrameworkSearchPaths(std::vector frameworkSearchPaths) +{ + m_frameworkSearchPaths.clear(); + for (unsigned int i = 0; i < frameworkSearchPaths.size(); i++) + { + SharedString path(m_frameworkSearchPaths.get_allocator()); + path = frameworkSearchPaths[i].str().c_str(); + m_frameworkSearchPaths.push_back(path); + } +} + +std::vector SharedParserArguments::getFrameworkSearchPaths() const +{ + std::vector result; + + for (unsigned int i = 0; i < m_frameworkSearchPaths.size(); i++) + { + result.push_back(FilePath(m_frameworkSearchPaths[i].c_str())); + } + + return result; +} + +void SharedParserArguments::setCompilerFlags(std::vector compilerFlags) +{ + m_compilerFlags.clear(); + for (unsigned int i = 0; i < compilerFlags.size(); i++) + { + SharedString path(m_compilerFlags.get_allocator()); + path = compilerFlags[i].c_str(); + m_compilerFlags.push_back(path); + } +} + +std::vector SharedParserArguments::getCompilerFlags() const +{ + std::vector result; + + for (unsigned int i = 0; i < m_compilerFlags.size(); i++) + { + result.push_back(m_compilerFlags[i].c_str()); + } + + return result; +} diff --git a/src/lib/utility/interprocess/SharedParserArguments.h b/src/lib/utility/interprocess/SharedParserArguments.h new file mode 100644 index 00000000..7aac3f4e --- /dev/null +++ b/src/lib/utility/interprocess/SharedParserArguments.h @@ -0,0 +1,67 @@ +#ifndef SHARED_PARSER_ARGUMENTS_H +#define SHARED_PARSER_ARGUMENTS_H + +#include +#include +#include +#include + +#include "utility/file/FilePath.h" + +class SharedParserArguments +{ +public: + typedef boost::interprocess::allocator VoidAllocator; + + SharedParserArguments(const VoidAllocator& allocator); + ~SharedParserArguments(); + + void setLogErrors(const bool logErrors); + bool getLogErrors() const; + + + void setLanguage(const std::string& language); + std::string getLanguage() const; + + + void setLanguageStandard(const std::string& languageStandard); + std::string getLanguageStandard() const; + + void setCompilationDatabasePath(const std::string& compilationDatabasePath); + std::string getCompilationDatabasePath() const; + + void setJavaClassPaths(std::vector javaClassPaths); + std::vector getJavaClassPaths() const; + + void setHeaderSearchPaths(std::vector headerSearchPaths); + std::vector getHeaderSearchPaths() const; + + void setSystemHeaderSearchPaths(std::vector systemHeaderSearchPaths); + std::vector getSystemHeaderSearchPaths() const; + + void setFrameworkSearchPaths(std::vector frameworkSearchPaths); + std::vector getFrameworkSearchPaths() const; + + void setCompilerFlags(std::vector compilerFlags); + std::vector getCompilerFlags() const; + +private: + typedef boost::interprocess::allocator CharAllocator; + typedef boost::interprocess::basic_string, CharAllocator> SharedString; + typedef boost::interprocess::allocator StringAllocator; + typedef boost::interprocess::vector SharedStringVector; + + bool m_logErrors; + + SharedString m_language; + SharedString m_languageStandard; + SharedString m_compilationDatabasePath; + + SharedStringVector m_javaClassPaths; + SharedStringVector m_headerSearchPaths; + SharedStringVector m_systemHeaderSearchPaths; + SharedStringVector m_frameworkSearchPaths; + SharedStringVector m_compilerFlags; +}; + +#endif // SHARED_PARSER_ARGUMENTS_H diff --git a/src/lib/utility/interprocess/SharedQueue.h b/src/lib/utility/interprocess/SharedQueue.h new file mode 100644 index 00000000..2b43dda2 --- /dev/null +++ b/src/lib/utility/interprocess/SharedQueue.h @@ -0,0 +1,128 @@ +#ifndef SHARED_QUEUE_H +#define SHARED_QUEUE_H + +#include +#include + +#include "SharedContainer.h" + +template +class SharedQueue : public SharedContainer +{ +public: + SharedQueue(); + virtual ~SharedQueue(); + + virtual bool initialize(const bool isOwner, const std::string& dequeName); + + void pushValue(const T& val); + T popValue(); + + unsigned int size() const; + + boost::interprocess::managed_shared_memory::segment_manager* getSegmentManager() const; + +private: + typedef boost::interprocess::allocator ShmemAllocator; + typedef boost::interprocess::deque ShmemDeque; + + ShmemDeque* m_deque; +}; + +template +SharedQueue::SharedQueue() + : m_deque(NULL) +{ +} + +template +SharedQueue::~SharedQueue() +{ + if (m_deque != NULL && m_initialized && m_isOwner) + { + m_sharedMemory.destroy(m_containerName.c_str()); + boost::interprocess::shared_memory_object::remove(m_memoryName.c_str()); + + delete m_deque; + } +} + +template +bool SharedQueue::initialize(const bool isOwner, const std::string& dequeName) +{ + m_isOwner = isOwner; + m_containerName = m_containerNamePrefix + dequeName; + m_memoryName = m_memoryNamePrefix + m_containerName; + + if (initializeSharedMemory(m_isOwner)) + { + try + { + if (isOwner) + { + m_sharedMemory.destroy(m_containerName.c_str()); + + const ShmemAllocator allocator(m_sharedMemory.get_segment_manager()); + + m_deque = m_sharedMemory.construct(m_containerName.c_str())(allocator); + } + else + { + m_deque = m_sharedMemory.find(m_containerName.c_str()).first; + } + + m_initialized = true; + } + catch (std::exception& e) + { + LOG_ERROR(e.what()); + } + } + + return m_initialized; +} + +template +void SharedQueue::pushValue(const T& val) +{ + IF_INITIALIZED() + { + m_deque->push_back(val); + } +} + +template +T SharedQueue::popValue() +{ + if (m_initialized) + { + T val = m_deque->front(); + m_deque->pop_front(); + + return val; + } + else + { + throw(std::exception("Deque was not initialized")); + } +} + +template +unsigned int SharedQueue::size() const +{ + IF_INITIALIZED(0) + { + return m_deque->size(); + } +} + +template +boost::interprocess::managed_shared_memory::segment_manager* SharedQueue::getSegmentManager() const +{ + IF_INITIALIZED(NULL) + { + return m_sharedMemory.get_segment_manager(); + } +} + +#endif // SHARED_QUEUE_H diff --git a/src/lib/utility/interprocess/SharedUUIDManager.cpp b/src/lib/utility/interprocess/SharedUUIDManager.cpp new file mode 100644 index 00000000..c2345fbc --- /dev/null +++ b/src/lib/utility/interprocess/SharedUUIDManager.cpp @@ -0,0 +1,128 @@ +#include "SharedUUIDManager.h" + +#include + +#include "utility/file/FileSystem.h" +#include "utility/ConfigManager.h" +#include "utility/text/TextAccess.h" + +#include "utility/UserPaths.h" + +const std::string SharedUUIDManager::m_fileName("sharedUUIDs.xml"); +const std::string SharedUUIDManager::m_instanceUUIDsKey("instances"); +std::shared_ptr SharedUUIDManager::m_instance(NULL); + +std::shared_ptr SharedUUIDManager::getInstance() +{ + if (m_instance == NULL) + { + // m_instance = std::make_shared(); + SharedUUIDManager* sharedUUIDManager = new SharedUUIDManager(); + m_instance = std::shared_ptr(sharedUUIDManager); + m_instance->setFilePath(UserPaths::getUserDataPath()); + m_instance->saveInstanceUUID(); + } + + return m_instance; +} + +SharedUUIDManager::~SharedUUIDManager() +{ +} + +void SharedUUIDManager::setFilePath(const std::string& filePath) +{ + m_filePath = filePath; + FileSystem::createDirectory(m_filePath); + + refreshUUIDs(); +} + +std::string SharedUUIDManager::getInstanceUUID() const +{ + return UUIDUtility::UUIDtoString(m_instanceUUID); +} + +std::string SharedUUIDManager::getNewUUID() +{ + std::string uuidString = UUIDUtility::getUUIDString(); + + std::vector uuids; + m_uuids->getValues(UUIDUtility::UUIDtoString(m_instanceUUID), uuids); + + uuids.push_back(uuidString); + + m_uuids->setValues(UUIDUtility::UUIDtoString(m_instanceUUID), uuids); + + m_uuids->save(m_filePath + m_fileName); + + return uuidString; +} + +std::vector SharedUUIDManager::getUUIDsForInstance(const std::string& instanceUUID) +{ + std::vector uuids; + m_uuids->getValues(instanceUUID, uuids); + + return uuids; +} + +void SharedUUIDManager::removeUUIDsForInstance(const std::string& instanceUUID) +{ + m_uuids->removeValues(instanceUUID); + + m_uuids->save(m_filePath + m_fileName); +} + +std::vector SharedUUIDManager::getStoredInstanceUUIDs() const +{ + std::vector instanceUUIDs; + m_uuids->getValues(m_instanceUUIDsKey, instanceUUIDs); + + return instanceUUIDs; +} + +void SharedUUIDManager::removeInstanceUUID(const std::string& instanceUUID) +{ + std::vector instanceUUIDs; + m_uuids->getValues(m_instanceUUIDsKey, instanceUUIDs); + + // instanceUUIDs + + std::vector::iterator it = instanceUUIDs.begin(); + for (it; it != instanceUUIDs.end(); it++) + { + if (*it == instanceUUID) + { + instanceUUIDs.erase(it); + break; + } + } + + m_uuids->setValues(m_instanceUUIDsKey, instanceUUIDs); + m_uuids->save(m_filePath + m_fileName); +} + +SharedUUIDManager::SharedUUIDManager() + : m_filePath("user/") + , m_instanceUUID(UUIDUtility::getUUID()) + , m_uuids(NULL) +{ +} + +void SharedUUIDManager::saveInstanceUUID() +{ + std::vector instanceUUIDs; + m_uuids->getValues(m_instanceUUIDsKey, instanceUUIDs); + + instanceUUIDs.push_back(getInstanceUUID()); + m_uuids->setValues(m_instanceUUIDsKey, instanceUUIDs); +} + +void SharedUUIDManager::refreshUUIDs() +{ + if (FilePath(m_filePath + m_fileName).exists()) + { + m_uuids = ConfigManager::createAndLoad(TextAccess::createFromFile(m_filePath + m_fileName)); + } +} diff --git a/src/lib/utility/interprocess/SharedUUIDManager.h b/src/lib/utility/interprocess/SharedUUIDManager.h new file mode 100644 index 00000000..6c8f0bb6 --- /dev/null +++ b/src/lib/utility/interprocess/SharedUUIDManager.h @@ -0,0 +1,47 @@ +#ifndef SHARED_UUID_MANAGER_H +#define SHARED_UUID_MANAGER_H + +#include +#include + +#include "utility/UUIDUtility.h" + +#include "utility/ConfigManager.h" + +class SharedUUIDManager +{ +public: + static std::shared_ptr getInstance(); + + ~SharedUUIDManager(); + + void setFilePath(const std::string& filePath); + + std::string getInstanceUUID() const; + std::string getNewUUID(); + + std::vector getUUIDsForInstance(const std::string& instanceUUID); + void removeUUIDsForInstance(const std::string& instanceUUID); + + std::vector getStoredInstanceUUIDs() const; + void removeInstanceUUID(const std::string& instanceUUID); + +private: + SharedUUIDManager(); + + void saveInstanceUUID(); + + void refreshUUIDs(); + + static const std::string m_fileName; + static const std::string m_instanceUUIDsKey; + static std::shared_ptr m_instance; + + std::string m_filePath; + + const UUID m_instanceUUID; + + std::shared_ptr m_uuids; +}; + +#endif // SHARED_UUID_MANAGER_H