登录
当前位置： 首页 > 知识库问答 >
问题：

在同一函数/程序中使用WebSocket++服务器和客户端

浦墨竹
2023-03-14

我的问题是如何设置WebSocket++服务器，并在相同的程序或函数中创建连接到此服务器的WebSocket++客户端？（用于测试）

详细信息：我想在我的C++程序中使用库WebSocket++在WebSocket上流数据。我有一个websocket客户端，它将数据发送到外部websocket服务器。

作为一个好的程序员，我试着写一些测试来检查一切都很好。因此，我想设置一个WebSocket++服务器来测试我从WebSocket++客户端发送的数据。

从这些示例中，我已经设法在一个程序中创建了一个服务器，在另一个程序中创建了一个客户机。就像一种魅力。当我尝试将服务器和客户机代码放在同一个程序中时出现了问题（代码给出在下面）：客户机无法连接到服务器，并且导致握手超时。我猜是ASIO的问题或者是线程的问题，但是我完全不知道该如何处理。

在我遇到的经典示例中，我必须将echo_server.start()替换为echo_server.poll()，以实现不停止的阻塞进程。它没有阻止，但它阻止客户端连接到服务器。

任何关于如何解决这个问题的建议都会有很大的帮助！！我应该用线还是别的什么？

下面是我试图运行的程序，我希望客户端连接到服务器。它是基于在这里和这里找到的教程的合并

#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/client.hpp>
#include <websocketpp/server.hpp>

#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/memory.hpp>

#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <sstream>

typedef websocketpp::server<websocketpp::config::asio> server;


using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;

// pull out the type of messages sent by our config
typedef server::message_ptr message_ptr;

// Define a callback to handle incoming messages
void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg);
void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg)
{
    std::cout << "on_message called with hdl: " << hdl.lock().get()
              << " and message: " << msg->get_payload()
              << std::endl;

    try {
        s->send(hdl, msg->get_payload(), msg->get_opcode());
    } catch (const websocketpp::lib::error_code& e) {
        std::cout << "Echo failed because: " << e
                  << "(" << e.message() << ")" << std::endl;
    }
}


typedef websocketpp::client<websocketpp::config::asio_client> client;

class connection_metadata {
public:
    typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;

    connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri)
        : m_id(id)
        , m_hdl(hdl)
        , m_status("Connecting")
        , m_uri(uri)
        , m_server("N/A")
        , m_error_reason("")
        ,m_messages()
    {}

    void on_open(client * c, websocketpp::connection_hdl hdl) {
        m_status = "Open";

        client::connection_ptr con = c->get_con_from_hdl(hdl);
        m_server = con->get_response_header("Server");
    }

    void on_fail(client * c, websocketpp::connection_hdl hdl) {
        m_status = "Failed";

        client::connection_ptr con = c->get_con_from_hdl(hdl);
        m_server = con->get_response_header("Server");
        m_error_reason = con->get_ec().message();
    }

    void on_close(client * c, websocketpp::connection_hdl hdl) {
        m_status = "Closed";
        client::connection_ptr con = c->get_con_from_hdl(hdl);
        std::stringstream s;
        s << "close code: " << con->get_remote_close_code() << " ("
          << websocketpp::close::status::get_string(con->get_remote_close_code())
          << "), close reason: " << con->get_remote_close_reason();
        m_error_reason = s.str();
    }

    void on_message(websocketpp::connection_hdl, client::message_ptr msg) {
        if (msg->get_opcode() == websocketpp::frame::opcode::text) {
            m_messages.push_back("<< " + msg->get_payload());
        } else {
            m_messages.push_back("<< " + websocketpp::utility::to_hex(msg->get_payload()));
        }
    }

    websocketpp::connection_hdl get_hdl() const {
        return m_hdl;
    }

    int get_id() const {
        return m_id;
    }

    std::string get_status() const {
        return m_status;
    }

    void record_sent_message(std::string message) {
        m_messages.push_back(">> " + message);
    }

    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
private:
    int m_id;
    websocketpp::connection_hdl m_hdl;
    std::string m_status;
    std::string m_uri;
    std::string m_server;
    std::string m_error_reason;
    std::vector<std::string> m_messages;
};

std::ostream & operator<< (std::ostream & out, connection_metadata const & data) {
    out << "> URI: " << data.m_uri << "\n"
        << "> Status: " << data.m_status << "\n"
        << "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
        << "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason) << "\n";
    out << "> Messages Processed: (" << data.m_messages.size() << ") \n";

    std::vector<std::string>::const_iterator it;
    for (it = data.m_messages.begin(); it != data.m_messages.end(); ++it) {
        out << *it << "\n";
    }

    return out;
}

class websocket_endpoint {
public:
    websocket_endpoint () :  m_endpoint(), m_thread(), m_connection_list(), m_next_id(0)
    {
        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);

        m_endpoint.init_asio();
        m_endpoint.start_perpetual();

        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(&client::run, &m_endpoint);
    }

    ~websocket_endpoint() {
        m_endpoint.stop_perpetual();
        for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
            if (it->second->get_status() != "Open") {
                // Only close open connections
                continue;
            }

            std::cout << "> Closing connection " << it->second->get_id() << std::endl;

            websocketpp::lib::error_code ec;
            m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
            if (ec) {
                std::cout << "> Error closing connection " << it->second->get_id() << ": "
                          << ec.message() << std::endl;
            }
        }
        m_thread->join();
    }

    int connect(std::string const & uri) {
        websocketpp::lib::error_code ec;

        client::connection_ptr con = m_endpoint.get_connection(uri, ec);

        if (ec) {
            std::cout << "> Connect initialization error: " << ec.message() << std::endl;
            return -1;
        }

        int new_id = m_next_id++;
        connection_metadata::ptr metadata_ptr = websocketpp::lib::make_shared<connection_metadata>(new_id, con->get_handle(), uri);
        m_connection_list[new_id] = metadata_ptr;

        con->set_open_handler(websocketpp::lib::bind(
            &connection_metadata::on_open,
            metadata_ptr,
            &m_endpoint,
            websocketpp::lib::placeholders::_1
        ));
        con->set_fail_handler(websocketpp::lib::bind(
            &connection_metadata::on_fail,
            metadata_ptr,
            &m_endpoint,
            websocketpp::lib::placeholders::_1
        ));
        con->set_close_handler(websocketpp::lib::bind(
            &connection_metadata::on_close,
            metadata_ptr,
            &m_endpoint,
            websocketpp::lib::placeholders::_1
        ));
        con->set_message_handler(websocketpp::lib::bind(
            &connection_metadata::on_message,
            metadata_ptr,
            websocketpp::lib::placeholders::_1,
            websocketpp::lib::placeholders::_2
        ));

        m_endpoint.connect(con);

        return new_id;
    }

    void close(int id, websocketpp::close::status::value code, std::string reason) {
        websocketpp::lib::error_code ec;

        con_list::iterator metadata_it = m_connection_list.find(id);
        if (metadata_it == m_connection_list.end()) {
            std::cout << "> No connection found with id " << id << std::endl;
            return;
        }

        m_endpoint.close(metadata_it->second->get_hdl(), code, reason, ec);
        if (ec) {
            std::cout << "> Error initiating close: " << ec.message() << std::endl;
        }
    }

    void send(int id, std::string message) {
        websocketpp::lib::error_code ec;

        con_list::iterator metadata_it = m_connection_list.find(id);
        if (metadata_it == m_connection_list.end()) {
            std::cout << "> No connection found with id " << id << std::endl;
            return;
        }

        m_endpoint.send(metadata_it->second->get_hdl(), message, websocketpp::frame::opcode::text, ec);
        if (ec) {
            std::cout << "> Error sending message: " << ec.message() << std::endl;
            return;
        }

        metadata_it->second->record_sent_message(message);
    }

    connection_metadata::ptr get_metadata(int id) const {
        con_list::const_iterator metadata_it = m_connection_list.find(id);
        if (metadata_it == m_connection_list.end()) {
            return connection_metadata::ptr();
        } else {
            return metadata_it->second;
        }
    }
private:
    typedef std::map<int,connection_metadata::ptr> con_list;

    client m_endpoint;
    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;

    con_list m_connection_list;
    int m_next_id;
};

int main() {
    bool done = false;
    std::string input;
    websocket_endpoint endpoint;
    server echo_server;

    // Set logging settings
    echo_server.set_access_channels(websocketpp::log::alevel::all);
    echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);

    // Initialize ASIO
    echo_server.init_asio();

    // Register our message handler
    echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));

    // Listen on port 9002
    echo_server.listen(9002);

    // Start the server accept loop
    echo_server.start_accept();

    // Start the ASIO io_service run loop
    echo_server.poll();
    // echo_server.run();
    //thread t(bind(&WSServer::poll,echo_server));
    //t.detach();

    while (!done) {
        std::cout << "Enter Command: ";
        std::getline(std::cin, input);

        if (input == "quit") {
            done = true;
        } else if (input == "help") {
            std::cout
                << "\nCommand List:\n"
                << "connect <ws uri>\n"
                << "send <connection id> <message>\n"
                << "close <connection id> [<close code:default=1000>] [<close reason>]\n"
                << "show <connection id>\n"
                << "help: Display this help text\n"
                << "quit: Exit the program\n"
                << std::endl;
        } else if (input.substr(0,7) == "connect") {
            int id = endpoint.connect(input.substr(8));
            if (id != -1) {
                std::cout << "> Created connection with id " << id << std::endl;
            }
        } else if (input.substr(0,4) == "send") {
            std::stringstream ss(input);

            std::string cmd;
            int id;
            std::string message = "";

            ss >> cmd >> id;
            std::getline(ss,message);

            endpoint.send(id, message);
        } else if (input.substr(0,5) == "close") {
            std::stringstream ss(input);

            std::string cmd;
            int id;
            int close_code = websocketpp::close::status::normal;
            std::string reason = "";

            ss >> cmd >> id >> close_code;
            std::getline(ss,reason);

            endpoint.close(id, (websocketpp::close::status::value)close_code, reason);
        } else if (input.substr(0,4) == "show") {
            int id = atoi(input.substr(5).c_str());

            connection_metadata::ptr metadata = endpoint.get_metadata(id);
            if (metadata) {
                std::cout << *metadata << std::endl;
            } else {
                std::cout << "> Unknown connection id " << id << std::endl;
            }
        } else {
            std::cout << "> Unrecognized Command" << std::endl;
        }
    }

    return 0;
}

编译此程序所需的cmakelists.txt如下所示

CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8)
FIND_PACKAGE(Boost 1.53 COMPONENTS random system thread REQUIRED)
IF(Boost_FOUND)
    MESSAGE(STATUS "Boost_INCLUDE_DIRS  : ${Boost_INCLUDE_DIRS}")
    MESSAGE(STATUS "Boost_LIBRARIES     : ${Boost_LIBRARIES}")
ENDIF()

INCLUDE_DIRECTORIES(SYSTEM ${Boost_INCLUDE_DIRS})
INCLUDE_DIRECTORIES(SYSTEM websocketpp)
ADD_EXECUTABLE(DemoWebSocket DemoWebSocket.cpp)
TARGET_LINK_LIBRARIES(DemoWebSocket
    ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_RANDOM_LIBRARY})
IF(WIN32)
    TARGET_LINK_LIBRARIES(DemoWebSocket wsock32 ws2_32)
ELSE()
    TARGET_LINK_LIBRARIES(DemoWebSocket pthread rt)
ENDIF()

共有1个答案

郑鸿朗
2023-03-14

解决方案包括创建一个线程，该线程创建WebSocket服务器并启动其运行。那么客户端代码就可以用在相同的函数中。

下面是允许在同一函数/程序中使用WebSocket++服务器和WebSocket++客户端的代码

void createServerEcho();
void createServerEcho()
{
    server echo_server;
    // Set logging settings
    echo_server.set_access_channels(websocketpp::log::alevel::all);
    echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
    // Initialize ASIO
    echo_server.init_asio();
    // Register our message handler
    echo_server.set_message_handler(bind(&on_message,&echo_server,::_1,::_2));
    // Listen on port 9002
    echo_server.listen(9002);
    // Start the server accept loop
    echo_server.start_accept();
    // Start the ASIO io_service run loop
    echo_server.run();
}

int main()
{
    websocket_endpoint endpoint;
    std::thread serverThread (createServerEcho);
    /*
     * Client code part with variable endpoint, with creation, connection, ...
     */
    serverThread.join();
}
 类似资料：
  • Java服务器和客户端在一个程序中

    我想同步2个集合。如果服务器端有什么变化，连接的客户端就会更新。我有一个非常基本的问题。我现在需要复制我的java项目，并在一个项目中编程服务器，在另一个项目中编程客户端吗？但这听起来像是相当多不必要的工作。我不能在一个项目中实现这一切，然后在一个主项目中启动服务器和客户端吗？我需要线程吗？我有点纠结于最好的方法是什么。提前谢谢。

  • 在同一个应用程序中启动管理服务器和客户端

    我正在使用spring boot 2.5.1和Java 11。 我试图在同一个应用程序中创建SpringBoot管理服务器和客户端，但是当我启动它时，控制台中出现以下错误。 裁判：https://github.com/codecentric/spring-boot-admin 错误 未能将应用程序注册为Spring-boot-admin（[http://localhost:8085/instanc

  • Websocket Autobahn Python客户端：如何使用服务器和客户端证书连接到服务器？

    websocket客户端（使用Autobahn/Python和Twisted）需要连接到websocket服务器：客户端需要向服务器提供其客户端证书，客户端需要检查服务器的证书。例如，这些证书是在Kubernetes minikube安装过程中创建的。特别地： 服务器证书（据我所知为X509格式） 客户端证书~/。minikube/客户。按键 我已经检查过，我可以成功地使用这些证书密钥使用发出库伯

  • Java服务器JavaScript客户端WebSocket

    问题内容： 我正在尝试在Java中的服务器和JavaScript客户端之间建立连接，但在客户端出现此错误： WebSocket与“ ws：//127.0.0.1：4444 /”的连接失败：在收到握手响应之前，连接已关闭 由于可能从未调用该函数，因此它可能保持在OPENNING状态。该不会被调用。 有人可以让我知道这里出了什么问题吗？ 服务器 服务器线程 游戏协议 客户 问题答案： 首先，您的两个代

  • 用nodejs客户端访问golang websocket服务器

    我是NodeJS的新手。假设我有一个用Golang的websocket包实现的echo服务器： nodejs客户机代码应该是什么样子？

  • 在远程服务器和客户端之间使用UDP

    我目前正在做一个项目，需要一个UDP通信之间的服务器亚马逊法兰克福）和几个主机（Arduino）。我需要能够发送JSON数据从服务器到主机通过UDP，它需要实时工作（时间是一个真正的限制在这里）。此外，主机将定期与服务器通话，通知服务器其状态。 我面临的问题是，虽然我可以ping服务器，但当我创建带有端口的UDP套接字时，我会得到这个错误（对于任何端口）： errno99:无法分配请求的地址 我也

相关问答

在远程服务器和客户端之间使用UDP使用tcp/ip的Java客户端服务器程序使用客户机/服务器的聊天程序Arduino websocket客户端和Tyrus websocket服务器消息通信问题？带有WebSocket服务器的ping客户端

相关文章

Rust 一个简单的TCP客户端和服务器应用程序：echo使用nio在Java中不阻塞客户端服务器聊天应用程序请你来说一下socket编程中服务器端和客户端主要用到哪些函数Java Socket客户端和服务器pyqt和websocket客户端。在后台听websocket

相关阅读

QQ浏览器-客户端-一面4399 服务器一面快手客户端工程师一面蚂蚁金服Android客户端一面面经Dubbo 服务调用之远程调用-同步调用

相关工具

移动短信Cmpp服务端，客户端多线程页面抓取服务器Xlight FTP服务器Instagram客户端CSharp 邮件服务器

相关文档

Seafile 服务器用户手册小米用户画像+服务使用文档DIY 一个实用的 miniLAPP 服务器小米数据处理和分析服务（EMR）使用指南IPsec VPN 服务器一键安装脚本
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.