Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате
Форум программистов > C/C++: Общие вопросы > [boost asio] ошибка при выполнени


Автор: cupper 28.12.2010, 11:01
Пытаюсь реализовать следующее. Есть класс, он умеет сериализоваться. Нужно передать его с клиента на сервер, на сервере с ним что то сделать, и вернуть назад.

Логика работы следующая. 
есть класс Connection, с реализованными шаблонными функция для отправки и принятия данных.
Код

#ifndef __CONNECTION_HPP__
#define __CONNECTION_HPP__

#include <boost/asio.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>

#include <iomanip>
#include <string>
#include <sstream>
#include <vector>


class Connection{
public:
    Connection(boost::asio::io_service& io_service)
        : socket_(io_service)
    {
    }
    
    boost::asio::ip::tcp::socket& socket()
    {
        return socket_;
    }
    
    template<typename T, typename Handler>
    void async_write(const T* data, Handler handler)
    {
        // сериализуем данные
        DataToString(outbound_data_, data);
                
        // формируем хедер, заданой длины, содержащий размер отправляемых данных
        std::ostringstream header_stream;
        header_stream << std::setw(header_length_)
            << std::hex << outbound_data_.size();
            
        if(!header_stream || header_stream.str().size() != header_length_){
        // header_stream пустой или его длина не равняется
        // обязательной длине заголовка
            boost::system::error_code error(boost::asio::error::invalid_argument);
            socket_.io_service().post(boost::bind(handler, error));
            return;
        }
        // Сформировываем строку для заголовка
        outbound_header_ = header_stream.str();
        
        std::vector<boost::asio::const_buffer> buffers;
        buffers.push_back(boost::asio::buffer(outbound_header_));
        buffers.push_back(boost::asio::buffer(outbound_data_));
        boost::asio::async_write(socket_, buffers, handler);    
    }
    
    template<typename T, typename Handler>
    void async_read(T* data, Handler handler)
    {
        void (Connection::*f)(
            const boost::system::error_code&,
            T*, boost::tuple<Handler>) 
            = &Connection::handle_read_header<T, Handler>;
        
        boost::asio::async_read(socket_, boost::asio::buffer(inbound_header_),
            boost::bind(f, 
                this, boost::asio::placeholders::error, data,
                boost::make_tuple(handler)));
    }
    
    template<typename T, typename Handler>
    void handle_read_header(const boost::system::error_code& e,
        T* data, boost::tuple<Handler> handler)
    {
        if(e){
            boost::get<0>(handler)(e);
        }
        else{
            std::istringstream is(std::string(inbound_header_, header_length_));
            std::size_t inbound_data_size = 0;
            if(!(is >> std::hex >> inbound_data_size)){
                boost::system::error_code error(
                    boost::asio::error::invalid_argument);
                boost::get<0>(handler)(error);
                return;
            }
            
            inbound_data_.resize(inbound_data_size);
            void (Connection::*f)(
                const boost::system::error_code&,
                T*, boost::tuple<Handler>)
                = &Connection::handle_read_data<T, Handler>;
            
            boost::asio::async_read(socket_, boost::asio::buffer(inbound_data_),
                boost::bind(f, this, 
                    boost::asio::placeholders::error, data, handler));
        }
    }
    
    template<typename T, typename Handler>
    void handle_read_data(const boost::system::error_code& e, 
        T* data, boost::tuple<Handler> handler)
    {
        if(e)
        {
            boost::get<0>(handler)(e);
        }
        else
        {
            try
            {
                std::string archive_data(&inbound_data_[0], inbound_data_.size());
                StringToData(archive_data, data);
            }
            catch(std::exception& e)
            {
                boost::system::error_code error(
                    boost::asio::error::invalid_argument);
                boost::get<0>(handler)(error);
                return;
            }
            
            boost::get<0>(handler)(e);
        }
    }
            

private:
    template<typename T>
    void DataToString(std::string& outstr, T* data)
    {
        std::ostringstream archive_stream;
        boost::archive::xml_oarchive archive(archive_stream);
        archive << boost::serialization::make_nvp("data",*data);
        // переводим в строку
        outstr = archive_stream.str();
    }
    template<typename T>
    void StringToData(const std::string& instr, T* data)
    {
        std::istringstream archive_stream(instr);
        boost::archive::xml_iarchive archive(archive_stream);
        archive >> boost::serialization::make_nvp("data",*data);
    }
    boost::asio::ip::tcp::socket socket_;
    
    // Длина заголовка, содержащий длину принимаемого сообщения
    const static size_t header_length_ = 8;
    
    std::string outbound_header_;
    std::string outbound_data_;
    
    char inbound_header_[header_length_];
    std::vector<char> inbound_data_;
};

typedef boost::shared_ptr<Connection> Connection_ptr;

#endif

класс взят из тутториала и допилен.

Есть класс client который. Единственная особенность которую можно унего выделить это то что класс содержит два указателя (один обычный, указывающий на отправляемые данные, один умных для принимаемых данных, что бы не следить за их корректным удалением)
Код

#ifndef __CLIENT_HPP__
#define __CLIENT_HPP__

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/serialization/vector.hpp>
#include <vector>

#include "ListPerson.h"
#include "connection.hpp" // Must come before boost/serialization headers.

class Client
{
public:
  /// Constructor starts the asynchronous connect operation.
  Client(boost::asio::io_service& io_service,
      const std::string& host, const std::string& service, epam::ListPerson& data)
    : connection_(io_service)
  {
    sendData_ = &data;
    recvData_.reset(new epam::ListPerson());
    // Resolve the host name into an IP address.
    boost::asio::ip::tcp::resolver resolver(io_service);
    boost::asio::ip::tcp::resolver::query query(host, service);
    boost::asio::ip::tcp::resolver::iterator endpoint_iterator =
      resolver.resolve(query);
    boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;

    // Начинаем процедуру подключения к серверу
    connection_.socket().async_connect(endpoint,
        boost::bind(&Client::handle_connect, this,
          boost::asio::placeholders::error, ++endpoint_iterator));
  }

  // Верунть принятые от сервера данные
  boost::shared_ptr<epam::ListPerson> GetRecvData() const
  {
    return recvData_;
  }

private:
  void handle_connect(const boost::system::error_code& e,
      boost::asio::ip::tcp::resolver::iterator endpoint_iterator)
  {
    if (!e)
    {
      // Соединение прошло успешно
      // Отправляем данные
        connection_.async_write(sendData_,
          boost::bind(&Client::handle_write, this, boost::asio::placeholders::error));
    }
    else if (endpoint_iterator != boost::asio::ip::tcp::resolver::iterator())
    {
      // Иначе пробудем подлкючиться к следующей конечной точке
      connection_.socket().close();
      boost::asio::ip::tcp::endpoint endpoint = *endpoint_iterator;
      connection_.socket().async_connect(endpoint,
          boost::bind(&Client::handle_connect, this,
            boost::asio::placeholders::error, ++endpoint_iterator));
    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

  void handle_write(const boost::system::error_code& e)
  {
    if (!e)
    {
      // Данные отправленны
      // Принимает ответ
      connection_.async_read(recvData_.get(),
          boost::bind(&Client::handle_read, this,
            boost::asio::placeholders::error));
    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

  /// Handle completion of a read operation.
  void handle_read(const boost::system::error_code& e)
  {
    if (!e)
    {
      std::cout << recvData_.get();
    }
    else
    {
      // An error occurred.
      std::cerr << e.message() << std::endl;
    }

  }

private:
  /// The connection to the server.
  Connection connection_;

  /// The data received from the server.
  epam::ListPerson* sendData_;
  boost::shared_ptr<epam::ListPerson> recvData_;
};

#endif // __CLIENT_HPP__


есть серверный класс, который содержит просто один умный указатель (он указывает на пустой объект который моздается в конструкторе, в него производится десереализация данных, их модификация и отправка обратно клиенту.
Код

#ifndef __SERVER_HPP__
#define __SERVER_HPP__

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/serialization/vector.hpp>

#include <iostream>
#include <vector>

#include "connection.hpp"
#include "ListPerson.h"

class Server
{
public:
  Server(boost::asio::io_service& io_service, unsigned short port)
    : acceptor_(io_service,
        boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
  {
      data_.reset(new epam::ListPerson());
    // Start an accept operation for a new connection.
    Connection_ptr new_conn(new Connection(acceptor_.io_service()));

    acceptor_.async_accept(new_conn->socket(),
        boost::bind(&Server::handle_accept, this,
          boost::asio::placeholders::error, new_conn));
          
  }

  void handle_accept(const boost::system::error_code& e, Connection_ptr conn)
  {
    if (!e)
    {
      // Соединение активировано
      // Принимаем данные
        
        conn->async_read(data_.get(),
          boost::bind(&Server::handle_read, this,
            boost::asio::placeholders::error, conn));
            
    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

  /// Handle completion of a read operation.
  void handle_read(const boost::system::error_code& e, Connection_ptr conn)
  {
    if (!e)
    {
        // чтото делаем сданными
        std::cout << data_.get() << std::endl;
        data_->Add(boost::shared_ptr<epam::Person>(new epam::Student("Server BSD'ec", epam::Gender::MAN, "1977.07.20", "XX-42", 3.56)));
      // Отправляем ответ
        conn->async_write(data_.get(),
          boost::bind(&Server::handle_write, this,
            boost::asio::placeholders::error));

        // Данные отправлены, запускаем новое ожидание подключения
        std::cout << "\nRestart ACCEPTRO\n";
        Connection_ptr new_conn(new Connection(acceptor_.io_service()));
        acceptor_.async_accept(new_conn->socket(),
            boost::bind(&Server::handle_accept, this,
            boost::asio::placeholders::error, new_conn));
    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

  void handle_write(const boost::system::error_code& e)
  {
    if(!e)
    {
        // Вот СЮДА НЕДОХОДИТ

    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

private:
  boost::asio::ip::tcp::acceptor acceptor_;
  boost::shared_ptr<epam::ListPerson> data_;
};

#endif // __SERVER_HPP__


это все собирается, запускается сервер, запускается клиент. Данные с клиента уходят, на сервере принимаються, к ним добавляется еще один елемент, они отправляются, перезапускается ожидание нового подключения (происходит в функции handle_read) И до функции handle_write на которой полный цикл работы должен завершиться, недоходит. Вылетает ошибка студии об ошибке отлабки, и несодержащая вообше не какой полезной информации. До клиента данные благополучно доходят. Ошибка возникает на стороне сервера. Найти или понять где я не в силах, вообще понятие не приложу в чем проблемма.

http://d.imagehost.org/view/0743/error

Возможно ктото предложит более лучьшую реализацию задуманного, которая возможно поможет устранить данную ошибку. Буду рад любой помощи.

Автор: cupper 30.12.2010, 15:42
после долгих экспериментов было выявлено что если сделать логику такой:

клиент отправляет данные серверу, данный принимает и выводит (и.е. по одному действия) то все корректно работает.

Если же так:

клиент отправляет данные первый раз, сервер принимает и на этом же соединении ожидает еще данных, после отправки клиентом второй порции данных сервер (тех же самых, точно также, но на уже открытом соединении) сервер (точно также получает их, но на уже открытый acceptor) не может их корректно получить, 

ошибка проиходит в connection.hpp
Код

async_read(T* data, Handler handler)
    {
        void (Connection::*f)(
            const boost::system::error_code&,
            T*, boost::tuple<Handler>) 
            = &Connection::handle_read_header<T, Handler>;
        
        boost::asio::async_read(socket_, boost::asio::buffer(inbound_header_),
            boost::bind(f, 
                this, boost::asio::placeholders::error, data,
                boost::make_tuple(handler)));

после выполнение операции цтения и переходе в 
Код
template<typename T, typename Handler>
    void handle_read_header(const boost::system::error_code& e,
        T* data, boost::tuple<Handler> handler)
    {
        if(e){
            boost::get<0>(handler)(e);
        }
        else{
            std::istringstream is(std::string(inbound_header_, header_length_));
            std::size_t inbound_data_size = 0;
            if(!(is >> std::hex >> inbound_data_size)){
                boost::system::error_code error(
                    boost::asio::error::invalid_argument);
                boost::get<0>(handler)(error);
                return;
            }
            
            inbound_data_.resize(inbound_data_size);
            void (Connection::*f)(
                const boost::system::error_code&,
                T*, boost::tuple<Handler>)
                = &Connection::handle_read_data<T, Handler>;
            
            boost::asio::async_read(socket_, boost::asio::buffer(inbound_data_),
                boost::bind(f, this, 
                    boost::asio::placeholders::error, data, handler));
        }
    }



inbound_header_ содержит уже не массив char из 8 символов, а хрен пойми что. Соответственно из за этого хрен пойми что условие в 
Код

if(!(is >> std::hex >> inbound_data_size)){
                boost::system::error_code error(
                    boost::asio::error::invalid_argument);
                boost::get<0>(handler)(error);
                return;
            }


является true и мы выходим с ошибкой :(

Автор: bsa 31.12.2010, 12:02
cupper, на твоем бы месте, я вместо T*data использовал что-то с управляемым временем жизни, например shared_array. Потому что не исключена ситуация, что хэндл из async_read срабатывает уже после того, как память из-под data будет освобождена.
И вообще, код у тебя ужасный. Может, правда, дело в том, что ты делаешь шаблоны...

Автор: cupper 10.1.2011, 01:37
Цитата(bsa @ 31.12.2010,  12:02)
cupper, на твоем бы месте, я вместо T*data использовал что-то с управляемым временем жизни, например shared_array. Потому что не исключена ситуация, что хэндл из async_read срабатывает уже после того, как память из-под data будет освобождена.
И вообще, код у тебя ужасный. Может, правда, дело в том, что ты делаешь шаблоны...

функции типа async_read приведенные выше это чернорабочие функции класса Connection, он ничего не знает о данных и не следит за ними. работа с данными происходит в классах Server и Client, там как раз реализованы умные указатели и прочее интеллектуальное поведение.


PS. коли код ужасен, дайте пожалуйста пример прекрасного кода для поставленных целей ?

Автор: cupper 10.1.2011, 18:47
Хммммм.... а может это быть баг студии или asio под Win? Взял исходники, навоял cmake сборщик, собрал на убунте... работает, ошибок нет, не вылетает. Сервер не падает, несколько раз запускаю клиент данные отправляются и принимаются и не каких ошибок... очень странно...

PS. Прикрепляю проект, в сборке для Visual Studio 2010 и Cmake, кому не лень можете проверить будут ли у вас какие либо ошибки при выполнении проявляться.

Автор: cupper 10.1.2011, 19:25
под VS2010 (для обоих необходимо наличие boost желательно последнего).


PS. перенесите пожалуйста тему в раздел "Сети".

Автор: cupper 11.1.2011, 13:07
ошибка кажется нашлась...

PS. ошибка была в том что терялся объект connection после передачи управления в 
Код

void handle_write(const boost::system::error_code& e)
  {
    if(!e)
    {
        // Вот СЮДА НЕДОХОДИТ

    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

на клиенте такой проблеммы не возникало потому что объект Cnnection существовал в единственно экземпляре и был членом класса Client, тобишь разрушался только когда разрушался сам объект класса Client, тобишь. 

В классе сервер, юзается немного другая логика, там членом класса является объект acceptor, а Connetction создается для каждого нового подключения, и то бишь уничтожался раньше чем нужно было. а это чуть ли не во время работы функции, и при обращении к членам Connection (из его же методов) их как бы уже и не небыло. 

Все это очень приблизительно, и пока не понятно, починил я непосредственно частный случай ошибки, или логику в целом. 

Автор: boostcoder 11.1.2011, 13:15
поздравляю smile 

Автор: cupper 11.1.2011, 20:03
Цитата(boostcoder @ 11.1.2011,  13:15)
поздравляю smile

вопрос лично тебе (так как ты говорил что ты с asio рабоал)

вот есть код
Код

class Server{
...
void handle_read(const boost::system::error_code& e, Connection_ptr conn, boost::shared_ptr<ListPerson> data_)
  {
    if (!e)
    {
          conn->async_write(data_,
             boost::bind(&Server::handle_write, this,
                boost::asio::placeholders::error));

          // Запускаем ожидание нового подключения
          Connection_ptr new_conn(new Connection(acceptor_.io_service()));
          acceptor_.async_accept(new_conn->socket(),
          boost::bind(&Server::handle_accept, this,
                    boost::asio::placeholders::error, new_conn));
        
    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }

  void handle_write(const boost::system::error_code& e)
  {
    if(!e)
    {

    }
    else
    {
      std::cerr << e.message() << std::endl;
    }
  }
...
}

Код

class Connection{
...
template<typename T, typename Handler>
    void async_write(const T data, Handler handler)
    {
                            // подготавливаем данные к отправке
        boost::asio::async_write(socket_, buffers, handler);    
    }
...
}
typedef boost::shared_ptr<Connection> Connection_ptr;

что бросается в глаза ? и есть ли тут грубая ошибка ?.

handle_write, ничего не делает. На нем как бы завершается работа для данного сеанса.

Автор: boostcoder 11.1.2011, 20:27
Цитата(cupper @  11.1.2011,  20:03 Найти цитируемый пост)
что бросается в глаза ?

бардак в структуре smile 

к примеру, класс Server. его основная задача - принимать соединения/логировать, и т.д.. но не общаться с клиентами. зачем ему методы handle_read() и handle_write() - загадка smile 
для общения, у тебя есть класс Connection. но вот что странно - он не наследует enable_shared_from_this smile 
как ты удаляешь объекты Connection ?

Powered by Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)