如何连接到“wss"上的特定端点[IBM 沃森] [英] How to connect to particular endpoint on "wss" [IBM Watson]

问题描述

我正在使用 boost 库连接到 IBM 网络服务器(语音到文本).

我被困在网络套接字握手阶段.的代码.我已经提到了

解决方案

哦，成功了！

问题出在 ws_.async_handshake 而我不得不使用 ws_.async_handshake_ex 如下:

ws_.async_handshake_ex(host_, "/speech-to-text/api/v1/recognize",[](request_type& reqHead){reqHead.insert(http::field::authorization,"Bearer {我的令牌}");},std::bind( &session::on_handshake, shared_from_this(), std::placeholders::_1));

token 与 apikey 不同.它需要按照 这篇文章中给出的方式生成

说明:

网址是"stream.watsonplatform.net/speech-to-text/api/v1/recognize"并且 authentication token 作为请求标头.

I am using the boost library to connect to IBM web-server (speech to text).

And I am stuck at web-socket handshaking stage. of the code. I have referred to the Web-socket async SSL client example.

Here is the code (similar as the above example with a few debug cout in between): Aim is to connect to wss://stream.watsonplatform.net/speech-to-text/api/v1/recognize?apikey={my apikey}

// Report a failure
void
fail(beast::error_code ec, char const* what)
{
    std::cerr << what << ": " << ec.message() << "\n";
}

// Sends a WebSocket message and prints the response
class session : public std::enable_shared_from_this<session>
{
    tcp::resolver resolver_;
    websocket::stream<ssl::stream<tcp::socket>> ws_;
    beast::multi_buffer buffer_;
    std::string host_;
    std::string text_;

public:
    // Resolver and socket require an io_context
    explicit
    session(net::io_context& ioc, ssl::context& ctx)
        : resolver_(ioc)
        , ws_(ioc, ctx)
    {
    }

    // Start the asynchronous operation
    void run(char const* host, char const* port, char const* text)
    {
        // Save these for later
        host_ = host;
        text_ = text;

        std::cout<< "Successfully reached: run operation:" << __LINE__<<" Resolving"<<std::endl;
        // Look up the domain name
        resolver_.async_resolve(
            host,
            port,
            std::bind(&session::on_resolve, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
    }

    void on_resolve(beast::error_code ec, tcp::resolver::results_type results)
    {
        if(ec)
            return fail(ec, "resolve");

        std::cout<< "Successfully reached: resolve operation:" << __LINE__<<" Resolving"<<std::endl;
        // Make the connection on the IP address we get from a lookup
        net::async_connect(
            ws_.next_layer().next_layer(),
            results.begin(),
            results.end(),
            std::bind(&session::on_connect, shared_from_this(), std::placeholders::_1));
    }

    void on_connect(beast::error_code ec)
    {
        if(ec)
            return fail(ec, "connect");

        std::cout<< "Successfully reached: handshaking operation:" << __LINE__<<" Handshaking"<<std::endl;
        // Perform the SSL handshake
        ws_.next_layer().async_handshake(ssl::stream_base::client, std::bind(&session::on_ssl_handshake, shared_from_this(), std::placeholders::_1));
    }

    void on_ssl_handshake(beast::error_code ec)
    {
        if(ec)
            return fail(ec, "ssl_handshake");

        std::cout<< "Successfully reached: handshaking operation:" << __LINE__<<" Handshaking"<<std::endl;
        // Perform the websocket handshake
        ws_.async_handshake(host_, "/speech-to-text/api/v1/recognize", std::bind( &session::on_handshake, shared_from_this(), std::placeholders::_1));
    }

    void on_handshake(beast::error_code ec)
    {
        std::cout<< "Successfully reached: handshaking operation:" << __LINE__<<" Handshaking"<<std::endl;
        if(ec)
            return fail(ec, "handshake");

        std::cout<< "Successfully reached: handshaking operation:" << __LINE__<<" Send message"<<std::endl;
        // Send the message
        ws_.async_write(net::buffer(text_), std::bind(&session::on_write, shared_from_this(), std::placeholders::_1,
                                                                                            std::placeholders::_2));
    }

    void
    on_write(
        beast::error_code ec,
        std::size_t bytes_transferred)
    {
        boost::ignore_unused(bytes_transferred);

        if(ec)
            return fail(ec, "write");

        // Read a message into our buffer
        ws_.async_read(
            buffer_,
            std::bind(
                &session::on_read,
                shared_from_this(),
                std::placeholders::_1,
                std::placeholders::_2));
    }

    void
    on_read(
        beast::error_code ec,
        std::size_t bytes_transferred)
    {
        boost::ignore_unused(bytes_transferred);

        if(ec)
            return fail(ec, "read");

        // Close the WebSocket connection
        ws_.async_close(websocket::close_code::normal,
            std::bind(
                &session::on_close,
                shared_from_this(),
                std::placeholders::_1));
    }

    void
    on_close(beast::error_code ec)
    {
        if(ec)
            return fail(ec, "close");

        // If we get here then the connection is closed gracefully

        // The buffers() function helps print a ConstBufferSequence
        std::cout << beast::buffers(buffer_.data()) << std::endl;
    }
};

//------------------------------------------------------------------------------

int main(int argc, char** argv)
{
    auto const host = "stream.watsonplatform.net";
    auto const port = "443";
    auto const text = "speech-to-text/api/v1/recognize";//apikey={my apikey}

    std::cout<< "Successfully reached: Main function"<<std::endl;
    // The io_context is required for all I/O
    net::io_context ioc;

    // The SSL context is required, and holds certificates
    ssl::context ctx{ssl::context::sslv23_client};
    std::cout<< "Successfully reached: SSL context to hold certificates"<<std::endl;

    // This holds the root certificate used for verification
    load_root_certificates(ctx);

    std::cout<< "Successfully reached: Loading root certificates - Goes to Launch asyn operation"<<std::endl;
    // Launch the asynchronous operation
    std::make_shared<session>(ioc, ctx)->run(host, port, text);

    std::cout<< "Successfully reached: Launched asyn operation"<<std::endl;
    // Run the I/O service. The call will return when
    // the socket is closed.
    ioc.run();

    return EXIT_SUCCESS;
}

I am getting the output on console as :

Successfully reached: Main function

Successfully reached: SSL context to hold certificates

Successfully reached: Loading root certificates - Goes to Launch asyn operation

Successfully reached: run operation:71 Resolving

Successfully reached: Launched asyn operation

Successfully reached: resolve operation:84 Resolving

Successfully reached: handshaking operation:98 Handshaking

Successfully reached: handshaking operation:108 Handshaking

Successfully reached: handshaking operation:115 Handshaking

handshake: The WebSocket handshake was declined by the remote peer

Here I am A bit confused where the error has occured on_ssl_handshake or on_handshake and how to accomplish the above "Aim".

Kindly provide a resolution.

regards and Thanks

Wireshark entries:

解决方案

Oh it worked!

the problem was with the ws_.async_handshake instead I had to use the ws_.async_handshake_ex as below:

ws_.async_handshake_ex(host_, "/speech-to-text/api/v1/recognize",[](request_type& reqHead){reqHead.insert(http::field::authorization,"Bearer {my token}");},std::bind( &session::on_handshake, shared_from_this(), std::placeholders::_1));

The token is not the same as apikey. It needs to be generated as given in this post

Clarification:

The url is "stream.watsonplatform.net/speech-to-text/api/v1/recognize" and the authentication token goes as request header.

这篇关于如何连接到“wss"上的特定端点[IBM 沃森]的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！