EmulatedInterface.ih

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
//


/** \file
    \brief EmulatedInterface internal header */

#ifndef IH_SENF_Ext_NetEmu_EmulatedInterface_
#define IH_SENF_Ext_NetEmu_EmulatedInterface_ 1

// Custom includes
#include <senf/PPI/MonitorModule.hh>
#include <senf/PPI/IntervalTimer.hh>
#include "Packets.hh"

//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace emu {

    class EmulatedReceiver;
    class EmulatedTransmitter;
    class ChannelGroupTable;

namespace detail {

    /** \brief Internal: Emulated interface receive filter */
    class EmulatedInterfaceReceiveFilter
        : public ppi::module::Module
    {
        SENF_PPI_MODULE(EmulatedInterfaceReceiveFilter);
    public:
        ppi::connector::PassiveInput<PacketHeader> input;
        ppi::connector::ActiveOutput<> output;

        explicit EmulatedInterfaceReceiveFilter(EmulatedReceiver & receiver);

    private:
        void request();

        EmulatedReceiver & receiver_;
    };

    /** \brief Internal: Emulated interface transmit filter */
    class EmulatedInterfaceTransmitFilter
        : public ppi::module::Module
    {
        SENF_PPI_MODULE(EmulatedInterfaceTransmitFilter);
    public:
        ppi::connector::PassiveInput<> input;
        ppi::connector::ActiveOutput<PacketHeader> output;

        explicit EmulatedInterfaceTransmitFilter(EmulatedTransmitter & transmitter);

        unsigned mtu() const;
        void mtu(unsigned v);

    private:
        void request();

        EmulatedTransmitter & transmitter_;
        unsigned seqNr_;
        unsigned mtu_;
    };

    /**  \brief Sequence number validation

        This module will validate the sequence number of all packets. The sequence number is
        monitored for each peer. If sequence numbers are reversed or missing the module generates an
        appropriate message.
     */
    class DroppedPacketChecker
        : public ppi::module::MonitorModule<PacketHeader>
    {
        SENF_PPI_MODULE(DroppedPacketChecker);
        SENF_LOG_CLASS_AREA();
    public:
        DroppedPacketChecker();

        unsigned droppedPackets() const; ///< Number of dropped packets

        /** \brief DroppedPacketChecker statistics
            \see DroppedPacketChecker */
        struct Statistics {
            boost::signals2::signal<void (float)> droppedPacketsPerSecond;
            boost::signals2::signal<void (unsigned)> numPeers;
        } signals;

        void startStatistics(ClockService::clock_type pollInterval);
                                        ///< Start statistics generation or change interval

    private:
        virtual void v_handlePacket(PacketHeader const & p) override;
        void statisticsUpdate();

        typedef std::map<std::pair<unsigned,unsigned>, boost::uint32_t> SeqNoMap;
        SeqNoMap seqNos_;
        unsigned droppedPackets_;
        ppi::IntervalTimer statisticsTimer_;
        unsigned lastDroppedPackets_;
        float factor_;
    };

    /** \brief Check raw packet transmit time

        This module will check the time each packet takes from the time it is sent until it is
        received against a maximum value. Excessively delayed packets will be logged.
     */
    class DelayTimeChecker
        : public ppi::module::MonitorModule<PacketHeader>
    {
        SENF_PPI_MODULE(DelayTimeChecker);
        SENF_LOG_CLASS_AREA();
    public:
        DelayTimeChecker(
            ClockService::clock_type maxDelay = ClockService::milliseconds(10));

        void maxDelay(ClockService::clock_type maxDelay);
                                        ///< Set maximum allowed packet delay
        ClockService::clock_type maxDelay() const;
                                        ///< Get current maxDelay() value

        unsigned delayedPackets() const; ///< Number of packets with delay > maxDelay()
        ClockService::clock_type maxPacketDelay() const;
                                        ///< Maximum packet delay encountered

        /** \brief DelayTimeChecker statistics
            \see DelayTimeChecker */
        struct Statistics {
            boost::signals2::signal<void (float,float,float)> packetDelay;
        } signals;

        void startStatistics(ClockService::clock_type pollInterval);

    private:
        virtual void v_handlePacket(PacketHeader const & p) override;
        void statisticsUpdate();

        ClockService::clock_type maxDelay_;
        unsigned delayedPackets_;
        ClockService::clock_type maxPacketDelay_;
        ppi::IntervalTimer statisticsTimer_;
        ClockService::clock_type minDelayStat_, totalDelayStat_, maxDelayStat_;
        unsigned nPackets_;
    };

    class AdvancePacket
        : public ppi::module::Module
    {
        SENF_PPI_MODULE(AdvancePacket);
    public:
        ppi::connector::PassiveInput<PacketHeader> input;
        ppi::connector::ActiveOutput<> output;

        AdvancePacket();

    private:
        void request();
    };

}}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#endif

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