Unexpected SocketSelector behavior

[ZamenWolk]

Hello everyone

I'm here today to seek help for my program that I've been coding for quite a bit now, and I've been stuck for about a week over a very annoying bug, and I'm here because I really don't know what to do anymore. My problem is that my socket selector always returns "false" immediatly when I call wait(), no matter if there is actually someone trying to connect on the listener, or if I put a timeout argument.I'm really out of ideas about what it could be, so any help would be more than welcome

EDIT : There's a much simpler version of the code 2 posts below

Here's my code :

main.cpp

(click to show/hide)

#include <iostream>
#include <SFML/Network.hpp>
#include <vector>
#include <functional>

#include "../src/operators.hpp"
#include "../src/constants.hpp"
#include "../src/version.hpp"
#include "FightSubserver.hpp"
#include "fonctor.hpp"

using namespace std;
using namespace sf;

bool aboutToStop = false;

int main()
{
    TcpListener             listener;
    unsigned int            subserverNumber;
    vector<FightSubserver*> subservers;
    vector<ServerClient*>   clientsVector;
    SocketSelector          selector;
    inputFonctor            input(&subservers);
    Thread                  inputThread(input);

    //Questions how many fight subservers need to be done
    cout << "How many fights do you want to host simultaneously ?" << endl;
    cin >> subserverNumber;

    // Setting up all the subservers
    for (int i=0; i != subserverNumber; i++)
    {
        FightSubserver* newSubserver= new FightSubserver();
        subservers.push_back(newSubserver);
    }

    // Gathering all the Sockets together
    for (vector<FightSubserver*>::iterator it = subservers.begin(); it != subservers.end(); it++)
    {
         clientsVector.push_back(&(*it)->m_clients[0]);
         clientsVector.push_back(&(*it)->m_clients[1]);
    }

    selector.add(listener);

    //Addition of all the sockets to the selector
    for (int i = 0; i < clientsVector.size(); i++)
    {
        selector.add(*clientsVector[i]);
    }

    inputThread.launch();
    listener.listen(2715);

    cout << "The server host is now ready and working !" << endl;

    while (!aboutToStop)
    {
        cout << "Searching for event" << endl;

        if (selector.wait())
        {
            cout << "Found something !" << endl;

            if (selector.isReady(listener))
            {
                //Search of a subserver with at least one free socket
                FightSubserver *openSubserver(nullptr);
                if (findOpenSubserver(subservers, openSubserver))
                {
                    ServerClient* clientSocket;
                    clientSocket = openSubserver->connect(listener);
                }
            }
            else
            {
                for (int i = 0; i < clientsVector.size(); i++)
                {
                    if (selector.isReady(*clientsVector[i]) && subservers[i/2]->isLastEventTreated())
                    {
                        //Reception of events and dispatching into the correct subservers
                       
                        cout << "Received info !" << endl;

                        InteractionInfos                receivedInteraction;
                        vector<EntityInformations>      receivedTeam;
                        bool                            concernedTeam;
                        SentInfosType                   infosType;
                        sf::Packet                      receivedPacket;

                        clientsVector[i]->receive(receivedPacket);
                        receivedPacket >> infosType;

                        if (infosType == FIGHT_INTERACTION)
                        {
                            receivedPacket >> receivedInteraction;
                            subservers[i/2]->newEvent(receivedInteraction);
                        }
                        else if (infosType == TEAM_DATA)
                        {
                            receivedPacket >> concernedTeam;
                            receivedPacket >> receivedTeam;
                            subservers[i/2]->newEvent(receivedTeam, concernedTeam);
                        }
                    }
                }
            }
        }
        else
        {
            cout << "Couldn't find anything" << endl;
        }

        sf::sleep(sf::milliseconds(25));
    }

    inputThread.wait();
    for (vector<ServerClient*>::iterator it = clientsVector.begin(); it != clientsVector.end(); it++)
    {
        selector.remove(**it);
    }

    while (subservers.size() > 0)
    {
        subservers.pop_back();
    }

    return EXIT_SUCCESS;
}
 

FightSubserver.hpp

(click to show/hide)

#ifndef FIGHTSUBSERVER_HPP_INCLUDED
#define FIGHTSUBSERVER_HPP_INCLUDED

#include <SFML/Network.hpp>
#include <SFML/System.hpp>
#include <vector>
#include <iostream>

#include "ServerClients.hpp"
#include "../src/operators.hpp"
#include "../src/AIControlledEntity.hpp"
#include "structures.hpp"

extern bool aboutToStop;

class FightSubserver
{
public:

    friend int main();

    FightSubserver():
                m_clients(),
                m_serverThread(&FightSubserver::threadFunction, this),
                m_stopServer(0)
    {
        m_serverThread.launch();
    }

    ~FightSubserver()
    {
        m_stopServer = true;
        m_serverThread.wait();
        delete m_teams[0];
        delete m_teams[1];
    }

    bool isFull() const
    {
        if(m_clients[0].isFree() or m_clients[1].isFree())
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    void reset()
    {
        disconnect(true);
        disconnect(false);
    }

    ServerClient* connect(sf::TcpListener& listener)
    {
        if (m_clients[0].isFree())
        {
            //Connection to first Socket, and verification that the client has the right version of client
            sf::Packet versionPacket;

            m_clients[0].connect(listener);
            m_clients[0].receive(versionPacket);

            versionPacket >> m_eventsStructure.versEv_number.status >> m_eventsStructure.versEv_number.major >> m_eventsStructure.versEv_number.minor;

            if (m_eventsStructure.versEv_number.status == AutoVersion::SUPPORTED_STATUS
                and m_eventsStructure.versEv_number.major == AutoVersion::SUPPORTED_MAJOR
                and m_eventsStructure.versEv_number.minor == AutoVersion::SUPPORTED_MINOR)
            {
                m_teams[0] = new std::vector<EntityInformations>;
                m_eventsStructure.isEventTreated = true;
                m_clients[0].confirmConnection();
                return &m_clients[0];
            }
            else
            {
                disconnect(true);
                m_eventsStructure.isEventTreated = true;
                return 0;
            }
        }
        else if (m_clients[1].isFree())
        {
            //Connection to second Socket, and verification that the client has the right version of client
            sf::Packet versionPacket;

            m_clients[1].connect(listener);
            m_clients[1].receive(versionPacket);

            versionPacket >> m_eventsStructure.versEv_number.status >> m_eventsStructure.versEv_number.major >> m_eventsStructure.versEv_number.minor;

            if (m_eventsStructure.versEv_number.status == AutoVersion::SUPPORTED_STATUS
                and m_eventsStructure.versEv_number.major == AutoVersion::SUPPORTED_MAJOR
                and m_eventsStructure.versEv_number.minor == AutoVersion::SUPPORTED_MINOR)
            {
                m_teams[1] = new std::vector<EntityInformations>;
                m_eventsStructure.isEventTreated = true;
                m_clients[1].confirmConnection();
                return &m_clients[1];
            }
            else
            {
                disconnect(false);
                m_eventsStructure.isEventTreated = true;
                return 0;
            }
        }
        else
        {
            ServerClient buffer;
            buffer.connect(listener);
            buffer.disconnect();
            return 0;
        }
    }

    ServerClient* disconnect(bool isClient1)
    {
        if(isClient1)
        {
            m_clients[0].disconnect();
            delete m_teams[0];
            return &m_clients[0];
        }
        else
        {
            m_clients[1].disconnect();
            delete m_teams[1];
            return &m_clients[1];
        }
    }

    void newEvent(const InteractionInfos& eventInfos)
    {
        m_eventsStructure.typeOfEvent = FIGHT_INTERACTION;
        m_eventsStructure.intEv_infos = eventInfos;
        m_eventsStructure.isEventTreated = false;
    }

    void newEvent(const std::vector<EntityInformations>& teamInfo, bool isTeam1)
    {
        m_eventsStructure.typeOfEvent = TEAM_DATA;
        m_eventsStructure.teamEv_infos = teamInfo;
        m_eventsStructure.event_team1 = isTeam1;
        m_eventsStructure.isEventTreated = false;
    }

    void newEvent(const VersionNumber& versionNumber, bool isTeam1)
    {
        m_eventsStructure.typeOfEvent = VERSION_NUMBER;
        m_eventsStructure.versEv_number = versionNumber;
        m_eventsStructure.event_team1 = isTeam1;
        m_eventsStructure.isEventTreated = false;
    }

    bool isLastEventTreated()
    {
        return m_eventsStructure.isEventTreated;
    }

    ServerClient                    m_clients[2];

protected:

    void threadFunction()
    {
        //Function who will assure the functionning of its own subserver
        while (!m_stopServer)
        {
            if (!isFull())
            {
                sf::sleep(sf::seconds(1));
            }
            else
            {
                while (isFull() and !m_stopServer)
                {

                }
            }
        }
    }

    sf::Thread                      m_serverThread;
    EventsStructure                 m_eventsStructure;
    bool                            m_stopServer,
                                    m_readyToLaunch;
    InteractionInfos                m_interactionToTreat;
    std::vector<EntityInformations> m_receivedTeamData,
                                    *m_teams[2];
    SentInfosType                   m_typeOfPendingInfos;
};

bool findOpenSubserver(std::vector<FightSubserver*> serverVector, FightSubserver* returnedSubServer);

#endif // FIGHTSUBSERVER_HPP_INCLUDED
 

FightSubserver.cpp

(click to show/hide)

#include <vector>

#include "FightSubserver.hpp"

bool findOpenSubserver(std::vector<FightSubserver*> serverVector, FightSubserver* returnedSubServer)
{
    for (std::vector<FightSubserver*>::iterator it = serverVector.begin(); it != serverVector.end(); it++)
    {
        if(!(*it)->isFull())
        {
            returnedSubServer = *it;
            return true;
        }
    }

    return false;
}
 

ServerClient.hpp

(click to show/hide)

#ifndef SERVERCLIENTS_HPP_INCLUDED
#define SERVERCLIENTS_HPP_INCLUDED

#include <SFML/Network.hpp>

class ServerClient : public sf::TcpSocket
{
public:

    ServerClient():
           m_isFree(true)
    {

    }

    void connect(sf::TcpListener& listener)
    {
        listener.accept(*this);
    }

    void confirmConnection()
    {
        m_isFree = false;
    }

    virtual void disconnect()
    {
        sf::TcpSocket::disconnect();
        m_isFree = true;
    }

    bool isFree() const
    {
        return m_isFree;
    }

protected:

    bool m_isFree;
};

#endif // SERVERCLIENTS_HPP_INCLUDED
 

In case you want to see the functor, here is functor.hpp

(click to show/hide)

#ifndef FONCTOR_HPP_INCLUDED
#define FONCTOR_HPP_INCLUDED

#include <SFML/Network.hpp>
#include <vector>
#include <functional>

class inputFonctor
{
public:

    inputFonctor(   std::vector<FightSubserver*> *subservers):
                        m_subservers(subservers)
    {

    }

    void operator()()
    {
        std::string input("");

        while (!aboutToStop)
        {
            std::cin >> input;

            if (input == "stop")
            {
                std::cout << "Stopping the server" << std::endl;
                aboutToStop = true;
            }
            else if (input == "reset")
            {
                int servNumber(0);
                std::cin >> servNumber;

                if (servNumber > 0 and servNumber <= m_subservers->size())
                {
                    m_subservers->operator[](servNumber-1)->reset();
                    std::cout << "Server #" << servNumber << " was succesfully reset" << std::endl;
                }
                else
                {
                    std::cout << "This is not a correct number" << std::endl;
                }
            }
            else
            {
                std::cout << "This is not an existing command" << std::endl;
            }
        }
    }

private:

    std::vector<FightSubserver*> *m_subservers;
};

#endif // FONCTOR_HPP_INCLUDED
 

And thank you in advance for your help

Zamen

[Nexus]

Please read this post carefully

[ZamenWolk]

Ahah yeah that's probably right, will do I'll come back with something better

[ZamenWolk]

So I have updated my project os it's wayyy more simple, but there is still the error bothering me

main.cpp

bool aboutToStop = false;

int main()
{
    TcpListener             listener;
    unsigned int            subserverNumber(50);
    vector<TcpSocket*>      clientsVector;
    SocketSelector          selector;

    for (int i = 0; i < subserverNumber; i++)
    {
        TcpSocket* newSocket = new TcpSocket;
        clientsVector.push_back(newSocket);
    }

    selector.add(listener);

    //Addition of all the sockets to the selector
    for (int i = 0; i < clientsVector.size(); i++)
    {
        selector.add(*clientsVector[i]);
    }

    listener.listen(2715);

    cout << "The server host is now ready and working !" << endl;

    while (!aboutToStop)
    {
        cout << "Searching for event" << endl;

        if (selector.wait())
        {
            cout << "Found something !" << endl;
        }
        else
        {
            cout << "Couldn't find anything" << endl;
        }

        sf::sleep(sf::milliseconds(25));
    }

    return EXIT_SUCCESS;
}

[Laurent]

The listener must be added to the selector after the call to listen(). Same for all your TcpSockets, they must be connected before being added to the selector. But honestly I have no idea what you're going to do with 50 empty sockets. Why don't you create them on the fly, on each new connection?