source: nscp/service/plugin_list.hpp @ a44cb15

#pragma once

#include <set>

#include <boost/shared_ptr.hpp>
#include <boost/foreach.hpp>

#include "NSCPlugin.h"
#include "logger.hpp"

using namespace nscp::helpers;

namespace nsclient {
        typedef boost::shared_ptr<NSCPlugin> plugin_type;
        typedef std::map<unsigned long,plugin_type> plugin_list_type;
        typedef std::set<unsigned long> plugin_id_type;

        class plugins_list_exception : public std::exception {
                std::string what_;
        public:
                plugins_list_exception(std::wstring error) throw() : what_(to_string(error).c_str()) {}
                plugins_list_exception(std::string error) throw() : what_(error.c_str()) {}
                virtual ~plugins_list_exception() throw() {};

                virtual const char* what() const throw() {
                        return what_.c_str();
                }
        };

        template<class parent>
        struct plugins_list : boost::noncopyable, public parent {

                nsclient::logger *logger_;
                plugin_list_type plugins_;
                boost::shared_mutex mutex_;

                plugins_list(nsclient::logger *logger) : logger_(logger) {}

                bool has_valid_lock_log(boost::unique_lock<boost::shared_mutex> &lock, std::wstring key) {
                        if (!lock.owns_lock()) {
                                log_error(__FILE__, __LINE__, _T("Failed to get mutex: ") + key);
                                return false;
                        }
                        return true;
                }
                bool has_valid_lock_log(boost::shared_lock<boost::shared_mutex> &lock, std::wstring key) {
                        if (!lock.owns_lock()) {
                                log_error(__FILE__, __LINE__, _T("Failed to get mutex: ") + key);
                                return false;
                        }
                        return true;
                }
                void has_valid_lock_throw(boost::unique_lock<boost::shared_mutex> &lock, std::wstring key) {
                        if (!lock.owns_lock()) {
                                log_error(__FILE__, __LINE__, _T("Failed to get mutex: ") + key);
                                throw plugins_list_exception("Failed to get mutex: " + utf8::cvt<std::string>(key));
                        }
                }
                void has_valid_lock_throw(boost::shared_lock<boost::shared_mutex> &lock, std::wstring key) {
                        if (!lock.owns_lock()) {
                                log_error(__FILE__, __LINE__, _T("Failed to get mutex: ") + key);
                                throw plugins_list_exception("Failed to get mutex: " + utf8::cvt<std::string>(key));
                        }
                }

                void add_plugin(plugin_type plugin) {
                        boost::unique_lock<boost::shared_mutex> writeLock(mutex_, boost::get_system_time() + boost::posix_time::seconds(30));
                        if (!has_valid_lock_log(writeLock, _T("plugins_list::add_plugin")))
                                return;
                        plugins_[plugin->get_id()] = plugin;
                        parent::add_plugin(plugin);
                }

                void remove_all() {
                        boost::unique_lock<boost::shared_mutex> writeLock(mutex_, boost::get_system_time() + boost::posix_time::seconds(30));
                        if (!has_valid_lock_log(writeLock, _T("plugins_list::remove_all")))
                                return;
                        plugins_.clear();
                        parent::remove_all();
                }

                void remove_plugin(unsigned long id) {
                        boost::unique_lock<boost::shared_mutex> writeLock(mutex_, boost::get_system_time() + boost::posix_time::seconds(10));
                        if (!has_valid_lock_log(writeLock, _T("plugins_list::remove_plugin") + ::to_wstring(id)))
                                return;
                        plugin_list_type::iterator pit = plugins_.find(id);
                        if (pit != plugins_.end())
                                plugins_.erase(pit);
                        parent::remove_plugin(id);
                }

                std::list<std::wstring> list() {
                        std::list<std::wstring> lst;
                        boost::shared_lock<boost::shared_mutex> readLock(mutex_, boost::get_system_time() + boost::posix_time::seconds(5));
                        if (!has_valid_lock_log(readLock, _T("plugins_list::list")))
                                return lst;
                        parent::list(lst);
                        return lst;
                }

                std::wstring to_wstring() {
                        std::wstring ret;
                        BOOST_FOREACH(std::wstring str, list()) {
                                if (!ret.empty()) ret += _T(", ");
                                ret += str;
                        }
                        return ret + parent::to_wstring();
                }
                std::string to_string() {
                        std::string ret;
                        BOOST_FOREACH(std::wstring str, list()) {
                                if (!ret.empty()) ret += ", ";
                                ret += utf8::cvt<std::string>(str);
                        }
                        return ret + parent::to_string();
                }

                inline std::wstring make_key(std::wstring key) {
                        return boost::algorithm::to_lower_copy(key);
                }
                void log_error(std::string file, int line, std::wstring error) {
                        if (logger_ != NULL)
                                logger_->nsclient_log_error(file, line, error);
                }

                inline bool have_plugin(unsigned long plugin_id) {
                        return !(plugins_.find(plugin_id) == plugins_.end());
                }
        };


        struct plugins_list_listeners_impl {
                typedef std::map<std::wstring,plugin_id_type > listener_list_type;
                listener_list_type listeners_;

                void add_plugin(plugin_type plugin) {}

                void remove_all() {
                        listeners_.clear();
                }

                void remove_plugin(unsigned long id) {
                        listener_list_type::iterator it = listeners_.begin();
                        while (it != listeners_.end()) {
                                if ((*it).second.count(id) > 0) {
                                        listener_list_type::iterator toerase = it;
                                        ++it;
                                        listeners_.erase(toerase);
                                } else
                                        ++it;
                        }
                }

                void list(std::list<std::wstring> &lst) {
                        BOOST_FOREACH(listener_list_type::value_type i, listeners_) {
                                lst.push_back(i.first);
                        }
                }
                std::wstring to_wstring() {
                        std::wstring ret;
                        BOOST_FOREACH(listener_list_type::value_type i, listeners_) {
                                ret += _T(", ");
                                ret += i.first;
                        }
                        return ret;
                }
                std::string to_string() {
                        std::string ret;
                        BOOST_FOREACH(listener_list_type::value_type i, listeners_) {
                                ret += ", ";
                                ret += utf8::cvt<std::string>(i.first);
                        }
                        return ret;
                }

        };

        struct plugins_list_with_listener : plugins_list<plugins_list_listeners_impl> {
                typedef plugins_list<plugins_list_listeners_impl> parent_type;

                plugins_list_with_listener(nsclient::logger *logger) : parent_type(logger) {}

                void register_listener(unsigned long plugin_id, std::wstring channel) {
                        boost::unique_lock<boost::shared_mutex> writeLock(mutex_, boost::get_system_time() + boost::posix_time::seconds(10));
                        if (!writeLock.owns_lock()) {
                                log_error(__FILE__, __LINE__, _T("Failed to get mutex: ") + channel);
                                return;
                        }
                        std::wstring lc = make_key(channel);
                        if (!have_plugin(plugin_id)) {
                                writeLock.release();
                                throw plugins_list_exception("Failed to find plugin: " + ::to_string(plugin_id) + ", Plugins: " + to_string());
                        }
                        listeners_[lc].insert(plugin_id);
                }

                std::list<plugin_type> get(std::wstring channel) {
                        boost::shared_lock<boost::shared_mutex> readLock(mutex_, boost::get_system_time() + boost::posix_time::seconds(5));
                        has_valid_lock_throw(readLock, _T("plugins_list::get:") + channel);
                        std::wstring lc = make_key(channel);
                        plugins_list_listeners_impl::listener_list_type::iterator cit = listeners_.find(lc);
                        if (cit == listeners_.end()) {
                                return std::list<plugin_type>(); // throw plugins_list_exception("Channel not found: '" + ::to_string(channel) + "'" + to_string());
                        }
                        std::list<plugin_type> ret;
                        BOOST_FOREACH(unsigned long id, cit->second) {
                                ret.push_back(plugins_[id]);
                        }
                        return ret;
                }
        };

}