From bdc8c69915de41b00463f786081610764492ef7c Mon Sep 17 00:00:00 2001 From: "Aggin!2.0" Date: Sun, 24 Feb 2008 16:19:19 +0100 Subject: [PATCH] initial commit --- client_main.cpp | 21 ++++++++ server_main.cpp | 25 +++++++++ src/client/client.cpp | 63 +++++++++++++++++++++++ src/client/client.hpp | 32 ++++++++++++ src/client/session.hpp | 31 ++++++++++++ src/command.cpp | 20 ++++++++ src/command.hpp | 52 +++++++++++++++++++ src/command_connection.cpp | 12 +++++ src/command_connection.hpp | 22 ++++++++ src/connection.cpp | 17 +++++++ src/connection.hpp | 26 ++++++++++ src/core_module.cpp | 8 +++ src/core_module.hpp | 33 ++++++++++++ src/data.cpp | 14 ++++++ src/data.hpp | 19 +++++++ src/data_connection.cpp | 14 ++++++ src/data_connection.hpp | 29 +++++++++++ src/data_connection_container.cpp | 7 +++ src/data_connection_container.hpp | 18 +++++++ src/log.cpp | 19 +++++++ src/log.hpp | 20 ++++++++ src/module_base.cpp | 8 +++ src/module_base.hpp | 24 +++++++++ src/module_container.cpp | 8 +++ src/module_container.hpp | 63 +++++++++++++++++++++++ src/param_vector.hpp | 26 ++++++++++ src/server/server.cpp | 47 +++++++++++++++++ src/server/server.hpp | 32 ++++++++++++ src/server/session.hpp | 32 ++++++++++++ src/session_base.cpp | 25 +++++++++ src/session_base.hpp | 34 +++++++++++++ src/session_container.cpp | 21 ++++++++ src/session_container.hpp | 26 ++++++++++ src/session_id.cpp | 8 +++ src/session_id.hpp | 24 +++++++++ src/socket.cpp | 87 ++++++++++++++++++++++++++++++++ src/socket.hpp | 103 ++++++++++++++++++++++++++++++++++++++ test_main.cpp | 60 ++++++++++++++++++++++ 38 files changed, 1130 insertions(+) create mode 100755 client_main.cpp create mode 100755 server_main.cpp create mode 100755 src/client/client.cpp create mode 100755 src/client/client.hpp create mode 100755 src/client/session.hpp create mode 100755 src/command.cpp create mode 100755 src/command.hpp create mode 100755 src/command_connection.cpp create mode 100755 src/command_connection.hpp create mode 100755 src/connection.cpp create mode 100755 src/connection.hpp create mode 100755 src/core_module.cpp create mode 100755 src/core_module.hpp create mode 100755 src/data.cpp create mode 100755 src/data.hpp create mode 100755 src/data_connection.cpp create mode 100755 src/data_connection.hpp create mode 100755 src/data_connection_container.cpp create mode 100755 src/data_connection_container.hpp create mode 100755 src/log.cpp create mode 100755 src/log.hpp create mode 100755 src/module_base.cpp create mode 100755 src/module_base.hpp create mode 100755 src/module_container.cpp create mode 100755 src/module_container.hpp create mode 100755 src/param_vector.hpp create mode 100755 src/server/server.cpp create mode 100755 src/server/server.hpp create mode 100755 src/server/session.hpp create mode 100755 src/session_base.cpp create mode 100755 src/session_base.hpp create mode 100755 src/session_container.cpp create mode 100755 src/session_container.hpp create mode 100755 src/session_id.cpp create mode 100755 src/session_id.hpp create mode 100755 src/socket.cpp create mode 100755 src/socket.hpp create mode 100755 test_main.cpp diff --git a/client_main.cpp b/client_main.cpp new file mode 100755 index 0000000..0378ec0 --- /dev/null +++ b/client_main.cpp @@ -0,0 +1,21 @@ +#include +#include +#include "src/client/client.hpp" +#include "src/log.hpp" + +using namespace std; +using namespace raggin::client; + + +int main() +try +{ + init_log(); + client client(1337); + cin.get(); +} +catch(exception& ex) +{ + cerr << ex.what() << endl; + cin.get(); +} \ No newline at end of file diff --git a/server_main.cpp b/server_main.cpp new file mode 100755 index 0000000..7dd80f0 --- /dev/null +++ b/server_main.cpp @@ -0,0 +1,25 @@ +#include +#include +#include "src/server/server.hpp" +#include "src/log.hpp" + +using namespace std; + + +int main() +try +{ + using namespace raggin::server; + + init_log(); + + server srv("127.0.0.1", 1337); + srv.run(); + + cin.get(); +} +catch(exception& ex) +{ + cerr << ex.what() << endl; + cin.get(); +} \ No newline at end of file diff --git a/src/client/client.cpp b/src/client/client.cpp new file mode 100755 index 0000000..5f1458a --- /dev/null +++ b/src/client/client.cpp @@ -0,0 +1,63 @@ +#include "client.hpp" +#include "session.hpp" +#include "../log.hpp" +#include "../session_id.hpp" +#include "../session_base.hpp" +#include "../connection.hpp" +#include +#include +#include + +using namespace std; +using namespace boost; + + +raggin::client::client::client(uint16_t accept_port) + :accept_port_(accept_port) +{ + async_accept(); + thread t(boost::bind(&asio::io_service::run, &io_service_)); +} + +void raggin::client::client::async_accept() +{ + connection_ptr conn_ptr(new connection(io_service_)); + conn_ptr->socket()->async_accept(accept_port_, + bind(&client::handle_async_accept, this, _1, conn_ptr)); +} + +void raggin::client::client::handle_async_accept(const boost::system::error_code& error, connection_ptr conn_ptr) +{ + if(!error) + { + /** receive session_id from other side + */ + vector inbound_buf(36); + conn_ptr->socket()->receive(asio::buffer(inbound_buf)); + session_id session_id(inbound_buf.begin(), inbound_buf.end()); + + /** if there is already a session with that session_id, + * add the connection as a data-connection, + * otherwise create new session + */ + session_base_ptr existing_session = sessions_.get(session_id); + if(existing_session) + { + data_connection_ptr data_conn(new data_connection(*conn_ptr, existing_session->cmd_conn())); + existing_session->data_conns()->insert(data_conn); + } + else + { + //command_connection_ptr cmd_conn_ptr(new command_connection(conn_ptr)); + session_ptr new_session(new session(command_connection(*conn_ptr))); + sessions_.insert(new_session); + LOG << "Server accepted."; + } + + async_accept(); + } + else + { + LOG << "client.handle_async_accept: " << error.message(); + } +} \ No newline at end of file diff --git a/src/client/client.hpp b/src/client/client.hpp new file mode 100755 index 0000000..e468025 --- /dev/null +++ b/src/client/client.hpp @@ -0,0 +1,32 @@ +#ifndef client_hpp_INCLUDED +#define client_hpp_INCLUDED + +#include +#include +#include "../socket.hpp" +#include "../session_container.hpp" + + +namespace raggin +{ + namespace client + { + class client + { + boost::asio::io_service io_service_; + boost::uint16_t accept_port_; + session_container sessions_; + + void async_accept(); + void handle_async_accept(const boost::system::error_code& error, connection_ptr conn_ptr); + + public: + /** Constructor. + * @param port the port on which to listen for new connections + */ + client(boost::uint16_t port); + }; + } +} + +#endif \ No newline at end of file diff --git a/src/client/session.hpp b/src/client/session.hpp new file mode 100755 index 0000000..d207e38 --- /dev/null +++ b/src/client/session.hpp @@ -0,0 +1,31 @@ +#ifndef session_hpp_INCLUDED +#define session_hpp_INCLUDED + +#include +#include +#include "../command_connection.hpp" +#include "../session_base.hpp" + + +namespace raggin +{ + namespace client + { + class session : public session_base + { + public: + session(command_connection& cmd_conn) + :session_base(cmd_conn) + { + } + + virtual void start() + { + } + }; + + typedef boost::shared_ptr session_ptr; + } +} + +#endif \ No newline at end of file diff --git a/src/command.cpp b/src/command.cpp new file mode 100755 index 0000000..f5586cd --- /dev/null +++ b/src/command.cpp @@ -0,0 +1,20 @@ +#include "command.hpp" + +using namespace std; + + +raggin::command::command() + :name_("NoCommand") +{ +} + +raggin::command::command(string cmd_name) + :name_(cmd_name) +{ +} + +raggin::command::command(string cmd_name, param_vector params) + :name_(cmd_name) + ,params_(params) +{ +} diff --git a/src/command.hpp b/src/command.hpp new file mode 100755 index 0000000..5d48518 --- /dev/null +++ b/src/command.hpp @@ -0,0 +1,52 @@ +#ifndef command_hpp_INCLUDED +#define command_hpp_INCLUDED + +#include +#include "param_vector.hpp" + + +namespace raggin +{ + class command + { + public: + /** DefaultKonstruktor. + */ + command(); + + /** Konstruktor. + * @param cmdName Der Name des Commands. + */ + command(std::string cmd_name); + + /** Konstruktor. + * @param cmdName Der Name des Commands. + * @param params Die Parameter des Commands. + */ + command(std::string cmd_name, param_vector params); + + /** Gibt einen Parameter zurueck. + * @param index Index des Parameters. + */ + template + T & get_param(int index) + { + return boost::get(params_.at(index)); + } + + /** Fuegt einen Parameter hinzu. + * @param newParam Objekt, dass als Parameter hinzugefuegt werden soll. + */ + template + void add_param(const T & param) + { + params_.push_back(param); + } + + private: + std::string name_; + param_vector params_; + }; +} + +#endif \ No newline at end of file diff --git a/src/command_connection.cpp b/src/command_connection.cpp new file mode 100755 index 0000000..4dd5d7c --- /dev/null +++ b/src/command_connection.cpp @@ -0,0 +1,12 @@ +#include "command_connection.hpp" + + +raggin::command_connection::command_connection( boost::asio::io_service& io_service ) + :connection(io_service) +{ +} + +raggin::command_connection::command_connection( connection& conn ) + :connection(conn) +{ +} \ No newline at end of file diff --git a/src/command_connection.hpp b/src/command_connection.hpp new file mode 100755 index 0000000..683f05f --- /dev/null +++ b/src/command_connection.hpp @@ -0,0 +1,22 @@ +#ifndef command_connection_hpp_INCLUDED +#define command_connection_hpp_INCLUDED + +#include +#include +#include "connection.hpp" + + +namespace raggin +{ + class command_connection : public connection + { + public: + explicit command_connection(boost::asio::io_service& io_service); + + command_connection(connection& conn); + }; + + typedef boost::shared_ptr command_connection_ptr; +} + +#endif \ No newline at end of file diff --git a/src/connection.cpp b/src/connection.cpp new file mode 100755 index 0000000..78dc247 --- /dev/null +++ b/src/connection.cpp @@ -0,0 +1,17 @@ +#include "connection.hpp" + + +raggin::connection::connection( boost::asio::io_service& io_service ) + :socket_ptr_(new raggin::socket(io_service)) +{ +} + +// raggin::connection::connection( socket_ptr socket_ptr ) +// :socket_ptr_(socket_ptr) +// { +// } + +raggin::socket_ptr raggin::connection::socket() +{ + return socket_ptr_; +} diff --git a/src/connection.hpp b/src/connection.hpp new file mode 100755 index 0000000..9281423 --- /dev/null +++ b/src/connection.hpp @@ -0,0 +1,26 @@ +#ifndef connection_hpp_INCLUDED +#define connection_hpp_INCLUDED + +#include +#include +#include "socket.hpp" + + +namespace raggin +{ + class connection + { + public: + explicit connection(boost::asio::io_service& io_service); + //explicit connection(socket_ptr socket_ptr); + + socket_ptr socket(); + + private: + socket_ptr socket_ptr_; + }; + + typedef boost::shared_ptr connection_ptr; +} + +#endif \ No newline at end of file diff --git a/src/core_module.cpp b/src/core_module.cpp new file mode 100755 index 0000000..68662cc --- /dev/null +++ b/src/core_module.cpp @@ -0,0 +1,8 @@ +#include "core_module.hpp" +#include "session_base.hpp" + + +raggin::core_module::core_module( session_base& _session ) + :module_base(_session) +{ +} \ No newline at end of file diff --git a/src/core_module.hpp b/src/core_module.hpp new file mode 100755 index 0000000..d887904 --- /dev/null +++ b/src/core_module.hpp @@ -0,0 +1,33 @@ +#ifndef core_module_hpp_INCLUDED +#define core_module_hpp_INCLUDED + +#include +#include "module_base.hpp" +#include "param_vector.hpp" + + +namespace raggin +{ + //fwd + class session_base; + + /** Das Hauptmodul. + * Stellt grundlegenes zur Verfuegung und ist seitenunabhaengig. + */ + class core_module : public module_base + { + void log_(const param_vector& params); + void error_(const param_vector& params); + + public: + static const std::string + log, + error; + + core_module(session_base& _session); + + //ModuleManager::ModuleFunctionMap FunctionMap(); + }; +} + +#endif \ No newline at end of file diff --git a/src/data.cpp b/src/data.cpp new file mode 100755 index 0000000..cd27775 --- /dev/null +++ b/src/data.cpp @@ -0,0 +1,14 @@ +#include "data.hpp" + +using namespace std; + + +raggin::data::data() + :command() +{ +} + +raggin::data::data(string cmdName) + :command(cmdName) +{ +} diff --git a/src/data.hpp b/src/data.hpp new file mode 100755 index 0000000..89f7737 --- /dev/null +++ b/src/data.hpp @@ -0,0 +1,19 @@ +#ifndef data_hpp_INCLUDED +#define data_hpp_INCLUDED + +#include +#include +#include "command.hpp" + + +namespace raggin +{ + class data : public command + { + public: + data(); + data(std::string cmd_name); + }; +} + +#endif \ No newline at end of file diff --git a/src/data_connection.cpp b/src/data_connection.cpp new file mode 100755 index 0000000..a9cdd22 --- /dev/null +++ b/src/data_connection.cpp @@ -0,0 +1,14 @@ +#include "data_connection.hpp" + + +raggin::data_connection::data_connection(boost::asio::io_service& io_service, command_connection& cmd_conn) + :connection(io_service) + ,cmd_conn_(cmd_conn) +{ +} + +raggin::data_connection::data_connection(connection& conn, command_connection& cmd_conn) + :connection(conn) + ,cmd_conn_(cmd_conn) +{ +} \ No newline at end of file diff --git a/src/data_connection.hpp b/src/data_connection.hpp new file mode 100755 index 0000000..3d15c69 --- /dev/null +++ b/src/data_connection.hpp @@ -0,0 +1,29 @@ +#ifndef data_connection_hpp_INCLUDED +#define data_connection_hpp_INCLUDED + +#include +#include +#include "connection.hpp" +#include "command_connection.hpp" + + +namespace raggin +{ + class data_connection : public connection + { + public: + data_connection(boost::asio::io_service& io_service, command_connection& cmd_conn); + + /** Constructor. + * @param conn connection which will be used for this data_connection. + */ + data_connection(connection& conn, command_connection& cmd_conn); + + private: + command_connection& cmd_conn_; + }; + + typedef boost::shared_ptr data_connection_ptr; +} + +#endif \ No newline at end of file diff --git a/src/data_connection_container.cpp b/src/data_connection_container.cpp new file mode 100755 index 0000000..72a341b --- /dev/null +++ b/src/data_connection_container.cpp @@ -0,0 +1,7 @@ +#include "data_connection_container.hpp" + + +void raggin::data_connection_container::insert( data_connection_ptr data_conn_ptr ) +{ + push_back(data_conn_ptr); +} \ No newline at end of file diff --git a/src/data_connection_container.hpp b/src/data_connection_container.hpp new file mode 100755 index 0000000..ce68c7d --- /dev/null +++ b/src/data_connection_container.hpp @@ -0,0 +1,18 @@ +#ifndef data_connection_container_hpp_INCLUDED +#define data_connection_container_hpp_INCLUDED + +#include +#include "data_connection.hpp" + +namespace raggin +{ + class data_connection_container : private std::vector + { + public: + void insert(data_connection_ptr dara_conn_ptr); + }; + + typedef boost::shared_ptr data_connection_container_ptr; +} + +#endif \ No newline at end of file diff --git a/src/log.cpp b/src/log.cpp new file mode 100755 index 0000000..db9661a --- /dev/null +++ b/src/log.cpp @@ -0,0 +1,19 @@ +#include "log.hpp" +#include +#include + +using namespace boost::logging; + + +BOOST_DEFINE_LOG_FILTER(g_log_filter, filter::no_ts) +BOOST_DEFINE_LOG(g_l, log_type) + +void init_log() +{ + //g_l->writer().add_formatter( formatter::idx() ); + g_l->writer().add_formatter( formatter::time("[$hh:$mm:$ss] ") ); + g_l->writer().add_formatter( formatter::append_newline() ); + + g_l->writer().add_destination( destination::cout() ); + g_l->writer().add_destination( destination::dbg_window() ); +} \ No newline at end of file diff --git a/src/log.hpp b/src/log.hpp new file mode 100755 index 0000000..0b56ef8 --- /dev/null +++ b/src/log.hpp @@ -0,0 +1,20 @@ +#ifndef log_hpp_INCLUDED +#define log_hpp_INCLUDED + +#include + + +typedef boost::logging::logger_format_write< + boost::logging::default_, + boost::logging::default_, + boost::logging::writer::threading::ts_write +> log_type; + +BOOST_DECLARE_LOG_FILTER(g_log_filter, boost::logging::filter::no_ts ) +BOOST_DECLARE_LOG(g_l, log_type) + +#define LOG BOOST_LOG_USE_LOG_IF_FILTER(g_l, g_log_filter->is_enabled()) + +void init_log(); + +#endif diff --git a/src/module_base.cpp b/src/module_base.cpp new file mode 100755 index 0000000..04e88c2 --- /dev/null +++ b/src/module_base.cpp @@ -0,0 +1,8 @@ +#include "module_base.hpp" +#include "session_base.hpp" + + +raggin::module_base::module_base( session_base& _session ) + :session_(_session) +{ +} \ No newline at end of file diff --git a/src/module_base.hpp b/src/module_base.hpp new file mode 100755 index 0000000..cb69e1a --- /dev/null +++ b/src/module_base.hpp @@ -0,0 +1,24 @@ +#ifndef module_base_hpp_INCLUDED +#define module_base_hpp_INCLUDED + +#include + + +namespace raggin +{ + //fwd + class session_base; + + class module_base + { + public: + module_base(session_base& _session); + + private: + session_base& session_; + }; + + typedef boost::shared_ptr module_base_ptr; +} + +#endif \ No newline at end of file diff --git a/src/module_container.cpp b/src/module_container.cpp new file mode 100755 index 0000000..e50c1cb --- /dev/null +++ b/src/module_container.cpp @@ -0,0 +1,8 @@ +#include "module_container.hpp" +#include "session_base.hpp" + + +raggin::module_container::module_container( session_base& session ) + :session_(session) +{ +} \ No newline at end of file diff --git a/src/module_container.hpp b/src/module_container.hpp new file mode 100755 index 0000000..c8ab816 --- /dev/null +++ b/src/module_container.hpp @@ -0,0 +1,63 @@ +#ifndef module_manager_hpp_INCLUDED +#define module_manager_hpp_INCLUDED + +#include +#include +#include "module_base.hpp" +#include "command.hpp" +#include "data.hpp" + + +namespace raggin +{ + //fwd + class session_base; + + class module_container + { + public: + module_container(session_base& session); + + /** Registers a module. + */ + template + void add(); + + /** Returns registered module with type of ModuleType. + */ + template + boost::shared_ptr get(); + +// void process_cmd(command& cmd); +// void process_data(data& data); + + private: + session_base& session_; + std::vector modules_; + }; +} + +template +void raggin::module_container::add() +{ + BOOST_STATIC_ASSERT((boost::is_convertible::value)); + + module_base_ptr module(new ModuleType(session_)); + modules_.push_back(module); +} + +template +boost::shared_ptr raggin::module_container::get() +{ + BOOST_STATIC_ASSERT((boost::is_convertible::value)); + + typedef std::vector iterator; + iterator itr = std::find_if(modules_.begin(), modules_.end(), + (typeid(*_1) == typeid(ModuleType))); + + if(itr == modules_.end()) + throw runtime_error("Module of type" + typeid(ModuleType).name() + "is not registered.") + +} + +#endif \ No newline at end of file diff --git a/src/param_vector.hpp b/src/param_vector.hpp new file mode 100755 index 0000000..2148c40 --- /dev/null +++ b/src/param_vector.hpp @@ -0,0 +1,26 @@ +#ifndef param_vector_hpp_INCLUDED +#define param_vector_hpp_INCLUDED + +#include +#include +#include + + +namespace raggin +{ + //Anonymer namespace, damit param_types_variant nicht oeffentlich sichtbar ist + namespace + { + typedef boost::variant + < + std::string, + int, + std::vector + > + param_types_variant; + } + + typedef std::vector param_vector; +} + +#endif \ No newline at end of file diff --git a/src/server/server.cpp b/src/server/server.cpp new file mode 100755 index 0000000..68b01e3 --- /dev/null +++ b/src/server/server.cpp @@ -0,0 +1,47 @@ +#include "server.hpp" +#include "../log.hpp" +#include +#include + +using namespace std; +using namespace boost; +using namespace boost::asio; + + +raggin::server::server::server(const string& ip, boost::uint16_t port) + :remote_endpoint_(ip::address::from_string(ip), port) + ,timer_(io_service_) +{ +} + +void raggin::server::server::run() +{ + async_connect(); + io_service_.run(); +} + +void raggin::server::server::async_connect() +{ + LOG << "Connecting.."; + connection_ptr conn_ptr(new connection(io_service_)); + conn_ptr->socket()->async_connect(remote_endpoint_, + bind(&server::handle_async_connect, this, _1, conn_ptr)); +} + +void raggin::server::server::handle_async_connect(const boost::system::error_code& error, connection_ptr conn_ptr) +{ + if(!error) + { + session_ptr_.reset(new session(command_connection(*conn_ptr))); + LOG << "Connection to Client etablished."; + session_ptr_->start(); + //session_ptr->on_disconnected( boost::bind(&server::SessionDisconnectedHandler, this) ); + } + else + { + LOG << error.message() << " (Next attempt in " << connect_interval << " seconds)"; + conn_ptr.reset(); + timer_.expires_from_now(posix_time::seconds(connect_interval)); + timer_.async_wait( boost::bind(&server::async_connect, this) ); + } +} diff --git a/src/server/server.hpp b/src/server/server.hpp new file mode 100755 index 0000000..14bfcf8 --- /dev/null +++ b/src/server/server.hpp @@ -0,0 +1,32 @@ +#ifndef server_hpp_INCLUDED +#define server_hpp_INCLUDED + +#include +#include +#include +#include "session.hpp" + + +namespace raggin +{ + namespace server + { + class server + { + static const int connect_interval = 10; //Sekunden + boost::asio::io_service io_service_; + boost::asio::deadline_timer timer_; + boost::asio::ip::tcp::endpoint remote_endpoint_; //Beinhaltet den Endpoint zum Connecten. + session_ptr session_ptr_; + + void async_connect(); //Zu Client + void handle_async_connect(const boost::system::error_code& error, connection_ptr conn_ptr); + + public: + server(const std::string& ip, boost::uint16_t port); + void run(); + }; + } +} + +#endif diff --git a/src/server/session.hpp b/src/server/session.hpp new file mode 100755 index 0000000..f47abdf --- /dev/null +++ b/src/server/session.hpp @@ -0,0 +1,32 @@ +#ifndef session_hpp_INCLUDED +#define session_hpp_INCLUDED + +#include +#include +#include "../command_connection.hpp" +#include "../session_base.hpp" + + +namespace raggin +{ + namespace server + { + class session : public session_base + { + public: + session(command_connection& cmd_conn) + :session_base(cmd_conn) + { + } + + virtual void start() + { + boost::asio::write(*cmd_conn().socket(), boost::asio::buffer(id())); + } + }; + + typedef boost::shared_ptr session_ptr; + } +} + +#endif \ No newline at end of file diff --git a/src/session_base.cpp b/src/session_base.cpp new file mode 100755 index 0000000..7efcde1 --- /dev/null +++ b/src/session_base.cpp @@ -0,0 +1,25 @@ +#include "session_base.hpp" +#include "core_module.hpp" + + +raggin::session_base::session_base(command_connection& cmd_conn) + :modules_(*this) + ,cmd_conn_(cmd_conn) +{ + modules_.add(); +} + +raggin::command_connection& raggin::session_base::cmd_conn() +{ + return cmd_conn_; +} + +raggin::data_connection_container_ptr raggin::session_base::data_conns() +{ + return data_conns_ptr_; +} + +const raggin::session_id raggin::session_base::id() const +{ + return id_; +} \ No newline at end of file diff --git a/src/session_base.hpp b/src/session_base.hpp new file mode 100755 index 0000000..5fb75d9 --- /dev/null +++ b/src/session_base.hpp @@ -0,0 +1,34 @@ +#ifndef session_base_hpp_INCLUDED +#define session_base_hpp_INCLUDED + +#include +#include +#include "module_container.hpp" +#include "command_connection.hpp" +#include "data_connection_container.hpp" +#include "session_id.hpp" + + +namespace raggin +{ + class session_base + { + module_container modules_; + command_connection& cmd_conn_; + data_connection_container_ptr data_conns_ptr_; + const session_id id_; + + public: + session_base(command_connection& cmd_conn); + + //virtual void start()=0; + + command_connection& cmd_conn(); + data_connection_container_ptr data_conns(); + const session_id id() const; + }; + + typedef boost::shared_ptr session_base_ptr; +} + +#endif \ No newline at end of file diff --git a/src/session_container.cpp b/src/session_container.cpp new file mode 100755 index 0000000..f83b7dd --- /dev/null +++ b/src/session_container.cpp @@ -0,0 +1,21 @@ +#include "session_container.hpp" +#include +#include +#include + +using namespace std; +using namespace boost; + + +void raggin::session_container::insert(session_base_ptr session_ptr) +{ + push_back(session_ptr); +} + +raggin::session_base_ptr raggin::session_container::get(session_id session_id) +{ + iterator itr = std::find_if(begin(), end(), (boost::bind(&session_base::id, _1) == session_id)); + if(itr != end()) + return *itr; + return session_base_ptr(); +} \ No newline at end of file diff --git a/src/session_container.hpp b/src/session_container.hpp new file mode 100755 index 0000000..032fdda --- /dev/null +++ b/src/session_container.hpp @@ -0,0 +1,26 @@ +#ifndef session_container_hpp_INCLUDED +#define session_container_hpp_INCLUDED + +#include +#include "session_base.hpp" +#include "session_id.hpp" + + +namespace raggin +{ + class session_container : private std::vector + { + public: + /** Inserts session_ptr to the container. + */ + void insert(session_base_ptr session_ptr); + + /** + + /** Get session_base_ptr by session_id. + */ + session_base_ptr get(session_id session_id); + }; +} + +#endif \ No newline at end of file diff --git a/src/session_id.cpp b/src/session_id.cpp new file mode 100755 index 0000000..17fb5dd --- /dev/null +++ b/src/session_id.cpp @@ -0,0 +1,8 @@ +#include "session_id.hpp" +#include + + +raggin::session_id::session_id() + :std::string( boost::uuid::create().to_string() ) +{ +} \ No newline at end of file diff --git a/src/session_id.hpp b/src/session_id.hpp new file mode 100755 index 0000000..e8a5c23 --- /dev/null +++ b/src/session_id.hpp @@ -0,0 +1,24 @@ +#ifndef session_id_hpp_INCLUDED +#define session_id_hpp_INCLUDED + +#include + + +namespace raggin +{ + struct session_id : std::string + { + template + session_id(InputIterator begin, InputIterator end); + + session_id(); + }; +} + +template +raggin::session_id::session_id(InputIterator begin, InputIterator end) + :std::string(begin, end) +{ +} + +#endif \ No newline at end of file diff --git a/src/socket.cpp b/src/socket.cpp new file mode 100755 index 0000000..4d573d3 --- /dev/null +++ b/src/socket.cpp @@ -0,0 +1,87 @@ +#include "socket.hpp" +#include "Log.hpp" +#include + +using namespace std; +using namespace boost; +using namespace boost::asio; +using namespace boost::asio::ip; + + +raggin::socket::socket(asio::io_service& io_service) + :tcp::socket(io_service) +{ +} + +raggin::socket::socket(socket_ptr other_socket_ptr) + :tcp::socket(other_socket_ptr->get_io_service(), tcp::v4(), other_socket_ptr->native()) + ,other_socket_ptr_(other_socket_ptr) +{ +} + +raggin::socket::~socket() +{ +} + +void raggin::socket::close() +{ + close(); +} + +void raggin::socket::accept(uint16_t port) +{ + acceptor_ptr_.reset(new tcp::acceptor(get_io_service(), tcp::endpoint(tcp::v4(), port))); + try + { + acceptor_ptr_->accept(static_cast(*this)); + acceptor_ptr_.reset(); + } + catch(...) + { + acceptor_ptr_.reset(); + throw; + } +} + +void raggin::socket::async_accept(uint16_t port, accept_handler handler) +{ + acceptor_ptr_.reset(new tcp::acceptor(get_io_service(), tcp::endpoint(tcp::v4(),port))); + acceptor_ptr_->async_accept(static_cast(*this), + boost::bind(&socket::handle_async_accept, this, _1, handler)); +} + +void raggin::socket::handle_async_accept(const boost::system::error_code& error, accept_handler handler) +{ + LOG << "socket.handle_async_accept: " << (error?"error":"no error"); + acceptor_ptr_.reset(); + handler(error); +} + +void raggin::socket::connect(const string& ip, uint16_t port) +{ + tcp::endpoint endpoint(address().from_string(ip), port); + tcp::socket::connect(endpoint); +} + +void raggin::socket::async_connect(tcp::endpoint endpoint, connect_handler handler) +{ + LOG << "socket.async_connect"; + tcp::socket::async_connect(endpoint, handler); +} + +void raggin::socket::async_connect(const string& ip, uint16_t port, connect_handler handler) +{ + tcp::endpoint endpoint(address::from_string(ip), port); + async_connect(endpoint, handler); +} + + +boost::asio::ip::tcp::endpoint raggin::socket::local_endpoint() const +{ + return tcp::socket::local_endpoint(); +} + +boost::asio::ip::tcp::endpoint raggin::socket::remote_endpoint() const +{ + return tcp::socket::remote_endpoint(); +} \ No newline at end of file diff --git a/src/socket.hpp b/src/socket.hpp new file mode 100755 index 0000000..860529e --- /dev/null +++ b/src/socket.hpp @@ -0,0 +1,103 @@ +#ifndef socket_hpp_INCLUDED +#define socket_hpp_INCLUDED + +#include +#include +#include +#include + + +namespace raggin +{ + class socket; + typedef boost::shared_ptr socket_ptr; + + class socket : public boost::asio::ip::tcp::socket + { + typedef boost::shared_ptr acceptor_ptr; + + /** handler types for the asynchronous socket operations. + */ + typedef boost::function connect_handler; + typedef connect_handler accept_handler; + typedef boost::function send_handler; + typedef connect_handler receive_handler; + + /** Wenn Socket ueber einen einbestehenden Socket_ptr erstellt wird, + * speichern wir den Socket_ptr, damit der Socket am leben bleibt. + */ + socket_ptr other_socket_ptr_; + + acceptor_ptr acceptor_ptr_; + + /** internal accept handler. + * to reset the acceptor_ptr after an accepting operation. + */ + void handle_async_accept(const boost::system::error_code& error, accept_handler handler); + + public: + socket(boost::asio::io_service& io_service); + socket(socket_ptr other_socket_ptr); + virtual ~socket(); + + //boost::asio::io_service& get_io_service(); + + void close(); + + void accept(boost::uint16_t port); + void async_accept(boost::uint16_t port, accept_handler handler); + void connect(const std::string& host, boost::uint16_t port); + void async_connect(boost::asio::ip::tcp::endpoint endpoint, connect_handler handler); + void async_connect(const std::string& ip, boost::uint16_t port, connect_handler handler); + + /** receive. + */ + template + std::size_t receive(const MutableBufferSequence& buffers); + + /** send. + */ + template + std::size_t send(const ConstBufferSequence& buffers); + + /** async_receive. + */ + template + void async_receive(const MutableBufferSequence& buffers, receive_handler handler); + + /** async_send. + */ + template + void async_send(const ConstBufferSequence& buffers, send_handler handler); + + boost::asio::ip::tcp::endpoint local_endpoint() const; + boost::asio::ip::tcp::endpoint remote_endpoint() const; + }; + + + template + std::size_t socket::receive(const MutableBufferSequence& buffers) + { + return boost::asio::read(static_cast(*this), buffers); + } + + template + std::size_t socket::send(const ConstBufferSequence& buffers) + { + return boost::asio::write(static_cast(*this), buffers); + } + + template + void socket::async_receive(const MutableBufferSequence& buffers, receive_handler handler) + { + boost::asio::async_read(static_cast(*this), buffers, handler); + } + + template + void socket::async_send(const ConstBufferSequence& buffers, send_handler handler) + { + boost::asio::async_write(static_cast(*this), buffers, handler); + } +} + +#endif diff --git a/test_main.cpp b/test_main.cpp new file mode 100755 index 0000000..9483809 --- /dev/null +++ b/test_main.cpp @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include +// #include "src/socket.hpp" +#include "src/log.hpp" +// #include "src/session_container.hpp" +// #include "src/server/session.hpp" +#include +#include +#include + +using namespace std; +using namespace boost; +using namespace boost::asio::ip; +//using namespace raggin; + +class Y; +typedef shared_ptr Yptr; + +class Y : public enable_shared_from_this +{ +public: +}; + + + + +int main() +try +{ + init_log(); + + asio::io_service io_service; + + Yptr yp(new Y()); + + Yptr ptr = yp->shared_from_this(); + + /* + asio::io_service io_service; + + raggin::socket socket(io_service); + socket.accept(1337); + socket.send(asio::buffer("test!")); + + vector vecbuf(4); + socket.receive(asio::buffer(vecbuf)); + cout << string(vecbuf.begin(), vecbuf.end()) << endl; + */ + + cin.get(); +} +catch(exception& ex) +{ + cerr << ex.what() << endl; + cin.get(); +} \ No newline at end of file -- 2.11.4.GIT