diff --git a/.history/SubscriptionHandler_20221013185305.cpp b/.history/SubscriptionHandler_20221013185305.cpp new file mode 100644 index 0000000..ce40556 --- /dev/null +++ b/.history/SubscriptionHandler_20221013185305.cpp @@ -0,0 +1,68 @@ +#include "Subscription.h" +#include "TCPSession.h" +#include "Log.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + +} diff --git a/.history/SubscriptionHandler_20221013191001.h b/.history/SubscriptionHandler_20221013191001.h new file mode 100644 index 0000000..43d7bd0 --- /dev/null +++ b/.history/SubscriptionHandler_20221013191001.h @@ -0,0 +1,24 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + SubscriptionHandler(); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221013204338.h b/.history/SubscriptionHandler_20221013204338.h new file mode 100644 index 0000000..6fc8994 --- /dev/null +++ b/.history/SubscriptionHandler_20221013204338.h @@ -0,0 +1,23 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + SubscriptionHandler(); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221013204409.cpp b/.history/SubscriptionHandler_20221013204409.cpp new file mode 100644 index 0000000..23c2e94 --- /dev/null +++ b/.history/SubscriptionHandler_20221013204409.cpp @@ -0,0 +1,68 @@ +#include "SubscriptionHandler.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + +} diff --git a/.history/SubscriptionHandler_20221013204504.h b/.history/SubscriptionHandler_20221013204504.h new file mode 100644 index 0000000..6fc8994 --- /dev/null +++ b/.history/SubscriptionHandler_20221013204504.h @@ -0,0 +1,23 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + SubscriptionHandler(); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221013204612.cpp b/.history/SubscriptionHandler_20221013204612.cpp new file mode 100644 index 0000000..45cb3fb --- /dev/null +++ b/.history/SubscriptionHandler_20221013204612.cpp @@ -0,0 +1,68 @@ +#include "Log.h" +#include "Subscription.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + +} diff --git a/.history/SubscriptionHandler_20221014152050.h b/.history/SubscriptionHandler_20221014152050.h new file mode 100644 index 0000000..a625a99 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152050.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session){}; + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152131.h b/.history/SubscriptionHandler_20221014152131.h new file mode 100644 index 0000000..fef3b55 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152131.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) {} + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152241.h b/.history/SubscriptionHandler_20221014152241.h new file mode 100644 index 0000000..1c8484b --- /dev/null +++ b/.history/SubscriptionHandler_20221014152241.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler : public Base + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) {} + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152252.h b/.history/SubscriptionHandler_20221014152252.h new file mode 100644 index 0000000..fef3b55 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152252.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) {} + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152513.h b/.history/SubscriptionHandler_20221014152513.h new file mode 100644 index 0000000..7ad43f5 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152513.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) { return 1; } + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014153238.h b/.history/SubscriptionHandler_20221014153238.h new file mode 100644 index 0000000..71929a1 --- /dev/null +++ b/.history/SubscriptionHandler_20221014153238.h @@ -0,0 +1,23 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class TCPSession; + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session); + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013225816.h b/.history/SubscriptionManager_20221013225816.h new file mode 100644 index 0000000..d748e1c --- /dev/null +++ b/.history/SubscriptionManager_20221013225816.h @@ -0,0 +1,33 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "TCPSession.h" +#include "Subscription.h" +#include "Command.h" +#include "ZString.h" +#include +#include + +namespace core { + + class SubscriptionManager : public Command { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int addHandler(std::string name, SubscriptionHandler &handler) + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + std::mutex lock; + + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013230931.cpp b/.history/SubscriptionManager_20221013230931.cpp new file mode 100644 index 0000000..bff4406 --- /dev/null +++ b/.history/SubscriptionManager_20221013230931.cpp @@ -0,0 +1,100 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core { + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + handlers. + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for(auto [key, subscription] : subscriptions) { + if(temp != "") { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if(subscription->owner == &session) { + temp = key; + delete subscription; + ++countPublished; + } + } + if(temp != "") { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) { + if(request[0].equals("publish")) { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } else if(request[0].equals("catalog")) { + session.out << ":catalog:"; + for(auto const& [key, subscription] : subscriptions) { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if(request[1].equals(subscription->id)) { + if(request[0].equals("unpublish")) { + subscriptions.erase(request[1].str()); + } else if(request[0].equals("subscribe")) { + subscription->subscribe(session); + return 1; + } else if(request[0].equals("unsubscribe")) { + subscription->unsubscribe(session); + return 1; + } else if(request[0].equals("event")) { + std::stringstream out; + subscription->process(request, out, session); + if(subscription->mode == "*ANYONE") { + subscription->event(out); + return 1; + } else if(subscription->mode == "*SUBSCRIBERS") { + if(subscription->ifSubscriber(session)) { + subscription->event(out); + return 1; + } + } else if(subscription->mode == "*AUTHOR") { + if(subscription->owner == &session) { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013231054.cpp b/.history/SubscriptionManager_20221013231054.cpp new file mode 100644 index 0000000..2c897ba --- /dev/null +++ b/.history/SubscriptionManager_20221013231054.cpp @@ -0,0 +1,127 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + handlers.lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013231834.h b/.history/SubscriptionManager_20221013231834.h new file mode 100644 index 0000000..6113b52 --- /dev/null +++ b/.history/SubscriptionManager_20221013231834.h @@ -0,0 +1,34 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232252.h b/.history/SubscriptionManager_20221013232252.h new file mode 100644 index 0000000..69e27ad --- /dev/null +++ b/.history/SubscriptionManager_20221013232252.h @@ -0,0 +1,34 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232501.h b/.history/SubscriptionManager_20221013232501.h new file mode 100644 index 0000000..33bfae4 --- /dev/null +++ b/.history/SubscriptionManager_20221013232501.h @@ -0,0 +1,34 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription, SubscriptionHandler &handlers); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232513.h b/.history/SubscriptionManager_20221013232513.h new file mode 100644 index 0000000..22b4d1d --- /dev/null +++ b/.history/SubscriptionManager_20221013232513.h @@ -0,0 +1,34 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription, SubscriptionHandler *handlers); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232519.h b/.history/SubscriptionManager_20221013232519.h new file mode 100644 index 0000000..4e31671 --- /dev/null +++ b/.history/SubscriptionManager_20221013232519.h @@ -0,0 +1,34 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription, SubscriptionHandler *handler); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232529.cpp b/.history/SubscriptionManager_20221013232529.cpp new file mode 100644 index 0000000..d618840 --- /dev/null +++ b/.history/SubscriptionManager_20221013232529.cpp @@ -0,0 +1,127 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + handler.lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013232559.cpp b/.history/SubscriptionManager_20221013232559.cpp new file mode 100644 index 0000000..e4e91fb --- /dev/null +++ b/.history/SubscriptionManager_20221013232559.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + + handler.lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013232603.cpp b/.history/SubscriptionManager_20221013232603.cpp new file mode 100644 index 0000000..9cb8023 --- /dev/null +++ b/.history/SubscriptionManager_20221013232603.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + + handlers.lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013232637.cpp b/.history/SubscriptionManager_20221013232637.cpp new file mode 100644 index 0000000..b77390f --- /dev/null +++ b/.history/SubscriptionManager_20221013232637.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013232709.cpp b/.history/SubscriptionManager_20221013232709.cpp new file mode 100644 index 0000000..75f920d --- /dev/null +++ b/.history/SubscriptionManager_20221013232709.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221013232718.cpp b/.history/SubscriptionManager_20221013232718.cpp new file mode 100644 index 0000000..616f635 --- /dev/null +++ b/.history/SubscriptionManager_20221013232718.cpp @@ -0,0 +1,127 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } + +} diff --git a/.history/SubscriptionManager_20221014001552.cpp b/.history/SubscriptionManager_20221014001552.cpp new file mode 100644 index 0000000..8324d3c --- /dev/null +++ b/.history/SubscriptionManager_20221014001552.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription.setHandler = handler[handler]; + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014001640.cpp b/.history/SubscriptionManager_20221014001640.cpp new file mode 100644 index 0000000..784a103 --- /dev/null +++ b/.history/SubscriptionManager_20221014001640.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler = handler[handler]; + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014001750.cpp b/.history/SubscriptionManager_20221014001750.cpp new file mode 100644 index 0000000..bae78e2 --- /dev/null +++ b/.history/SubscriptionManager_20221014001750.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers) + subscription->setHandler = handler[handler]; + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014001801.cpp b/.history/SubscriptionManager_20221014001801.cpp new file mode 100644 index 0000000..784a103 --- /dev/null +++ b/.history/SubscriptionManager_20221014001801.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler = handler[handler]; + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014001829.cpp b/.history/SubscriptionManager_20221014001829.cpp new file mode 100644 index 0000000..1278eb1 --- /dev/null +++ b/.history/SubscriptionManager_20221014001829.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler = handlers[handler]; + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014001848.cpp b/.history/SubscriptionManager_20221014001848.cpp new file mode 100644 index 0000000..7405bf1 --- /dev/null +++ b/.history/SubscriptionManager_20221014001848.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002019.cpp b/.history/SubscriptionManager_20221014002019.cpp new file mode 100644 index 0000000..efc059b --- /dev/null +++ b/.history/SubscriptionManager_20221014002019.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler(*handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002052.cpp b/.history/SubscriptionManager_20221014002052.cpp new file mode 100644 index 0000000..7405bf1 --- /dev/null +++ b/.history/SubscriptionManager_20221014002052.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002112.cpp b/.history/SubscriptionManager_20221014002112.cpp new file mode 100644 index 0000000..9324632 --- /dev/null +++ b/.history/SubscriptionManager_20221014002112.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler != NULL) + subscription->setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002118.cpp b/.history/SubscriptionManager_20221014002118.cpp new file mode 100644 index 0000000..23e3e53 --- /dev/null +++ b/.history/SubscriptionManager_20221014002118.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler == NULL) + subscription->setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002130.cpp b/.history/SubscriptionManager_20221014002130.cpp new file mode 100644 index 0000000..4580af7 --- /dev/null +++ b/.history/SubscriptionManager_20221014002130.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler = !NULL) + subscription->setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002136.cpp b/.history/SubscriptionManager_20221014002136.cpp new file mode 100644 index 0000000..7405bf1 --- /dev/null +++ b/.history/SubscriptionManager_20221014002136.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription->setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002203.cpp b/.history/SubscriptionManager_20221014002203.cpp new file mode 100644 index 0000000..a26a962 --- /dev/null +++ b/.history/SubscriptionManager_20221014002203.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription.setHandler(handlers[handler]); + subscription->setHandler(); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002300.cpp b/.history/SubscriptionManager_20221014002300.cpp new file mode 100644 index 0000000..ccfb690 --- /dev/null +++ b/.history/SubscriptionManager_20221014002300.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002351.cpp b/.history/SubscriptionManager_20221014002351.cpp new file mode 100644 index 0000000..00c9082 --- /dev/null +++ b/.history/SubscriptionManager_20221014002351.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers != NULL) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002355.cpp b/.history/SubscriptionManager_20221014002355.cpp new file mode 100644 index 0000000..17f04bb --- /dev/null +++ b/.history/SubscriptionManager_20221014002355.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers = NULL) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002404.cpp b/.history/SubscriptionManager_20221014002404.cpp new file mode 100644 index 0000000..a07e58e --- /dev/null +++ b/.history/SubscriptionManager_20221014002404.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers == NULL) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002416.cpp b/.history/SubscriptionManager_20221014002416.cpp new file mode 100644 index 0000000..33ca4eb --- /dev/null +++ b/.history/SubscriptionManager_20221014002416.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002543.cpp b/.history/SubscriptionManager_20221014002543.cpp new file mode 100644 index 0000000..5e29a2f --- /dev/null +++ b/.history/SubscriptionManager_20221014002543.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (*handlers) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002547.cpp b/.history/SubscriptionManager_20221014002547.cpp new file mode 100644 index 0000000..33ca4eb --- /dev/null +++ b/.history/SubscriptionManager_20221014002547.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002751.cpp b/.history/SubscriptionManager_20221014002751.cpp new file mode 100644 index 0000000..66ccaf0 --- /dev/null +++ b/.history/SubscriptionManager_20221014002751.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.empty()) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002909.cpp b/.history/SubscriptionManager_20221014002909.cpp new file mode 100644 index 0000000..1422f5b --- /dev/null +++ b/.history/SubscriptionManager_20221014002909.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler)) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002931.cpp b/.history/SubscriptionManager_20221014002931.cpp new file mode 100644 index 0000000..c7ac40c --- /dev/null +++ b/.history/SubscriptionManager_20221014002931.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014002952.cpp b/.history/SubscriptionManager_20221014002952.cpp new file mode 100644 index 0000000..69b185b --- /dev/null +++ b/.history/SubscriptionManager_20221014002952.cpp @@ -0,0 +1,141 @@ +#include "Log.h" +#include "SubscriptionManager.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003012.cpp b/.history/SubscriptionManager_20221014003012.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003012.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + { + } + else + { + subscription.setHandler(handlers[handler]); + lock.unlock(); + } + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003016.cpp b/.history/SubscriptionManager_20221014003016.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003016.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + { + } + else + { + subscription.setHandler(handlers[handler]); + lock.unlock(); + } + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003032.cpp b/.history/SubscriptionManager_20221014003032.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003032.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + { + } + else + { + subscription.setHandler(handlers[handler]); + lock.unlock(); + } + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003110.cpp b/.history/SubscriptionManager_20221014003110.cpp new file mode 100644 index 0000000..6f3cc96 --- /dev/null +++ b/.history/SubscriptionManager_20221014003110.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + { + } + else + { + subscription.setHandler(handlers[handler]); + lock.unlock(); + } + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscriptions = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003112.cpp b/.history/SubscriptionManager_20221014003112.cpp new file mode 100644 index 0000000..c6463cd --- /dev/null +++ b/.history/SubscriptionManager_20221014003112.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + { + } + else + { + subscription.setHandler(handlers[handler]); + lock.unlock(); + } + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscriptions = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscriptions)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003118.cpp b/.history/SubscriptionManager_20221014003118.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003118.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handlers.find(handler) == handlers.end()) + { + } + else + { + subscription.setHandler(handlers[handler]); + lock.unlock(); + } + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003740.cpp b/.history/SubscriptionManager_20221014003740.cpp new file mode 100644 index 0000000..ccfb690 --- /dev/null +++ b/.history/SubscriptionManager_20221014003740.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription.setHandler(handlers[handler]); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014003842.cpp b/.history/SubscriptionManager_20221014003842.cpp new file mode 100644 index 0000000..c04fdce --- /dev/null +++ b/.history/SubscriptionManager_20221014003842.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + if (handler) + subscription.setHandler = handlers[handler]; + + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + if (request.getList().size() > 2) + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; +} +} diff --git a/.history/SubscriptionManager_20221014224510.cpp b/.history/SubscriptionManager_20221014224510.cpp new file mode 100644 index 0000000..fd31da3 --- /dev/null +++ b/.history/SubscriptionManager_20221014224510.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription; + if (request.getList().size() > 2) + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015132404.cpp b/.history/SubscriptionManager_20221015132404.cpp new file mode 100644 index 0000000..6d5fa0b --- /dev/null +++ b/.history/SubscriptionManager_20221015132404.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription; + // if (request.getList().size() > 2) + // newSubscription = new Subscription(request[1].str(), session, request[2].str()); + // else + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015135839.cpp b/.history/SubscriptionManager_20221015135839.cpp new file mode 100644 index 0000000..3beda7c --- /dev/null +++ b/.history/SubscriptionManager_20221015135839.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription; + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140050.cpp b/.history/SubscriptionManager_20221015140050.cpp new file mode 100644 index 0000000..71a21da --- /dev/null +++ b/.history/SubscriptionManager_20221015140050.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription; + if (request.getList().size() > 3) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140147.cpp b/.history/SubscriptionManager_20221015140147.cpp new file mode 100644 index 0000000..4baacdb --- /dev/null +++ b/.history/SubscriptionManager_20221015140147.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + Subscription *newSubscription; + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140418.h b/.history/SubscriptionManager_20221015140418.h new file mode 100644 index 0000000..e370a76 --- /dev/null +++ b/.history/SubscriptionManager_20221015140418.h @@ -0,0 +1,37 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int add(Subscription &subscription, std::string handler); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + std::map subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221015140432.cpp b/.history/SubscriptionManager_20221015140432.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015140432.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140547.cpp b/.history/SubscriptionManager_20221015140547.cpp new file mode 100644 index 0000000..f976bcf --- /dev/null +++ b/.history/SubscriptionManager_20221015140547.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.str().getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140637.cpp b/.history/SubscriptionManager_20221015140637.cpp new file mode 100644 index 0000000..92e4dc5 --- /dev/null +++ b/.history/SubscriptionManager_20221015140637.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getLength.size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140703.cpp b/.history/SubscriptionManager_20221015140703.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015140703.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140849.cpp b/.history/SubscriptionManager_20221015140849.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015140849.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015140915.cpp b/.history/SubscriptionManager_20221015140915.cpp new file mode 100644 index 0000000..fdfdec3 --- /dev/null +++ b/.history/SubscriptionManager_20221015140915.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + // newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015141339.cpp b/.history/SubscriptionManager_20221015141339.cpp new file mode 100644 index 0000000..b120314 --- /dev/null +++ b/.history/SubscriptionManager_20221015141339.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + // newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015141418.cpp b/.history/SubscriptionManager_20221015141418.cpp new file mode 100644 index 0000000..7b8d183 --- /dev/null +++ b/.history/SubscriptionManager_20221015141418.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + else + { + // newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015141638.cpp b/.history/SubscriptionManager_20221015141638.cpp new file mode 100644 index 0000000..6424f60 --- /dev/null +++ b/.history/SubscriptionManager_20221015141638.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + } + + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015180125.cpp b/.history/SubscriptionManager_20221015180125.cpp new file mode 100644 index 0000000..df0809a --- /dev/null +++ b/.history/SubscriptionManager_20221015180125.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015181249.cpp b/.history/SubscriptionManager_20221015181249.cpp new file mode 100644 index 0000000..464076a --- /dev/null +++ b/.history/SubscriptionManager_20221015181249.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 3) + { + + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015181639.cpp b/.history/SubscriptionManager_20221015181639.cpp new file mode 100644 index 0000000..be48bd0 --- /dev/null +++ b/.history/SubscriptionManager_20221015181639.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() >= 2) + { + + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015181912.cpp b/.history/SubscriptionManager_20221015181912.cpp new file mode 100644 index 0000000..df0809a --- /dev/null +++ b/.history/SubscriptionManager_20221015181912.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015182122.cpp b/.history/SubscriptionManager_20221015182122.cpp new file mode 100644 index 0000000..3ed7565 --- /dev/null +++ b/.history/SubscriptionManager_20221015182122.cpp @@ -0,0 +1,143 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015183109.cpp b/.history/SubscriptionManager_20221015183109.cpp new file mode 100644 index 0000000..4a7a545 --- /dev/null +++ b/.history/SubscriptionManager_20221015183109.cpp @@ -0,0 +1,143 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() >= 2) + + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + else + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015183204.cpp b/.history/SubscriptionManager_20221015183204.cpp new file mode 100644 index 0000000..0981e51 --- /dev/null +++ b/.history/SubscriptionManager_20221015183204.cpp @@ -0,0 +1,144 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() >= 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015183209.cpp b/.history/SubscriptionManager_20221015183209.cpp new file mode 100644 index 0000000..8d76f43 --- /dev/null +++ b/.history/SubscriptionManager_20221015183209.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() >= 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015183518.cpp b/.history/SubscriptionManager_20221015183518.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015183518.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015191146.cpp b/.history/SubscriptionManager_20221015191146.cpp new file mode 100644 index 0000000..1ab0538 --- /dev/null +++ b/.history/SubscriptionManager_20221015191146.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015193901.cpp b/.history/SubscriptionManager_20221015193901.cpp new file mode 100644 index 0000000..1db78ab --- /dev/null +++ b/.history/SubscriptionManager_20221015193901.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015200446.cpp b/.history/SubscriptionManager_20221015200446.cpp new file mode 100644 index 0000000..0804ac6 --- /dev/null +++ b/.history/SubscriptionManager_20221015200446.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + subscription.setHandler(handlers["handler"]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015200502.cpp b/.history/SubscriptionManager_20221015200502.cpp new file mode 100644 index 0000000..1db78ab --- /dev/null +++ b/.history/SubscriptionManager_20221015200502.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015201436.h b/.history/SubscriptionManager_20221015201436.h new file mode 100644 index 0000000..7e928e4 --- /dev/null +++ b/.history/SubscriptionManager_20221015201436.h @@ -0,0 +1,38 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int add(Subscription &subscription, std::string handler); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + Subscription subscription; + std::map subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221015201440.h b/.history/SubscriptionManager_20221015201440.h new file mode 100644 index 0000000..566cac8 --- /dev/null +++ b/.history/SubscriptionManager_20221015201440.h @@ -0,0 +1,38 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int add(Subscription &subscription, std::string handler); + int addHandler(std::string name, SubscriptionHandler &handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + Subscription *subscription; + std::map subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221015201500.cpp b/.history/SubscriptionManager_20221015201500.cpp new file mode 100644 index 0000000..1db78ab --- /dev/null +++ b/.history/SubscriptionManager_20221015201500.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015201542.cpp b/.history/SubscriptionManager_20221015201542.cpp new file mode 100644 index 0000000..cc7c533 --- /dev/null +++ b/.history/SubscriptionManager_20221015201542.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + subscription->setHandler(handlers[name]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221015201557.cpp b/.history/SubscriptionManager_20221015201557.cpp new file mode 100644 index 0000000..cc7c533 --- /dev/null +++ b/.history/SubscriptionManager_20221015201557.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + subscription->setHandler(handlers[name]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221016174159.cpp b/.history/SubscriptionManager_20221016174159.cpp new file mode 100644 index 0000000..f32b63a --- /dev/null +++ b/.history/SubscriptionManager_20221016174159.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name; + subscription->setHandler(handler); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221016174206.cpp b/.history/SubscriptionManager_20221016174206.cpp new file mode 100644 index 0000000..d34f2f4 --- /dev/null +++ b/.history/SubscriptionManager_20221016174206.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name; + subscription->setHandler(&handler); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221016175448.cpp b/.history/SubscriptionManager_20221016175448.cpp new file mode 100644 index 0000000..42235f3 --- /dev/null +++ b/.history/SubscriptionManager_20221016175448.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, &handler)); + coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name; + subscription->setHandler(handlers[name]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221016180238.cpp b/.history/SubscriptionManager_20221016180238.cpp new file mode 100644 index 0000000..614e1f4 --- /dev/null +++ b/.history/SubscriptionManager_20221016180238.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +namespace core +{ + + SubscriptionManager::SubscriptionManager() {} + + int SubscriptionManager::add(Subscription &subscription) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::add(Subscription &subscription, std::string handler) + { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + subscription.setHandler(handlers[handler]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler *handler) + { + lock.lock(); + handlers.insert(std::make_pair(name, handler)); + coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name; + subscription->setHandler(handlers[name]); + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { + int countSubscribed = 0; + int countPublished = 0; + + lock.lock(); + std::string temp = ""; + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + countSubscribed += subscription->unsubscribe(session); + if (subscription->owner == &session) + { + temp = key; + delete subscription; + ++countPublished; + } + } + if (temp != "") + { + subscriptions.erase(temp); + temp = ""; + } + coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; + coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; + lock.unlock(); + return countSubscribed; + } + + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + + if (request.getList().size() > 2) + { + newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str()); + } + else + { + newSubscription = new Subscription(request[1].str(), session, request[2].str()); + } + + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; + } + session.out << std::endl; + return 1; + } + + auto subscription = subscriptions[request[1].str()]; + + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); + return 1; + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); + return 1; + } + else if (request[0].equals("event")) + { + std::stringstream out; + subscription->process(request, out, session); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); + return 1; + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); + return 1; + } + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); + return 1; + } + } + } + return 0; + } + return 0; + } +} diff --git a/.history/SubscriptionManager_20221016180248.h b/.history/SubscriptionManager_20221016180248.h new file mode 100644 index 0000000..d7613fd --- /dev/null +++ b/.history/SubscriptionManager_20221016180248.h @@ -0,0 +1,38 @@ +#ifndef __SubscriptionManager_h__ +#define __SubscriptionManager_h__ + +#include "Command.h" +#include "Subscription.h" +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionManager : public Command + { + + public: + SubscriptionManager(); + + int add(Subscription &subscription); + int add(Subscription &subscription, std::string handler); + int addHandler(std::string name, SubscriptionHandler *handler); + + int removeSessionSubscriptions(TCPSession &session); + + int processCommand(coreutils::ZString &request, TCPSession &session) override; + + private: + Subscription *subscription; + std::map subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/Subscription_20221013190812.h b/.history/Subscription_20221013190812.h new file mode 100644 index 0000000..e995db7 --- /dev/null +++ b/.history/Subscription_20221013190812.h @@ -0,0 +1,46 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR"); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221013190943.cpp b/.history/Subscription_20221013190943.cpp new file mode 100644 index 0000000..6fa4cd0 --- /dev/null +++ b/.history/Subscription_20221013190943.cpp @@ -0,0 +1,75 @@ +#include "Subscription.h" +#include "TCPSession.h" +#include "Log.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if(handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void setHandler(SubscriptionHandler *handler) { + this->handler = handler; + } + +} diff --git a/.history/Subscription_20221013204658.h b/.history/Subscription_20221013204658.h new file mode 100644 index 0000000..e2c4d84 --- /dev/null +++ b/.history/Subscription_20221013204658.h @@ -0,0 +1,47 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR"); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221013204725.cpp b/.history/Subscription_20221013204725.cpp new file mode 100644 index 0000000..3f683db --- /dev/null +++ b/.history/Subscription_20221013204725.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void setHandler(SubscriptionHandler *handler) + { + this->handler = handler; + } + +} diff --git a/.history/Subscription_20221013204753.cpp b/.history/Subscription_20221013204753.cpp new file mode 100644 index 0000000..3f683db --- /dev/null +++ b/.history/Subscription_20221013204753.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void setHandler(SubscriptionHandler *handler) + { + this->handler = handler; + } + +} diff --git a/.history/Subscription_20221013205054.cpp b/.history/Subscription_20221013205054.cpp new file mode 100644 index 0000000..2fe2d13 --- /dev/null +++ b/.history/Subscription_20221013205054.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221014003150.h b/.history/Subscription_20221014003150.h new file mode 100644 index 0000000..e2c4d84 --- /dev/null +++ b/.history/Subscription_20221014003150.h @@ -0,0 +1,47 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR"); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014212452.h b/.history/Subscription_20221014212452.h new file mode 100644 index 0000000..6f8ef82 --- /dev/null +++ b/.history/Subscription_20221014212452.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014212457.h b/.history/Subscription_20221014212457.h new file mode 100644 index 0000000..d55b0e7 --- /dev/null +++ b/.history/Subscription_20221014212457.h @@ -0,0 +1,47 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014212653.h b/.history/Subscription_20221014212653.h new file mode 100644 index 0000000..c5ef04a --- /dev/null +++ b/.history/Subscription_20221014212653.h @@ -0,0 +1,48 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014220951.cpp b/.history/Subscription_20221014220951.cpp new file mode 100644 index 0000000..6a1cb7b --- /dev/null +++ b/.history/Subscription_20221014220951.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handler) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015131611.cpp b/.history/Subscription_20221015131611.cpp new file mode 100644 index 0000000..6a1cb7b --- /dev/null +++ b/.history/Subscription_20221015131611.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handler) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015142023.cpp b/.history/Subscription_20221015142023.cpp new file mode 100644 index 0000000..640cd6b --- /dev/null +++ b/.history/Subscription_20221015142023.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handler) + : id(id), mode(mode), owner(&session) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015175629.cpp b/.history/Subscription_20221015175629.cpp new file mode 100644 index 0000000..640cd6b --- /dev/null +++ b/.history/Subscription_20221015175629.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handler) + : id(id), mode(mode), owner(&session) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182553.h b/.history/Subscription_20221015182553.h new file mode 100644 index 0000000..7f0398f --- /dev/null +++ b/.history/Subscription_20221015182553.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015182613.h b/.history/Subscription_20221015182613.h new file mode 100644 index 0000000..0d98e5e --- /dev/null +++ b/.history/Subscription_20221015182613.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handler; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015182633.cpp b/.history/Subscription_20221015182633.cpp new file mode 100644 index 0000000..3c1199a --- /dev/null +++ b/.history/Subscription_20221015182633.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handler) + : id(id), mode(mode), owner(&session), handler(handler) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182644.cpp b/.history/Subscription_20221015182644.cpp new file mode 100644 index 0000000..fc07da5 --- /dev/null +++ b/.history/Subscription_20221015182644.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handler(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182655.h b/.history/Subscription_20221015182655.h new file mode 100644 index 0000000..53fd588 --- /dev/null +++ b/.history/Subscription_20221015182655.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015182706.cpp b/.history/Subscription_20221015182706.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015182706.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182712.cpp b/.history/Subscription_20221015182712.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015182712.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203632.h b/.history/Subscription_20221015203632.h new file mode 100644 index 0000000..b9340b2 --- /dev/null +++ b/.history/Subscription_20221015203632.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler &handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015203643.cpp b/.history/Subscription_20221015203643.cpp new file mode 100644 index 0000000..ac861a6 --- /dev/null +++ b/.history/Subscription_20221015203643.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler.process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203655.cpp b/.history/Subscription_20221015203655.cpp new file mode 100644 index 0000000..73d9ad2 --- /dev/null +++ b/.history/Subscription_20221015203655.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (&handler) + handler.process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203702.cpp b/.history/Subscription_20221015203702.cpp new file mode 100644 index 0000000..73d9ad2 --- /dev/null +++ b/.history/Subscription_20221015203702.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (&handler) + handler.process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203734.h b/.history/Subscription_20221015203734.h new file mode 100644 index 0000000..53fd588 --- /dev/null +++ b/.history/Subscription_20221015203734.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015203735.cpp b/.history/Subscription_20221015203735.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015203735.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203805.cpp b/.history/Subscription_20221015203805.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015203805.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015204939.cpp b/.history/Subscription_20221015204939.cpp new file mode 100644 index 0000000..dde1003 --- /dev/null +++ b/.history/Subscription_20221015204939.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (!handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221016151339.cpp b/.history/Subscription_20221016151339.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221016151339.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221016162014.cpp b/.history/Subscription_20221016162014.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221016162014.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221016172637.cpp b/.history/Subscription_20221016172637.cpp new file mode 100644 index 0000000..0040988 --- /dev/null +++ b/.history/Subscription_20221016172637.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler" << handler; + } +} diff --git a/.history/Subscription_20221016172643.cpp b/.history/Subscription_20221016172643.cpp new file mode 100644 index 0000000..0040988 --- /dev/null +++ b/.history/Subscription_20221016172643.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler" << handler; + } +} diff --git a/.history/Subscription_20221016173312.cpp b/.history/Subscription_20221016173312.cpp new file mode 100644 index 0000000..ee6d5ea --- /dev/null +++ b/.history/Subscription_20221016173312.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler"; + } +} diff --git a/.history/Subscription_20221016173458.cpp b/.history/Subscription_20221016173458.cpp new file mode 100644 index 0000000..b843257 --- /dev/null +++ b/.history/Subscription_20221016173458.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + // handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler"; + } +} diff --git a/.history/Subscription_20221016173903.cpp b/.history/Subscription_20221016173903.cpp new file mode 100644 index 0000000..ee6d5ea --- /dev/null +++ b/.history/Subscription_20221016173903.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler"; + } +} diff --git a/.history/Subscription_20221016174406.cpp b/.history/Subscription_20221016174406.cpp new file mode 100644 index 0000000..0040988 --- /dev/null +++ b/.history/Subscription_20221016174406.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler" << handler; + } +} diff --git a/.history/Subscription_20221016174556.cpp b/.history/Subscription_20221016174556.cpp new file mode 100644 index 0000000..d62d2b5 --- /dev/null +++ b/.history/Subscription_20221016174556.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174634.cpp b/.history/Subscription_20221016174634.cpp new file mode 100644 index 0000000..6b2e0b2 --- /dev/null +++ b/.history/Subscription_20221016174634.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174652.cpp b/.history/Subscription_20221016174652.cpp new file mode 100644 index 0000000..ce23872 --- /dev/null +++ b/.history/Subscription_20221016174652.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = &handler; + } +} diff --git a/.history/Subscription_20221016174712.cpp b/.history/Subscription_20221016174712.cpp new file mode 100644 index 0000000..6b2e0b2 --- /dev/null +++ b/.history/Subscription_20221016174712.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174852.h b/.history/Subscription_20221016174852.h new file mode 100644 index 0000000..6010ad0 --- /dev/null +++ b/.history/Subscription_20221016174852.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler *handlers; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221016174910.h b/.history/Subscription_20221016174910.h new file mode 100644 index 0000000..53fd588 --- /dev/null +++ b/.history/Subscription_20221016174910.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handler); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221016174913.h b/.history/Subscription_20221016174913.h new file mode 100644 index 0000000..b9e448b --- /dev/null +++ b/.history/Subscription_20221016174913.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + virtual ~Subscription(); + + int subscribe(TCPSession &session); + int unsubscribe(TCPSession &session); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + int event(std::stringstream &out); + + bool ifSubscriber(TCPSession &session); + + void setHandler(SubscriptionHandler *handlers); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221016174921.cpp b/.history/Subscription_20221016174921.cpp new file mode 100644 index 0000000..e18853c --- /dev/null +++ b/.history/Subscription_20221016174921.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174923.cpp b/.history/Subscription_20221016174923.cpp new file mode 100644 index 0000000..21c5b39 --- /dev/null +++ b/.history/Subscription_20221016174923.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + } +} diff --git a/.history/Subscription_20221016175152.cpp b/.history/Subscription_20221016175152.cpp new file mode 100644 index 0000000..9f30eaf --- /dev/null +++ b/.history/Subscription_20221016175152.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.history/Subscription_20221016175838.cpp b/.history/Subscription_20221016175838.cpp new file mode 100644 index 0000000..33256cc --- /dev/null +++ b/.history/Subscription_20221016175838.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.history/Subscription_20221016175855.cpp b/.history/Subscription_20221016175855.cpp new file mode 100644 index 0000000..6271e2e --- /dev/null +++ b/.history/Subscription_20221016175855.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + return handler; + } +} diff --git a/.history/Subscription_20221016175911.cpp b/.history/Subscription_20221016175911.cpp new file mode 100644 index 0000000..33256cc --- /dev/null +++ b/.history/Subscription_20221016175911.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.history/Subscription_20221016175912.cpp b/.history/Subscription_20221016175912.cpp new file mode 100644 index 0000000..33256cc --- /dev/null +++ b/.history/Subscription_20221016175912.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +namespace core +{ + + Subscription::Subscription(std::string id, std::string mode) + : id(id), mode(mode), owner(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) + : id(id), mode(mode), owner(&session) {} + + Subscription::~Subscription() + { + std::stringstream out; + out << "cancel:" << id << std::endl; + for (auto subscriber : subscribers) + { + subscriber->write(out.str()); + } + } + + int Subscription::subscribe(TCPSession &session) + { + onSubscribe(session); + subscribers.push_back(&session); + return 1; + } + + int Subscription::unsubscribe(TCPSession &session) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + { + if (*subscriber == &session) + { + subscribers.erase(subscriber++); + return 1; + } + } + return 0; + } + + int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) + { + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; + return 1; + } + + int Subscription::event(std::stringstream &out) + { + for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber) + (*subscriber)->write(out.str()); + return 1; + } + + bool Subscription::ifSubscriber(TCPSession &session) + { + return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end()); + } + + int Subscription::onSubscribe(TCPSession &session) + { + return 0; + } + + void Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/Subscription.cpp b/Subscription.cpp index ce40556..f37a6d5 100644 --- a/Subscription.cpp +++ b/Subscription.cpp @@ -1,16 +1,19 @@ #include "Subscription.h" -#include "TCPSession.h" #include "Log.h" +#include "TCPSession.h" #include namespace core { Subscription::Subscription(std::string id, std::string mode) - : id(id), mode(mode), owner(NULL) {} - + : id(id), mode(mode), owner(NULL), handler(NULL) {} + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) - : id(id), mode(mode), owner(&session) {} + : id(id), mode(mode), owner(&session), handler(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler) + : id(id), mode(mode), owner(&session), handler(handler) {} Subscription::~Subscription() { @@ -24,7 +27,11 @@ namespace core int Subscription::subscribe(TCPSession &session) { - onSubscribe(session); + if(handler) + handler->onSubscribe(session); + else + onSubscribe(session); + subscribers.push_back(&session); return 1; } @@ -44,7 +51,11 @@ namespace core int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) { - out << "event:" << request[1] << ":" << request[2] << std::endl; + std::cout << "(" << handler << ")" << std::endl; + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; return 1; } @@ -65,4 +76,10 @@ namespace core return 0; } +// void Subscription::setHandler(SubscriptionHandler *handlers) +// { +// handler = handlers; + +// coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; +// } } diff --git a/Subscription.h b/Subscription.h index 371b6c4..b62e342 100644 --- a/Subscription.h +++ b/Subscription.h @@ -1,9 +1,10 @@ #ifndef __Subscription_h__ #define __Subscription_h__ +#include "SubscriptionHandler.h" #include "ZString.h" -#include #include +#include namespace core { @@ -15,7 +16,8 @@ namespace core public: Subscription(std::string id, std::string mode = "*AUTHOR"); - Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler); virtual ~Subscription(); int subscribe(TCPSession &session); @@ -29,12 +31,16 @@ namespace core bool ifSubscriber(TCPSession &session); +// void setHandler(SubscriptionHandler *handlers); + // int processCommand(coreutils::ZString &request, TCPSession &session) override; std::string id; std::string mode; TCPSession *owner; + SubscriptionHandler *handler; + std::vector subscribers; }; } diff --git a/SubscriptionHandler.h b/SubscriptionHandler.h new file mode 100644 index 0000000..786faf6 --- /dev/null +++ b/SubscriptionHandler.h @@ -0,0 +1,25 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class TCPSession; + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) { return 0; } + + virtual int onSubscribe(TCPSession &session) { return 0; } + + }; +} + +#endif diff --git a/SubscriptionManager.cpp b/SubscriptionManager.cpp index 44c2468..29e1af0 100644 --- a/SubscriptionManager.cpp +++ b/SubscriptionManager.cpp @@ -1,85 +1,123 @@ #include "SubscriptionManager.h" #include "Log.h" +#include "Subscription.h" #include -namespace core { +namespace core +{ SubscriptionManager::SubscriptionManager() {} - - int SubscriptionManager::add(Subscription &subscription) { - lock.lock(); - subscriptions.insert(std::make_pair(subscription.id, &subscription)); - lock.unlock(); - return 1; - } - - int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) { + + int SubscriptionManager::add(Subscription &subscription) { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } + + int SubscriptionManager::addHandler(std::string name, SubscriptionHandler *handler) { + lock.lock(); + handlers.insert(std::make_pair(name, handler)); + coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for '" << name << "' (" << handler; + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { int countSubscribed = 0; int countPublished = 0; - lock.lock(); + lock.lock(); std::string temp = ""; - for(auto [key, subscription] : subscriptions) { - if(temp != "") { + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { subscriptions.erase(temp); temp = ""; } countSubscribed += subscription->unsubscribe(session); - if(subscription->owner == &session) { + if (subscription->owner == &session) + { temp = key; delete subscription; ++countPublished; - } + } } - if(temp != "") { + if (temp != "") + { subscriptions.erase(temp); temp = ""; } coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s)."; coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session."; - lock.unlock(); + lock.unlock(); return countSubscribed; } - int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) { - if(request[0].equals("publish")) { - Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str()); + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + SubscriptionHandler *handler = handlers[request[3].str()]; + newSubscription = new Subscription(request[1].str(), session, request[2].str(), handler); + subscriptions.insert(std::make_pair(request[1].str(), newSubscription)); - return 1; - } else if(request[0].equals("catalog")) { - session.out << ":catalog:"; - for(auto const& [key, subscription] : subscriptions) { - session.out << subscription->id << ";"; + return 1; + } + + else if (request[0].equals("catalog")) + { + session.out << ":catalog:"; + for (auto const &[key, subscription] : subscriptions) + { + session.out << subscription->id << ";"; } - session.out << std::endl; - return 1; + session.out << std::endl; + return 1; } auto subscription = subscriptions[request[1].str()]; - if(request[1].equals(subscription->id)) { - if(request[0].equals("unpublish")) { - subscriptions.erase(request[1].str()); - } else if(request[0].equals("subscribe")) { - subscription->subscribe(session); + if (request[1].equals(subscription->id)) + { + if (request[0].equals("unpublish")) + { + subscriptions.erase(request[1].str()); + } + else if (request[0].equals("subscribe")) + { + subscription->subscribe(session); return 1; - } else if(request[0].equals("unsubscribe")) { - subscription->unsubscribe(session); + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); return 1; - } else if(request[0].equals("event")) { + } + else if (request[0].equals("event")) + { std::stringstream out; subscription->process(request, out, session); - if(subscription->mode == "*ANYONE") { - subscription->event(out); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); return 1; - } else if(subscription->mode == "*SUBSCRIBERS") { - if(subscription->ifSubscriber(session)) { - subscription->event(out); + } + else if (subscription->mode == "*SUBSCRIBERS") + { + if (subscription->ifSubscriber(session)) + { + subscription->event(out); return 1; } - } else if(subscription->mode == "*AUTHOR") { - if(subscription->owner == &session) { - subscription->event(out); + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); return 1; } } @@ -88,5 +126,4 @@ namespace core { } return 0; } - } diff --git a/SubscriptionManager.h b/SubscriptionManager.h index 6fa042a..38226e7 100644 --- a/SubscriptionManager.h +++ b/SubscriptionManager.h @@ -1,31 +1,36 @@ #ifndef __SubscriptionManager_h__ #define __SubscriptionManager_h__ -#include "TCPSession.h" -#include "Subscription.h" #include "Command.h" +#include "Subscription.h" +#include "SubscriptionHandler.h" +#include "TCPSession.h" #include "ZString.h" -#include #include +#include namespace core { - + class SubscriptionManager : public Command { - + public: SubscriptionManager(); - - int add(Subscription &subscription); - + + int add(Subscription &subscription); + int addHandler(std::string name, SubscriptionHandler *handler); + int removeSessionSubscriptions(TCPSession &session); - + int processCommand(coreutils::ZString &request, TCPSession &session) override; - + private: + Subscription *subscription; std::map subscriptions; - std::mutex lock; - + std::map handlers; + Subscription *newSubscription; + std::mutex lock; }; + } #endif