EmulatedWirelessInterface.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_Ext_NetEmu_EmulatedWirelessInterface_
#define HH_SENF_Ext_NetEmu_EmulatedWirelessInterface_ 1

// Custom includes
#include <boost/signals2.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/composite_key.hpp>
#include <senf/Scheduler/IdleEvent.hh>
#include <senf/Utils/Console/Traits.hh>
#include <senf/Utils/Console/UDPServer.hh>
#include <senf/Utils/Console/Utility.hh>
#include <senf/Utils/singleton.hh>
#include "WirelessInterfaceAPI.hh"
#include "EmulatedInterface.hh"
#include "Annotations.hh"

#include "EmulatedWirelessInterface.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace emu {

    class EmulatedFrequencyRegistry
        : public senf::singleton<EmulatedFrequencyRegistry>
    {
        SENF_LOG_CLASS_AREA();

    public:
        typedef boost::function<void (UDPClientHandle::Address const & address)> UserCallback;
        typedef boost::function<void (unsigned frequency, unsigned bandwidth)> CollisionCallback;

        struct Entry
        {
            unsigned frequency;         
            unsigned bandwidth;         
            UDPClientHandle::Address address; 
            unsigned nUsers;            
            unsigned ownerNodeId;       

        private:
            Entry();
            Entry(unsigned frequency_, unsigned bandwidth_);
            Entry(unsigned frequency_, unsigned bandwidth_, UDPClientHandle::Address address_,
                  unsigned nUsers_, unsigned ownerNodeId_);

            friend class EmulatedFrequencyRegistry;
        };

    private:
        struct ByFrequency {};
        struct ByAddress {};

        // The ByAddress index really is unique except for the 'None' address, which may occur
        // more than once
        struct EntryIndices
            : public boost::multi_index::indexed_by<
                  boost::multi_index::ordered_unique<
                      boost::multi_index::tag<ByFrequency>,
                      boost::multi_index::composite_key<
                          Entry,
                          boost::multi_index::member<Entry, unsigned, &Entry::frequency>,
                          boost::multi_index::member<Entry, unsigned, &Entry::bandwidth> > >,
                  boost::multi_index::ordered_non_unique<
                      boost::multi_index::tag<ByAddress>,
                      boost::multi_index::member<Entry, UDPClientHandle::Address, &Entry::address> >
              >
        {};

        typedef boost::multi_index_container<Entry, EntryIndices> Entries;

        struct User
        {
            Entries::index_iterator<ByFrequency>::type entry;
            unsigned interfaceId;
            mutable UserCallback callback;

            User();
            User(Entries::index_iterator<ByFrequency>::type entry_, unsigned interfaceId_,
                 UserCallback callback_);
        };

        struct ByInterfaceId {};
        struct ByEntry {};

        // Since the multi_index_container iterators are not comparable, we sort the ByEntry index
        // using the address of the Entry referenced by the 'entry' iterator. Additional overloads
        // allow searching either by iterator or by Entry address.
        struct AddrCompare
        {
            bool operator()(Entries::index_iterator<ByFrequency>::type a,
                            Entries::index_iterator<ByFrequency>::type b) const;
            bool operator()(Entries::index_iterator<ByFrequency>::type a,
                            Entry const * b) const;
            bool operator()(Entry const * a,
                            Entries::index_iterator<ByFrequency>::type b) const;
        };

        struct UserIndices
            : public boost::multi_index::indexed_by<
                  boost::multi_index::ordered_unique<
                      boost::multi_index::tag<ByInterfaceId>,
                      boost::multi_index::member<User, unsigned, &User::interfaceId> >,
                  boost::multi_index::ordered_non_unique<
                      boost::multi_index::tag<ByEntry>,
                      boost::multi_index::member<
                          User, Entries::index_iterator<ByFrequency>::type, &User::entry>,
                      AddrCompare>
            >
        {};

        typedef boost::multi_index_container<User, UserIndices> Users;

        typedef boost::multi_index::member<User, unsigned, &User::interfaceId> GetInterfaceId;
        typedef boost::transform_iterator<
            GetInterfaceId, Users::index_iterator<ByEntry>::type> InterfaceIdIterator;

    public:
        typedef boost::iterator_range<Entries::index_iterator<ByFrequency>::type> EntriesRange;
        typedef boost::iterator_range<InterfaceIdIterator> UsersRange;

        using senf::singleton<EmulatedFrequencyRegistry>::instance;
        using senf::singleton<EmulatedFrequencyRegistry>::alive;

        UDPClientHandle::Address consoleGroup() const;
        void consoleGroup(UDPClientHandle::Address const & group);

        std::pair<INet4Network, unsigned> addressRange() const;

        void addressRange(INet4Network const & range, unsigned portbase);

        void nextAddress(unsigned index); 

        void allocate(unsigned interfaceId, unsigned frequency, unsigned bandwidth, UserCallback cb);

        void release(unsigned interfaceId);

        void collisionCallback(CollisionCallback cb);

        void schedulerStart();
        void start();                   
        void stop();                    

        EntriesRange entries() const;   
        UsersRange users(EntriesRange::iterator i) const;

        enum ChangeType { JOIN, LEAVE, STOP };
        boost::signals2::signal<void (
            Entry const &, unsigned nodeId, ChangeType type)> channelPopulationChanged;

    protected:

    private:
        EmulatedFrequencyRegistry();

        // User console commands
        void consoleList(std::ostream & os) const;

        // IPC console commands
        void add(unsigned nodeId, unsigned frequency, unsigned bandwidth,
                 UDPClientHandle::Address address);
        void del(unsigned nodeId, unsigned frequency, unsigned bandwidth);
        void join(unsigned nodeId, unsigned frequency, unsigned bandwidth);
        void leave(unsigned nodeId, unsigned frequency, unsigned bandwidth);
        int poll(unsigned nodeId, unsigned frequency, unsigned bandwidth);

        // Sending console commands to other nodes
        void sendAdd(unsigned nodeId, unsigned frequency, unsigned bandwidth,
                     UDPClientHandle::Address address);
        void sendDel(unsigned nodeId, unsigned frequency, unsigned bandwidth);
        void sendJoin(unsigned nodeId, unsigned frequency, unsigned bandwidth);
        void sendLeave(unsigned nodeId, unsigned frequency, unsigned bandwidth);
        void sendPoll(unsigned nodeId, unsigned frequency, unsigned bandwidth);

        UDPClientHandle::Address getAddress();
        void updateAddress(Entry const & entry);
        void checkCollisionOk(unsigned frequency, unsigned bandwidth);

        console::ScopedDirectory<> dir_;
        UDPClientHandle socket_;
        UDPClientHandle::Address group_;
        boost::scoped_ptr<console::UDPServer> server_;
        scheduler::IdleEvent schedulerStart_;
        INet4Network channelGroupRange_;
        unsigned portbase_;
        unsigned lastAddress_;
        Entries entries_;
        Users users_;
        bool running_;
        CollisionCallback cb_;

        friend class senf::singleton<EmulatedFrequencyRegistry>;
    };

    EmulatedFrequencyRegistry & emulatedFrequencyRegistry();

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

    class EmulatedWirelessReceiver;
    class EmulatedWirelessTransmitter;

    class EmulatedWirelessInterface
        : public EmulatedInterface,
          public detail::InterfaceAccess<WirelessInterface>,
          public detail::CommfaceAccess<EmulatedWirelessReceiver, EmulatedWirelessTransmitter>
    {
    public:
        using detail::InterfaceAccess<WirelessInterface>::interface;
        using detail::CommfaceAccess<EmulatedWirelessReceiver, EmulatedWirelessTransmitter>::receiver;
        using detail::CommfaceAccess<EmulatedWirelessReceiver, EmulatedWirelessTransmitter>::transmitter;

        typedef std::vector<console::ValueRange<unsigned> > Ranges;
        typedef boost::function<double (unsigned nodeId)> DistanceCallback;

        ~EmulatedWirelessInterface();

        void registerFrequency(unsigned frequency, unsigned bandwidth);
        void registerFrequency(unsigned frequencyLower, unsigned frequencyUpper,
                               unsigned bandwidthLower,unsigned bandwidthUpper);
        void registerFrequency(Ranges const & frequencies, Ranges const & bandwidths);

        void distanceCallback(DistanceCallback cb); //register the distance cb

    protected:
        EmulatedWirelessInterface();
        void init();

        unsigned emulatedFrequency() const; 
        unsigned emulatedBandwidth() const; 
        void emulatedFrequency(unsigned frequency, unsigned bandwidth);

        void emulatedCoverageRange(unsigned distance);

    private:
        unsigned frequency_;
        unsigned bandwidth_;
        unsigned index_;

        DistanceCallback distanceCallback_;
        friend class EmulatedWirelessReceiver;
    };

    class EmulatedWirelessReceiver
        : public EmulatedReceiver,
          public detail::InterfaceAccess<WirelessInterface>,
          public detail::InterfaceAccess<EmulatedWirelessInterface>
    {
    public:
        typedef detail::InterfaceAccess<EmulatedWirelessInterface> emui;
        typedef detail::InterfaceAccess<WirelessInterface> basei;

    protected:
        ppi::connector::ActiveOutputJack<> receiverJack;

        EmulatedWirelessReceiver();
        void init();

        virtual bool v_emulatedWirelessQuality(Packet packet, annotations::Quality & quality);

    private:
        detail::EmulatedWirelessInterfaceReceiveFilter filter_;

        unsigned rssiRandomnessRange_;
        unsigned noiseRandomnessRange_;

        friend class detail::EmulatedWirelessInterfaceReceiveFilter;
    };

    class EmulatedWirelessTransmitter
        : public EmulatedTransmitter,
          public detail::InterfaceAccess<WirelessInterface>,
          public detail::InterfaceAccess<EmulatedWirelessInterface>
    {
    public:
        typedef detail::InterfaceAccess<EmulatedWirelessInterface> emui;
        typedef detail::InterfaceAccess<WirelessInterface> basei;

        typedef std::vector< console::ValueRange<int> > Ranges;

        void registerTxPower(int power); 
        void registerTxPower(int powerLow, int powerHigh); 
        void registerTxPower(Ranges const & powers); 

    protected:
        ppi::connector::PassiveInputJack<> transmitterJack;

        EmulatedWirelessTransmitter();
        void init();

    private:
        detail::EmulatedWirelessInterfaceTransmitFilter filter_;
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "EmulatedWirelessInterface.cci"
//#include "EmulatedWirelessInterface.ct"
//#include "EmulatedWirelessInterface.cti"
#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: