socket_server_manager_glibc.hpp

Go to the documentation of this file.

#ifndef LIBJMMCG_COER_SERVER_MANAGER_GLIBC_HPP
#define LIBJMMCG_COER_SERVER_MANAGER_GLIBC_HPP
 
/******************************************************************************
** Copyright © 2015 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "socket_wrapper_glibc.hpp"
 
#include <functional>
#include <memory>
 
#ifdef __GCC__
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#  pragma GCC diagnostic ignored "-Wsuggest-final-types"
#endif
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE { namespace socket { namespace server_manager { namespace glibc {
 
/// A simple TCP/IP socket wrapper using socket::server::wrapper for servers.
/**
   \see socket::server::wrapper
*/
template<class LkT>
class manager {
public:
   using acceptor_t=socket::glibc::server::wrapper<LkT>;
   using socket_t=socket::glibc::client::wrapper<LkT>;
   using socket_priority=typename socket_t::socket_priority;
 
   /// A wrapper for a new client connection to the server.
   class session : public std::enable_shared_from_this<session> {
   public:
      using ptr_type=std::shared_ptr<session>;
 
      explicit session(typename socket_t::socket_type accept_socket) noexcept(false)
      : socket_(accept_socket) {
         // Stuff to set once the socket is open...
      }
 
      virtual ~session()=default;
 
      /// For loop-back connections, such as simulators.
      template<class RecvProcMsgs>
      bool process(RecvProcMsgs proc_fn) noexcept(false) {
         return proc_fn(*this, socket_);
      }
 
      /// For forwarding connections, such as the translator.
      template<class RecvProcMsgs>
      bool process(RecvProcMsgs proc_fn, socket_t &dest_socket) noexcept(false) {
         return proc_fn(*this, dest_socket);
      }
 
      virtual void start() {
      }
 
      virtual void stop() {
         socket_.close();
      }
 
      socket_t &socket() noexcept(true) {
         return socket_;
      }
 
      std::string to_string() const noexcept(false);
 
      static ptr_type make(typename socket_t::socket_type accept_socket) noexcept(false) {
         return std::make_shared<typename ptr_type::element_type>(accept_socket);
      }
 
   protected:
      socket_t socket_;
   };
   using server_to_client_flow_t=std::function<void (typename session::ptr_type)>;
 
   /// Create a new connection to the specified TCP socket using the TCP/IP protocol.
   /**
      \param   addr  The IPv4 or IPv6 address to which the connection should be made.
      \param   port_num The port number to which the connection should be made.
   */
   manager(boost::asio::ip::address const &addr, unsigned short port_num, std::size_t min_message_size, std::size_t max_message_size, unsigned short timeout, socket_priority priority, std::size_t incoming_cpu, server_to_client_flow_t &&server_to_client_flow);
 
   /// Blocking wait for a new connection from a client.
   void run();
 
   void stop();
 
   static void set_options(acceptor_t &acceptor, socket_t &skt);
 
   std::string to_string() const noexcept(false);
 
protected:
   acceptor_t acceptor;
   server_to_client_flow_t server_to_client_flow_;
 
   ~manager()=default;
 
   void set_options(socket_t &skt);
};
 
template<class LkT>
inline std::ostream &
operator<<(std::ostream &os, typename manager<LkT>::tcp_connection const &ec) noexcept(false);
 
template<class LkT>
inline std::ostream &
operator<<(std::ostream &os, manager<LkT> const &ec) noexcept(false);
 
/// A simple TCP/IP socket wrapper using boost::asio for loop-back servers.
template<class SvrHBs, class LkT>
class loopback : public manager<LkT> {
public:
   using base_t=manager<LkT>;
   /// Start sending heartbeats upon a connection.
   using heartbeats_t=SvrHBs;
   using socket_t=typename base_t::socket_t;
   using socket_priority=typename base_t::socket_priority;
   using server_to_client_flow_t=typename base_t::server_to_client_flow_t;
   using base_t::base_t;
 
   /**
      \param   dest  The socket to which the received messages should be forwarded after suitable processing.
   */
   loopback(boost::asio::ip::address const &addr, unsigned short port_num, std::size_t min_message_size, std::size_t max_message_size, unsigned short timeout, socket_priority priority, std::size_t incoming_cpu, server_to_client_flow_t &&server_to_client_flow);
 
   /// Non-blocking call to wait for new connections from a client.
   /**
      \param   proc_fn  The operations to perform upon receiving a connection request from a client.
   */
   template<class RecvProcMsgs>
   void start_accept(RecvProcMsgs proc_fn) noexcept(false);
 
private:
   class send_heartbeats;
};
 
/// A simple TCP/IP socket wrapper using a socket wrapper for forwarding servers.
template<class LkT>
class forwarding : public manager<LkT> {
public:
   using base_t=manager<LkT>;
   using socket_t=typename base_t::socket_t;
   using socket_priority=typename base_t::socket_priority;
   using server_to_client_flow_t=typename base_t::server_to_client_flow_t;
 
   /**
      \param   dest  The socket to which the received messages should be forwarded after suitable processing.
   */
   forwarding(boost::asio::ip::address const &addr, unsigned short port_num, std::size_t min_message_size, std::size_t max_message_size, unsigned short timeout, socket_priority priority, std::size_t incoming_cpu, server_to_client_flow_t &&server_to_client_flow, socket_t &dest);
 
   /// Non-blocking call to wait for new connections from a client.
   /**
      \param   proc_fn  The operations to perform upon receiving a connection request from a client.
   */
   template<class RecvProcMsgs>
   void start_accept(RecvProcMsgs proc_fn) noexcept(false);
 
private:
   socket_t &dest_socket_;
};
 
} } } } }
 
#include "socket_server_manager_glibc_impl.hpp"
 
#ifdef __GCC__
#  pragma GCC diagnostic pop
#endif
 
#endif