连接到Poloniex Push-API

我想连接到Poloniex的Push API.在他们的页面上,他们写下以下内容

要使用推送API,请连接到wss://api.poloniex.com并订阅所需的订阅源.

wss = WebSocket安全 - > SSL保护

他们还举例说明了Node.js和Autobahn | JS:

var autobahn = require('autobahn');
var wsuri = "wss://api.poloniex.com";
var connection = new autobahn.Connection({
  url: wsuri,
  realm: "realm1"
});

connection.onopen = function (session) {
        function marketEvent (args,kwargs) {
                console.log(args);
        }
        function tickerEvent (args,kwargs) {
                console.log(args);
        }
        function trollboxEvent (args,kwargs) {
                console.log(args);
        }
        session.subscribe('BTC_XMR', marketEvent);
        session.subscribe('ticker', tickerEvent);
        session.subscribe('trollbox', trollboxEvent);
}

connection.onclose = function () {
  console.log("Websocket connection closed");
}

connection.open();

但是,我不想使用JavaScript,而是使用C++.还有一个用于C++的Autobahn-Library,叫做Autobahn | CPP.我已经安装了它并尝试运行他们的订阅者示例代码,几乎没有修改(基本上只是硬编码地址和端口):

#include 
#include 
#include 
#include 
#include 

void topic1(const autobahn::wamp_event& event)
{
    std::cerr << "received event: " << event.argument(0) << std::endl;
}
using namespace boost;
using namespace boost::asio;
using namespace boost::asio::ip;
int main()
{
    try {

        boost::asio::io_service io;
        boost::asio::ip::tcp::socket socket(io);

        bool debug = true;
        auto session = std::make_shared<
                autobahn::wamp_session>(io, socket, socket, debug);

        boost::future start_future;
        boost::future join_future;

        boost::asio::ip::tcp::endpoint rawsocket_endpoint( boost::asio::ip::address::from_string("173.236.42.218"), 443/*8000=standard*/);


        socket.async_connect(rawsocket_endpoint,
            [&](boost::system::error_code ec) {
                if (!ec) {
                    std::cerr << "connected to server" << std::endl;

                    start_future = session->start().then([&](boost::future started) {
                        if (started.get()) {
                            std::cerr << "session started" << std::endl;
                            join_future = session->join("realm1").then([&](boost::future s) {
                                std::cerr << "joined realm: " << s.get() << std::endl;
                                session->subscribe("ticker", &topic1);
                            });
                        } else {
                            std::cerr << "failed to start session" << std::endl;
                            io.stop();
                        }
                    });
                } else {
                    std::cerr << "connect failed: " << ec.message() << std::endl;
                    io.stop();
                }
            }
        );

        std::cerr << "starting io service" << std::endl;
        io.run();
        std::cerr << "stopped io service" << std::endl;
    }
    catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    return 0;
}

有几件事情需要解释一下:我发现了IP-ADRESS 173.236.42.218通过简单的ping命令api.poloniex.com.

端口443是标准SSL端口.我尝试使用8000的标准WAMP/WebSocket端口,但服务器不接受.80也不被接受.

因此,如果我启动该程序,输出如下:

开始io服务

连接到服务器

然后,没有任何反应.所以代码必须停留在session_start(),在那里执行WS握手,当你在第80行查看wamp_session.ipp时可以看到的内容.

在我看来,问题是API想要使用安全连接(ws s://).看起来这段代码不会尝试创建SSL加密连接,我不知道如何告诉会话我需要一个安全的连接.

编辑:在这个问题中,作者说Autobahn无法处理混合的http/wamp服务器,并且在使用WebSocket协议之前首先需要升级 http-request.我知道Poloniex使用这种混合类型,但我试图用Autobahn访问API JS已经和它在那里工作正常,也发送升级请求.所以也许这是一辆高速公路 CPP问题？

编辑2:如果以上是真的,是否可以自己发送Http-Update-Request,甚至可能在连接上加上SSL加密？我不确定,因为这可能会干扰图书馆.

不,不,这不是迟到的回应.迟到或者没有,我相信这对你来说可能更直接一个解决方案Bobface(以及其他任何与之斗争的人).我不愿意这样做,因为竞争对手可能会使用它.但是,没有竞争的生活是什么!？无聊,就是这样.此外,我希望有人来到我面前发布,所以你走了!是你想看的改变,对吧？

下面,您将找到一个利用websocketpp和autobahn | cpp连接到Poloniex的push api的实现.在这种情况下,它将收到BTC_ETH的书籍更新.

一般来说,这就是如何利用websocketpp和autobahn | cpp连接到实现WAMP协议的安全Web套接字服务器(又名wss://ip-address.com:port).

干杯!

包括:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

码:

typedef websocketpp::client client;
typedef autobahn::wamp_websocketpp_websocket_transport websocket_transport;

try {
    //std::cerr << "Connecting to realm: " << parameters->realm() << std::endl;

    boost::asio::io_service io;
    //bool debug = parameters->debug();

    client ws_client;
    ws_client.init_asio(&io);
    ws_client.set_tls_init_handler([&](websocketpp::connection_hdl) {
        return websocketpp::lib::make_shared(boost::asio::ssl::context::tlsv12_client);
    });
    auto transport = std::make_shared < autobahn::wamp_websocketpp_websocket_transport >(
            ws_client, "wss://api.poloniex.com:443", true);

    // create a WAMP session that talks WAMP-RawSocket over TCP
    auto session = std::make_shared(io, true);

    transport->attach(std::static_pointer_cast(session));

    // Make sure the continuation futures we use do not run out of scope prematurely.
    // Since we are only using one thread here this can cause the io service to block
    // as a future generated by a continuation will block waiting for its promise to be
    // fulfilled when it goes out of scope. This would prevent the session from receiving
    // responses from the router.
    boost::future connect_future;
    boost::future start_future;
    boost::future join_future;
    boost::future subscribe_future;
    connect_future = transport->connect().then([&](boost::future connected) {
        try {
            connected.get();
        } catch (const std::exception& e) {
            std::cerr << e.what() << std::endl;
            io.stop();
            return;
        }

        std::cerr << "transport connected" << std::endl;

        start_future = session->start().then([&](boost::future started) {
            try {
                started.get();
            } catch (const std::exception& e) {
                std::cerr << e.what() << std::endl;
                io.stop();
                return;
            }

            std::cerr << "session started" << std::endl;

            join_future = session->join("realm1").then([&](boost::future joined) {
                try {
                    std::cerr << "joined realm: " << joined.get() << std::endl;
                } catch (const std::exception& e) {
                    std::cerr << e.what() << std::endl;
                    io.stop();
                    return;
                }

                subscribe_future = session->subscribe("BTC_ETH", &on_topic1).then([&] (boost::future subscribed)
                {
                    try {
                        std::cerr << "subscribed to topic: " << subscribed.get().id() << std::endl;
                    }
                    catch (const std::exception& e) {
                        std::cerr << e.what() << std::endl;
                        io.stop();
                        return;
                    }

                });
            });
        });
    });

    std::cerr << "starting io service" << std::endl;
    io.run();
    std::cerr << "stopped io service" << std::endl;
}
catch (std::exception& e) {
    std::cerr << "exception: " << e.what() << std::endl;
    ret_var.successfully_ran = false;
    return ret_var;
}