Subversion Repositories HomeAutomation

/*

 *

 *  Copyright (C) 2010  Mattias Runge

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License along

 *  with this program; if not, write to the Free Software Foundation, Inc.,

 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

#include "Manager.h"

#include <boost/lexical_cast.hpp>

#include <boost/bind.hpp>

#include <boost/cast.hpp>

namespace atom {

namespace net {

Manager::Pointer Manager::instance_ = Manager::Pointer(new Manager());

Manager::Manager() : io_service_work_(io_service_)

{

    boost::thread thread(boost::bind(&boost::asio::io_service::run, &this->io_service_));

    this->thread_ = thread.move();

}

Manager::~Manager()

{

    this->clients_.clear();

    this->thread_.interrupt();

    this->thread_.join();

}

Manager::Pointer Manager::Instance()

{

    return Manager::instance_;

}

void Manager::Delete()

{

    Manager::instance_.reset();

}

void Manager::ConnectSlots(const SignalOnNewState::slot_type& slot_on_new_state, const SignalOnNewData::slot_type& slot_on_new_data)

{

    this->signal_on_new_state_.connect(slot_on_new_state);

    this->signal_on_new_data_.connect(slot_on_new_data);

}

void Manager::SlotOnNewState(ClientId client_id, ServerId server_id, ClientState client_state)

{

    if (client_state == CLIENT_STATE_DISCONNECTED)

    {

        this->mutex_clients_.lock();

        this->clients_.erase(client_id);

        this->mutex_clients_.unlock();

    }

    else if (client_state == CLIENT_STATE_ACCEPTED)

    {

        this->mutex_clients_.lock();

        ClientList::iterator it = this->clients_.find(client_id);

        if (it != this->clients_.end())

        {

            TcpClient::Pointer client = TcpClient::Pointer(new TcpClient(this->io_service_, this->GetFreeClientId(), it->second->GetServerId()));

            client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),

                                 Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));

            client->Accept(boost::polymorphic_downcast<TcpClient*>(it->second.get())->ReleaseAcceptor());

            this->clients_[client->GetId()] = client;

            this->mutex_clients_.unlock();

            this->signal_on_new_state_(client_id, server_id, CLIENT_STATE_CONNECTED);

            return;

        }

        else

        {

            this->mutex_clients_.unlock();

            throw std::runtime_error("Accepted unknown client!");

        }

    }

    this->signal_on_new_state_(client_id, server_id, client_state);

}

void Manager::SlotOnNewData(ClientId client_id, ServerId server_id, Buffer data)

{

    this->signal_on_new_data_(client_id, server_id, data);

}

ServerId Manager::GetFreeServerId()

{

    ServerId server_id = 1;

    for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)

    {

        if (it->second->GetServerId() != server_id)

        {

            return server_id;

        }

        server_id++;

    }

    return 0;

}

ClientId Manager::GetFreeClientId()

{

    ClientId client_id = 1;

    while (this->clients_.find(client_id) != this->clients_.end())

    {

        client_id++;

    }

    return client_id;

}

ServerId Manager::StartServer(Protocol protocol, unsigned int port)

{

    if (protocol != PROTOCOL_TCP)

    {

        throw std::runtime_error("Can not start server for the Serial or UDP protocol!");

        return 0;

    }

    this->mutex_clients_.lock();

    TcpClient::Pointer client = TcpClient::Pointer(new TcpClient(this->io_service_, this->GetFreeClientId(), this->GetFreeServerId()));

    client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),

                         Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));

    TcpClient::AcceptorPointer acceptor = TcpClient::AcceptorPointer(new boost::asio::ip::tcp::acceptor(this->io_service_, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)));    

    client->Accept(acceptor);

    this->clients_[client->GetId()] = client;

    this->mutex_clients_.unlock();

    return client->GetServerId();

}

ClientId Manager::Connect(Protocol protocol, std::string address, unsigned int port_or_baud)

{

    Client::Pointer client;

    this->mutex_clients_.lock();

    switch (protocol)

    {

        case PROTOCOL_TCP:

        {

            client = Client::Pointer(new TcpClient(this->io_service_, this->GetFreeClientId(), 0));

            break;

        }

        case PROTOCOL_UDP:

        {

            client = Client::Pointer(new UdpClient(this->io_service_, this->GetFreeClientId(), 0));

            break;

        }

        case PROTOCOL_SERIAL:

        {

            client = Client::Pointer(new SerialClient(this->io_service_, this->GetFreeClientId(), 0));

            break;

        }

        default:

        {

            this->mutex_clients_.unlock();

            throw std::runtime_error("Invalid protocol specified!");

            return 0;

        }

    }

    client->ConnectSlots(Client::SignalOnNewState::slot_type(&Manager::SlotOnNewState, this, _1, _2, _3).track(Manager::instance_),

                         Client::SignalOnNewData::slot_type(&Manager::SlotOnNewData, this, _1, _2, _3).track(Manager::instance_));

    try

    {

        client->Connect(address, port_or_baud);

    }

    catch (std::exception e)

    {

        this->mutex_clients_.unlock();

        throw e;

    }

    this->clients_[client->GetId()] = client;

    this->mutex_clients_.unlock();

    return client->GetId();

}

void Manager::SendToAll(ServerId server_id, Buffer data)

{

    this->io_service_.post(boost::bind(&Manager::SendToAllHandler, this, server_id, data));

}

void Manager::SendTo(ClientId client_id, Buffer data)

{

    this->io_service_.post(boost::bind(&Manager::SendToHandler, this, client_id, data));

}

void Manager::StopServer(ServerId server_id)

{

    this->io_service_.post(boost::bind(&Manager::StopServerHandler, this, server_id));

}

void Manager::Disconnect(ClientId client_id)

{

    this->io_service_.post(boost::bind(&Manager::DisconnectHandler, this, client_id));

}

void Manager::SendToAllHandler(ServerId server_id, Buffer data)

{

    this->mutex_clients_.lock();

    for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)

    {

        if (it->second->GetServerId() == server_id)

        {

            it->second->Send(data);

        }

    }

    this->mutex_clients_.unlock();

}

void Manager::SendToHandler(ClientId client_id, Buffer data)

{

    this->mutex_clients_.lock();

    ClientList::iterator it = this->clients_.find(client_id);

    if (it != this->clients_.end())

    {

        it->second->Send(data);

    }

    this->mutex_clients_.unlock();

}

void Manager::StopServerHandler(ServerId server_id)

{

    this->mutex_clients_.lock();

    for (ClientList::iterator it = this->clients_.begin(); it != this->clients_.end(); it++)

    {

        if (it->second->GetServerId() == server_id)

        {

            this->mutex_clients_.unlock();

            it->second->Disconnect();

            this->mutex_clients_.lock();

        }

    }

    this->mutex_clients_.unlock();

}

void Manager::DisconnectHandler(ClientId client_id)

{

    this->mutex_clients_.lock();

    ClientList::iterator it = this->clients_.find(client_id);

    this->mutex_clients_.unlock();

    if (it != this->clients_.end())

    {

        it->second->Disconnect();

    }

}

}; // namespace net

}; // namespace atom