Connectors.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_PPI_Connectors_
#define HH_SENF_PPI_Connectors_ 1

// Custom includes
#include <deque>
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <senf/Utils/safe_bool.hh>
#include <senf/Utils/Exception.hh>
#include <senf/Packets/Packets.hh>
#include "predecl.hh"
#include "detail/Callback.hh"
#include "Throttling.hh"
#include "ModuleManager.hh"

//#include "Connectors.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace ppi {
namespace connector {

    struct IncompatibleConnectorsException : public senf::Exception
    { IncompatibleConnectorsException() : senf::Exception("Incompatible connectors") {} };

    struct DuplicateConnectionException : public senf::Exception
    { DuplicateConnectionException() : senf::Exception("Duplicate connection") {} };


    class Connector
        : ModuleManager::Initializable, boost::noncopyable
    {
        SENF_LOG_CLASS_AREA();
        SENF_LOG_DEFAULT_LEVEL(senf::log::NOTICE);
    public:
        Connector & peer() const;       
        module::Module & module() const; 

        bool connected() const;         

        void disconnect();              

        console::DirectoryNode & consoleDir() const;

#ifndef SENF_PPI_NOTRACE
        enum TraceState { NO_TRACING, TRACE_IDS, TRACE_CONTENTS };

        static void staticTracingState(TraceState state);
        void tracingState(TraceState state);
        TraceState tracingState() const;
        static void tracingFilter(std::string const & traceFilter);
#endif

    protected:
        Connector();
        virtual ~Connector();

        void connect(Connector & target);

#ifndef SENF_PPI_NOTRACE
        void trace(Packet const & p, char const * label);
        void throttleTrace(char const * label, char const * type);
#endif

        void unregisterConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        virtual std::type_info const & v_packetTypeId();

        void setModule(module::Module & module);

        Connector * peer_;
        module::Module * module_;

        console::ScopedDirectory<> consoleDir_;

#ifndef SENF_PPI_NOTRACE
        TraceState traceState_;
        static TraceState staticTraceState_;
        static std::string traceFilter_;
#endif

        friend class module::Module;
    };

    class PassiveConnector
        : public virtual Connector
    {
    public:
        ~PassiveConnector();

        template <class Handler>
        void onRequest(Handler handler);

        bool throttled() const;         
        bool nativeThrottled() const;   

        void throttle();                
        void unthrottle();              

        ActiveConnector & peer() const;

    protected:
        PassiveConnector();

        void emit();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        virtual void v_init();

        // Called by the routing to change the throttling state from forwarding routes
        void notifyThrottle();          
        void notifyUnthrottle();        

        // Internal members to emit throttling notifications to the connected peer
        void emitThrottle();
        void emitUnthrottle();

        // Called after unthrottling the connector
        virtual void v_unthrottleEvent();

        // called by ForwardingRoute to register a new route
        void registerRoute(ForwardingRoute & route);
        void unregisterRoute(ForwardingRoute & route);

        ActiveConnector * peer_;

        typedef ppi::detail::Callback<>::type Callback;
        Callback callback_;

        bool remoteThrottled_;
        bool nativeThrottled_;

        typedef std::vector<ForwardingRoute*> Routes;
        Routes routes_;

        friend class senf::ppi::ForwardingRoute;
    };

    class ActiveConnector
        : public virtual Connector
    {
        typedef ppi::detail::Callback<>::type Callback;
    public:
        ~ActiveConnector();

        template <class Handler>
        void onThrottle(Handler handler); 

        void onThrottle();              

        template <class Handler>
        void onUnthrottle(Handler handler); 

        void onUnthrottle();            

        bool throttled() const;         

        PassiveConnector & peer() const;

    protected:
        ActiveConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        virtual void v_init();

        // called by the peer() to forward throttling notifications
        void notifyThrottle();
        void notifyUnthrottle();

        // called by ForwardingRoute to register a new route
        void registerRoute(ForwardingRoute & route);
        void unregisterRoute(ForwardingRoute & route);

        PassiveConnector * peer_;

        Callback throttleCallback_;
        Callback unthrottleCallback_;

        typedef std::vector<ForwardingRoute*> NotifyRoutes;
        NotifyRoutes notifyRoutes_;

        bool throttled_;

        friend class senf::ppi::ForwardingRoute;
        friend class PassiveConnector;
    };

    class InputConnector
        : public virtual Connector
    {
        typedef std::deque<Packet> Queue;
    public:
        typedef Queue::const_iterator queue_iterator; 
        typedef Queue::size_type size_type; 


        Packet const & operator()();    

        Packet const & read();          

        OutputConnector & peer() const;

        size_type queueSize() const;    
        bool empty() const;             

    protected:
        InputConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        void enqueue(Packet const & p);

        virtual void v_requestEvent();
        virtual void v_enqueueEvent();
        virtual void v_dequeueEvent();

        OutputConnector * peer_;
        Queue queue_;
        Packet const * fastPacket_;
        Packet slowPacket_;

        friend class OutputConnector;
    };

    class OutputConnector
        : public virtual Connector
    {
    public:
        void operator()(Packet const & p);      

        void write(Packet const & p);           

        InputConnector & peer() const;

    protected:
        OutputConnector();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        InputConnector * peer_;
    };

    class GenericPassiveInput
        : public PassiveConnector, public InputConnector,
          public safe_bool<GenericPassiveInput>
    {
    public:
        GenericActiveOutput & peer() const;

        bool boolean_test() const;      

        template <class ThrottlingDisc>
        void throttlingDisc(ThrottlingDisc const & disc); 

        void throttlingDisc(ThrottlingDiscipline::None_t);

    protected:
        GenericPassiveInput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        void v_enqueueEvent();
        void v_dequeueEvent();
        void v_unthrottleEvent();

        GenericActiveOutput * peer_;
        boost::scoped_ptr<ThrottlingDiscipline> throttlingDisc_;
    };

    class GenericPassiveOutput
        : public PassiveConnector, public OutputConnector,
          public safe_bool<GenericPassiveOutput>
    {
    public:
        GenericActiveInput & peer() const;

        bool boolean_test() const;      

        void connect(GenericActiveInput & target); 

        friend class GenericActiveInput;

    protected:
        GenericPassiveOutput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        GenericActiveInput * peer_;
    };

    class GenericActiveInput
        : public ActiveConnector, public InputConnector,
          public safe_bool<GenericActiveInput>
    {
    public:
        GenericPassiveOutput & peer() const;

        bool boolean_test() const;      

        void request();                 

    protected:
        GenericActiveInput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        void v_requestEvent();

        GenericPassiveOutput * peer_;
    };

    class GenericActiveOutput
        : public ActiveConnector, public OutputConnector,
          public safe_bool<GenericActiveOutput>
    {
    public:
        GenericPassiveInput & peer() const;

        bool boolean_test() const;      

        void connect(GenericPassiveInput & target); 

    protected:
        GenericActiveOutput();

        virtual void v_disconnected();
        virtual void v_connected();

    private:
        GenericPassiveInput * peer_;
    };


#ifndef DOXYGEN

#   define TypedConnector_Input read
#   define TypedConnector_Output write
#   define TypedConnector(pType, dir)                                                             \
        template <class PacketType>                                                               \
        class pType ## dir                                                                        \
            : public Generic ## pType ## dir,                                                     \
              private detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType>        \
        {                                                                                         \
            typedef detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType> mixin;   \
        public:                                                                                   \
            using mixin::operator();                                                              \
            using mixin::TypedConnector_ ## dir ;                                                 \
        private:                                                                                  \
            virtual std::type_info const & v_packetTypeId()                                         \
                { return typeid(typename PacketType::type); }                                     \
            friend class detail::Typed ## dir ## Mixin<pType ## dir <PacketType>, PacketType>;    \
        };                                                                                        \
        template <>                                                                               \
        class pType ## dir <Packet> : public Generic ## pType ## dir                              \
        {}

    TypedConnector( Passive, Input  );
    TypedConnector( Passive, Output );
    TypedConnector( Active,  Input  );
    TypedConnector( Active,  Output );

#   undef TypedConnector
#   undef TypedConnector_Input
#   undef TypedConnector_Output

#else

    template <class PacketType=Packet>
    class ActiveInput : public GenericActiveInput
    {
    public:
        PacketType const & operator()(); 

        PacketType const & read();        
    };

    template <class PacketType=Packet>
    class PassiveInput : public GenericPassiveInput
    {
    public:
        PacketType const & operator()(); 

        PacketType const & read();      
    };

    template <class PacketType=Packet>
    class ActiveOutput : public GenericActiveOutput
    {
    public:
        void operator()(PacketType const & packet); 
        void write(PacketType const & packet);      
    };

    template <class PacketType=Packet>
    class PassiveOutput : public GenericPassiveOutput
    {
    public:
        void operator()(PacketType const & packet); 
        void write(PacketType const & packet);      
    };

#endif

}}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Connectors.cci"
#include "Connectors.ct"
#include "Connectors.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End: