Backend template

backends/CMakeLists.txt

@@ -9,6 +9,8 @@ if (PROTOBUF_FOUND)
 
 	ADD_SUBDIRECTORY(smstools3)
 
+	ADD_SUBDIRECTORY(template)
+
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(frotz)
 	if (${LIBDBUSGLIB_FOUND})

backends/template/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 2.6)
+
+FILE(GLOB SRC *.c *.cpp)
+
+ADD_EXECUTABLE(spectrum2_template_backend ${SRC})
+
+target_link_libraries(spectrum2_template_backend transport pthread ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})
+
+#INSTALL(TARGETS spectrum2_template_backend RUNTIME DESTINATION bin)
+

backends/template/README

@@ -0,0 +1 @@
+This is just template for creating new generic spectrum2 backends. It does not do anything!

backends/template/main.cpp

@@ -0,0 +1,181 @@
+// Transport includes
+#include "transport/config.h"
+#include "transport/networkplugin.h"
+
+// Swiften
+#include "Swiften/Swiften.h"
+
+// for signal handler
+#include "unistd.h"
+#include "signal.h"
+#include "sys/wait.h"
+#include "sys/signal.h"
+
+// Log4cxx
+#include "log4cxx/logger.h"
+#include "log4cxx/consoleappender.h"
+#include "log4cxx/patternlayout.h"
+#include "log4cxx/propertyconfigurator.h"
+#include "log4cxx/helpers/properties.h"
+#include "log4cxx/helpers/fileinputstream.h"
+#include "log4cxx/helpers/transcoder.h"
+
+// Boost
+#include <boost/algorithm/string.hpp>
+using namespace boost::filesystem;
+using namespace boost::program_options;
+using namespace Transport;
+
+// log4cxx main logger
+using namespace log4cxx;
+static LoggerPtr logger = log4cxx::Logger::getLogger("Backend Template");
+
+// eventloop
+Swift::SimpleEventLoop *loop_;
+
+// Plugin
+class TemplatePlugin;
+TemplatePlugin * np = NULL;
+
+class TemplatePlugin : public NetworkPlugin {
+	public:
+		Swift::BoostNetworkFactories *m_factories;
+		Swift::BoostIOServiceThread m_boostIOServiceThread;
+		boost::shared_ptr<Swift::Connection> m_conn;
+
+		TemplatePlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
+			this->config = config;
+			m_factories = new Swift::BoostNetworkFactories(loop);
+			m_conn = m_factories->getConnectionFactory()->createConnection();
+			m_conn->onDataRead.connect(boost::bind(&TemplatePlugin::_handleDataRead, this, _1));
+			m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
+
+			LOG4CXX_INFO(logger, "Starting the plugin.");
+		}
+
+		// NetworkPlugin uses this method to send the data to networkplugin server
+		void sendData(const std::string &string) {
+			m_conn->write(Swift::createSafeByteArray(string));
+		}
+
+		// This method has to call handleDataRead with all received data from network plugin server
+		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {
+			std::string d(data->begin(), data->end());
+			handleDataRead(d);
+		}
+
+		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
+			handleConnected(user);
+		}
+
+		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
+		}
+
+		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "") {
+			LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");
+		}
+
+		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
+			LOG4CXX_INFO(logger, user << ": Added buddy " << buddyName << ".");
+			handleBuddyChanged(user, buddyName, alias, groups, pbnetwork::STATUS_ONLINE);
+		}
+
+		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
+
+		}
+
+	private:
+		Config *config;
+};
+
+static void spectrum_sigchld_handler(int sig)
+{
+	int status;
+	pid_t pid;
+
+	do {
+		pid = waitpid(-1, &status, WNOHANG);
+	} while (pid != 0 && pid != (pid_t)-1);
+
+	if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
+		char errmsg[BUFSIZ];
+		snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
+		perror(errmsg);
+	}
+}
+
+
+int main (int argc, char* argv[]) {
+	std::string host;
+	int port;
+
+	if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
+		std::cout << "SIGCHLD handler can't be set\n";
+		return -1;
+	}
+
+	boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
+	desc.add_options()
+		("host,h", value<std::string>(&host), "host")
+		("port,p", value<int>(&port), "port")
+		;
+	try
+	{
+		boost::program_options::variables_map vm;
+		boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
+		boost::program_options::notify(vm);
+	}
+	catch (std::runtime_error& e)
+	{
+		std::cout << desc << "\n";
+		exit(1);
+	}
+	catch (...)
+	{
+		std::cout << desc << "\n";
+		exit(1);
+	}
+
+
+	if (argc < 5) {
+		return 1;
+	}
+
+	Config config;
+	if (!config.load(argv[5])) {
+		std::cerr << "Can't open " << argv[1] << " configuration file.\n";
+		return 1;
+	}
+
+	if (CONFIG_STRING(&config, "logging.backend_config").empty()) {
+		LoggerPtr root = log4cxx::Logger::getRootLogger();
+#ifndef _MSC_VER
+		root->addAppender(new ConsoleAppender(new PatternLayout("%d %-5p %c: %m%n")));
+#else
+		root->addAppender(new ConsoleAppender(new PatternLayout(L"%d %-5p %c: %m%n")));
+#endif
+	}
+	else {
+		log4cxx::helpers::Properties p;
+		log4cxx::helpers::FileInputStream *istream = new log4cxx::helpers::FileInputStream(CONFIG_STRING(&config, "logging.backend_config"));
+		p.load(istream);
+		LogString pid, jid;
+		log4cxx::helpers::Transcoder::decode(boost::lexical_cast<std::string>(getpid()), pid);
+		log4cxx::helpers::Transcoder::decode(CONFIG_STRING(&config, "service.jid"), jid);
+#ifdef _MSC_VER
+		p.setProperty(L"pid", pid);
+		p.setProperty(L"jid", jid);
+#else
+		p.setProperty("pid", pid);
+		p.setProperty("jid", jid);
+#endif
+		log4cxx::PropertyConfigurator::configure(p);
+	}
+
+	Swift::SimpleEventLoop eventLoop;
+	loop_ = &eventLoop;
+	np = new TemplatePlugin(&config, &eventLoop, host, port);
+	loop_->run();
+
+	return 0;
+}