服务器端事件C ++实现? [英] Server-side-event C++ implementation?

问题描述

我正在尝试实现C ++服务器来为javascript EventSource生成事件，我正在使用cpprest构建它.从我在PHP或Node.js中看到的示例来看，它看起来很简单，但由于要在Firefox控制台中找到它，因此我必须缺少一些东西:

I'm trying to implement a C++ server to generate event for a javascript EventSource, I'm building it with cpprest. From the examples I've seen in PHP or Node.js, it looked pretty straight-forward but I must be missing something since I'm getting this in the Firefox console:

Firefox can’t establish a connection to the server at http://localhost:32123/data.

在使用邮递员时，我正确地收到了"data : test"，所以我认为我缺少一些续传，可能需要做的不仅仅是回复请求，而是我没有找到很好的解释说明应该工作了.如果您有一些文档可以指出，那将不胜感激！

With Postman, I'm correctly receiving "data : test" so I think I'm missing some continuation, probably have to do something more than just reply to the request, but I didn't find a good explanation on how this is supposed to work yet. If you have some documentation you could point me to, that would be greatly appreciated!

html页面脚本如下:

The html page script looks like this:

var source = new EventSource("http://localhost:32123/data");

source.onmessage = function (event) {
    document.getElementById("result1").innerHTML += event.data + "<br>";
};

C ++服务器响应:

The C++ server reponse :

wResponse.set_status_code(status_codes::OK);
wResponse.headers().add(U("Access-Control-Allow-Origin"), U("*"));
wResponse.set_body(U("data: test"));
iRequest.reply(wResponse);

服务器收到的请求:

GET /data HTTP/1.1
Accept: text/event-stream
Accept-Encoding: gzip, deflate
Accept-Language: en-us, en;q=0.5
Cache-Control: no-cache
Connection: keep-alive
Host: localhost:32123
Origin: null
Pragma: no-cache
User-Agent: Mozilla/5.0 (Windows NT6.1; Win64, x64; rv:61.0) Gecko/20100101 Firefox/61.0

推荐答案

在此处找到解决方案

这是一个小例子.它一点都不完美，但是可以正常工作.下一步是弄清楚如何存储连接，检查它们是否还活着，等等...

在达伦发表评论后更新答案

正确的解决方案似乎围绕着馈给绑定到设置为http_response主体的basic_istream<uint8_t>的producer_consumer_buffer<char>.

The proper solution seems to revolve around feeding a producer_consumer_buffer<char> bound to a basic_istream<uint8_t> that is set as the http_response body.

然后，一旦完成http_request::reply，连接将保持打开状态，直到关闭缓冲区为止，这可以通过wBuffer.close(std::ios_base::out).wait();完成.

Then once the http_request::reply is done, the connection will stay opened until the buffer is closed, which could be done with wBuffer.close(std::ios_base::out).wait();.

我不确定100％，但似乎wBuffer.sync().wait();的行为类似于PHP flush命令，将在类似的 event-providing-server 方案中使用.

I'm not 100% sure, but it seems that wBuffer.sync().wait(); acts like the PHP flush command would be used in a similar event-providing-server scenario.

下面添加了一个工作示例.

A working example has been added below.

显然，这不是一个完整的解决方案.管理连接和所有连接仍然有更多乐趣.用make_unique实例化一些Connection并将它们存储到事件中访问的容器中可能是我要走的路...

This is not a complete solution, obviously. There's still more fun ahead with managing the connections and all. Instanciating some Connection with make_unique and storing them to an container visited on events would probably be my way to go...

main.cpp

#include "cpprest/uri.h"
#include "cpprest/producerconsumerstream.h"
#include "cpprest/http_listener.h"

using namespace std;
using namespace web;
using namespace http;
using namespace utility;
using namespace concurrency;
using namespace http::experimental::listener;

struct MyServer
{
  MyServer(string_t url);
  pplx::task<void> open()  { return mListener.open(); };
  pplx::task<void> close() { return mListener.close(); };

private:

  void handleGet(http_request iRequest);
  http_listener mListener;
};

MyServer::MyServer(utility::string_t url) : mListener(url)
{
  mListener.support(methods::GET, bind(&MyServer::handleGet, this, placeholders::_1));
}

void MyServer::handleGet(http_request iRequest)
{
  ucout << iRequest.to_string() << endl;

  http_response wResponse;

  // Setting headers
  wResponse.set_status_code(status_codes::OK);
  wResponse.headers().add(header_names::access_control_allow_origin, U("*"));
  wResponse.headers().add(header_names::content_type, U("text/event-stream"));

  // Preparing buffer
  streams::producer_consumer_buffer<char> wBuffer;
  streams::basic_istream<uint8_t> wStream(wBuffer);
  wResponse.set_body(wStream);

  auto wReplyTask = iRequest.reply(wResponse);

  wBuffer.putn_nocopy("data: a\n",10).wait();
  wBuffer.putn_nocopy("data: b\n\n",12).wait();
  wBuffer.sync().wait();  // seems equivalent to 'flush'

  this_thread::sleep_for(chrono::milliseconds(2000));

  wBuffer.putn_nocopy("data: c\n", 10).wait();
  wBuffer.putn_nocopy("data: d\n\n", 12).wait();
  wBuffer.sync().wait();
  // wBuffer.close(std::ios_base::out).wait();    // closes the connection
  wReplyTask.wait();      // blocking!
}

unique_ptr<MyServer> gHttp;

void onInit(const string_t iAddress)
{
  uri_builder wUri(iAddress);
  auto wAddress = wUri.to_uri().to_string();
  gHttp = unique_ptr<MyServer>(new MyServer(wAddress));

  gHttp->open().wait();
  ucout << string_t(U("Listening for requests at: ")) << wAddress << endl;

}

void onShutdown()
{
  gHttp->close().wait();
}


void main(int argc, wchar_t* argv[])
{

  onInit(U("http://*:32123"));

  cout << "Wait until connection occurs..." << endl;
  getchar();

  onShutdown();
}

sse.htm

<!DOCTYPE html>
<html lang="en-US">
<head>
<meta charset="utf-8">
</head>
    <body>
        <div id="result"></div>
    </body>
</html>

<script>

    if (typeof (EventSource) !== undefined)
    {
        document.getElementById("result").innerHTML += "SSE supported" + "<br>";
    } 
    else
    {
        document.getElementById("result").innerHTML += "SSE NOT supported" + "<br>";
    }

    var source = new EventSource("http://localhost:32123/");

    source.onopen = function ()
    {
        document.getElementById("result").innerHTML += "open" + "<br>";
    };

    source.onerror = function ()
    {        
        document.getElementById("result").innerHTML += "error" + "<br>";
    };

    source.onmessage = function (event) {
        document.getElementById("result").innerHTML += event.data + "<br>";
    };

</script>

这篇关于服务器端事件C ++实现?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！