void Horus::Commons::Network::StreamServer::start()
{
if (m_running) return;
boost::asio::ip::tcp::resolver resolver(m_acceptor.get_io_service());
boost::asio::ip::tcp::resolver::query query(
m_address.toStdString(),
m_port.toStdString());
try
{
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
m_acceptor.open(endpoint.protocol());
m_acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
m_acceptor.bind(endpoint);
m_acceptor.listen();
m_running = true;
emit startSuccess();
startAccept();
} catch (std::exception& e) {
Q_UNUSED(e);
emit startFailure();
}
}
void Server::handleAccept (const boost::system::error_code& ec)
{
if (!ec)
m_conn->start ();
startAccept ();
}
void Server::start(unsigned short port)
{
MLOG_MESSAGE(Debug, "start(" << port << ")");
nexus::listen(acceptor_, port);
startAccept();
}
void KinectServer::handleAccept(KinectServerConnection::pointer new_connection, const boost::system::error_code& error)
{
if (!error)
{
new_connection->Start();
startAccept();
}
}
void TcpServer::handleAccept( TcpConnection::SharedPtr newConnection, const boost::system::error_code &error )
{
if(!error)
{
newConnection->start();
startAccept();
}
}
ServeurCentral::ServeurCentral(boost::asio::io_service &io_service, int portecoute)
: portecoute(portecoute),
m_acceptor(io_service, tcp::endpoint(tcp::v4(), portecoute)),
io_service(io_service)
{
cout << "Construction du serveur central" << std::endl;
startAccept();
}
TcpServer::TcpServer( boost::asio::io_service &io
, MessageHandler &msgHandler
, unsigned int serverPort )
: m_acceptor(io, tcp::endpoint(tcp::v4(),serverPort))
, m_msgHandler(msgHandler)
{
startAccept();
}
void TcpServer::start() {
running_ = true;
startAccept();
init();
self_ = new std::thread(boost::bind(&boost::asio::io_service::run, &io_));
}
void Server::handleAccept(OnlineUser* newUser, const boost::system::error_code& error) {
if (!error) {
newUser->start();
}
startAccept();
}
SecureNodeListProvider::SecureNodeListProvider(boost::asio::io_service &io_service, int portecoute)
: portecoute(portecoute),
m_acceptor(io_service, tcp::endpoint(tcp::v4(), portecoute)),
io_service(io_service)
{
cout << "Construction du serveur de liste de noeud" << std::endl;
startAccept();
}
void CS3100::ServerImpl::onAccept(boost::shared_ptr<CS3100::ConnectionImpl> connection, const boost::system::error_code& error)
{
if(!error)
{
boost::interprocess::scoped_lock<boost::mutex> lock(connectionListMutex);
connectionList.push_back(boost::shared_ptr<CS3100::Connection>(new CS3100::Connection(connection)));
}
startAccept();
}
void EventManager::handleAccept(EventSystem::NetworkChannel::Pointer newConnection,
const boost::system::error_code& error)
{
std::cout << "New Incoming connection" << std::endl;
if (!error)
{
newConnection->startHandShake();
startAccept();
}
}
void SecureNodeListProvider::handle_accept(Client<SecureNodeListProvider> *noeud, const boost::system::error_code &error)
{
if (!error)
{
std::cout << "Un client est accepté" << std::endl;
toutlemonde.push_back(noeud);
noeud->startRead();
startAccept();
}
}
void TcpServer::createServer(int port, int)
{
tcp::endpoint endpoint(tcp::v4(), port);
mPort = port;
mAcceptor = boost::shared_ptr<tcp::acceptor>(new tcp::acceptor(mService, endpoint));
std::cout << "[TCP] start listening on port " << port << std::endl;
startAccept();
boost::system::error_code ec;
mService.run(ec);
}
void ServeurCentral::handle_accept(Client<ServeurCentral> *noeud, const boost::system::error_code &error)
{
if (!error)
{
std::cout << "Un client est accepté !" << std::endl;
toutlemonde.push_back(noeud);
noeud->startRead();
startAccept();
}
}
void GameServer::handleAccept(PlayerSession::ptr session,
boost::system::error_code const& error)
{
if (!error)
{
session->start();
}
startAccept();
}
void TCP_Async_Server::acceptHandle(TCPConnectionPtr newConnectionPtr, const boost::system::error_code& error) {
if(!error) {
std::cout << "Start handling request\n";
newConnectionPtr->start();
}
waitingSocket--;
if(waitingSocket == 0)
startAccept();
}
void Server::initService() {
startAccept();
for (int i = 0; i < 4; i++) {
threads.create_thread(
[&]()
{
ioService.run();
});
}
//ioService.run();
}
void Server::handleAccept(const boost::system::error_code & error)
{
if (!error)
{
auto endp=newConnection_.get()->socket().remote_endpoint();
std::cout << "new connection from " <<endp.address()
<<" at port " <<endp.port()<<std::endl;
connectionManager_.start(newConnection_);
}
startAccept();
}
void TelnetServer::handleAccept(TelnetConnection::pointer newCon, const boost::system::error_code &err) {
if (!err) {
newCon->setupLineMode();
mNewConnectionHandler(newCon);
newCon->startReceive();
}
else {
std::cerr << "handleAccept: " << err.message() << std::endl;
}
startAccept();
}
void PeerServer::handleAccept(PeerConnection::pointer conn,
const boost::system::error_code &error) {
if (!error) {
conn->start();
// Go back accepting other connections
startAccept();
} else {
LOG(ERROR) << "Error accepting peer connection";
}
}
void LBServer::handleAccept(WorkerConnection::pointer conn,
const boost::system::error_code &error) {
if (!error) {
LOG(INFO) << "Connection received from " << conn->getSocket().remote_endpoint().address();
conn->start();
// Go back and accept another connection
startAccept();
} else {
LOG(ERROR) << "Error accepting worker connection";
}
}
Server::Server ()
: m_acceptor (m_io)
, m_dbMgr (new DBManager)
{
std::string address = "127.0.0.1";
ip::tcp::resolver resolver (m_io);
ip::tcp::endpoint ep = *resolver.resolve (ip::tcp::resolver::query (address, "54093"));
m_acceptor.open (ep.protocol());
m_acceptor.set_option (ip::tcp::acceptor::reuse_address (true));
m_acceptor.bind (ep);
m_acceptor.listen ();
startAccept ();
}
AsyncServer::AsyncServer(const SmartMet::Spine::Options& theOptions,
SmartMet::Spine::Reactor& theReactor)
: Server(theOptions, theReactor), itsNewConnection(), itsMutex(), itsConnections(0)
{
try
{
// Fire the connect accept loop
startAccept();
}
catch (...)
{
throw SmartMet::Spine::Exception(BCP, "Operation failed!", NULL);
}
}
void Server::handleAccept(TCPConnection::Pointer_t newConnection, const boost::system::error_code &error)
{
if (verbose)
{
std::cout << "[Server] Incoming connection from " << newConnection->socket().remote_endpoint().address().to_string() << "." << std::endl;
}
if (!error)
{
newConnection->setParent(this);
newConnection->start();
clients.insert(newConnection);
}
startAccept();
}
void Server::handleAccept(ServerConnectionPtr connection, const boost::system::error_code &error)
{
if (_acceptor.is_open())
{
if (!error)
{
std::cout << "Connection accepted." << std::endl;
bool acceptConnection = true;
_onConnectionCreated(connection, acceptConnection);
if(acceptConnection)
connection->Start();
}
startAccept();
}
}
void Horus::Commons::Network::StreamServer::handleAccept(const boost::system::error_code &e)
{
if (m_manager->isNewConnectionAvailable() == false)
{
m_new_connection->socket().close();
return;
}
if (m_acceptor.is_open()==false)
return;
if (!e)
m_manager->join(m_new_connection);
startAccept();
}
//-----------------------------------------------------------------------------
// Network stuff
void EventManager::listen(const int port)
{
dbglog << "EventManager: Listening on port " << port << " ...";
boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), port);
if (!mAcceptor)
{
mAcceptor = new boost::asio::ip::tcp::acceptor(mService, ep);
startAccept();
}
else
{
throw std::logic_error("EventManager::init(): Initialized twice!");
}
}
void TcpServer::startAccept(void)
{ tcp::socket *socket = new tcp::socket(mService);
mSockets.push_back(socket);
mAcceptor->async_accept(*socket, [this](const boost::system::error_code& error) {
if (!error)
{
if (mListener)
mListener->onNewConnection(this);
}
else
{
std::cout << "[TCP] async_accept failed: " << error.message() << std::endl;
delete this;
}
startAccept();
});
}
void Server::handleAccept(const boost::system::error_code & ec, const nexus::isocket & socket)
{
MLOG_MESSAGE(Info, "handleAccept(" << ec << ")");
if(!ec)
{
MLOG_MESSAGE(Debug, "accepted, local: " << (*socket)->local_endpoint() << ", remote: " << (*socket)->remote_endpoint());
(*socket)->set_option(boost::asio::ip::tcp::no_delay(true));
ConnectionPtr conn = new Connection(socket, handler_);
conn->start();
startAccept();
} else {
MLOG_MESSAGE(Warning, "Accept failed: " << ec << ", message: " << ec.message());
}
}
