标签: websocket

我正在尝试使用 Ruby 为我的团队编写一个简单的 Slack 聊天机器人。这有点粗糙，因为 Slack 没有对 Ruby 的官方支持。尽管如此，我已经能够使用我编写的代码打开 websocket 并监听 Slack 事件：

# frozen_string_literal: true

require "async"
require "async/io/stream"
require "async/http/endpoint"
require "async/websocket/client"
require "excon"
require "json"

module Slack
  class Client
    Error = Class.new(StandardError)
    AquisitionError = Class.new(Error)
    ConnectionError = Class.new(Error)

    CONNECTION_AQUISITION_ENDPOINT = "https://slack.com/api/apps.connections.open"

    def initialize
      @token = "my-app-token"
    end

    def connect
      connection_info = Excon.post(CONNECTION_AQUISITION_ENDPOINT, headers: {
        "Content-type": "application/x-www-form-urlencoded",
        Authorization:  "Bearer #{@token}",
      })

      result = JSON.parse(connection_info.body)

      raise(AquisitionError) unless result["ok"] # better error later

      websocket = Async::HTTP::Endpoint.parse(result["url"])

      Async do |_task|
        Async::WebSocket::Client.connect(websocket) …

I'm new to web sockets (specifically to socketIO interfaces, both client and server), and I wonder how basic JWT auth is usually implemented. How the headers are passed through. Should I add them to every socket listener or emit event? Or just once during the connection. Maybe the connection is already considered private because of the connection id?

I am using Socket.io-client v.4 and flask-socketio. I am interested in general practices and would be grateful for any information or your …

我正在从 Django 通道文档中制作一个示例，效果非常好！

我在日志中看到

HTTP GET /chat/lobby/ 200 [0.00, 127.0.0.1:43164]
WebSocket HANDSHAKING /ws/chat/lobby/ [127.0.0.1:43168]
WebSocket CONNECT /ws/chat/lobby/ [127.0.0.1:43168]

但是我无法连接 wscat 客户端

andrey@andrey-desktop:~$ wscat -c "ws://127.0.0.1:8000/ws/chat/lobby/"
error: Unexpected server response: 403

或邮递员 - 邮递员断开连接

我在日志中看到失败的尝试

WebSocket HANDSHAKING /ws/chat/lobby/ [127.0.0.1:43232]
WebSocket REJECT /ws/chat/lobby/ [127.0.0.1:43232]
WebSocket DISCONNECT /ws/chat/lobby/ [127.0.0.1:43232]

如何与其他客户端建立连接，而不仅仅是从 javascript/html 页面建立连接？

我知道终止硬关闭套接字不会让它挂起或像 close 那样发送更多数据包，并且终止在关闭套接字时发送不同的代码（1006 与 close 发送 1000）。所以这就提出了一个问题，当我不打算重新打开套接字时，为什么我还要使用 ws.close() ？我见过很多只使用 ws.close() 并且从不重新打开它的例子。它只是不为人所知或不标准，或者幕后有什么我不知道的吗？

我已经进行网络抓取很长时间了，最​​近决定通过 websocket 流抓取视频流。我完全理解 websockets 及其工作原理，但我不完全理解流媒体部分。我正在尝试使用 Python 3.10 获取 Base64 数据的流，当我尝试对其进行解码时，我发现它无法读取（正是因为它是来自视频流的数据）。我试图提取的流来自一家提供一些天气数据的公司，我需要获取这些数据，而无需使用 Selenium 或其他一些库进行测试。有什么有效的方法可以做到这一点吗？也许是一些性能良好的库，或者某种方式以某种方式从流中“读取”数据？

这是我从 websocket 获得的数据中得到的印象：

即使尝试将获得的base64解码为utf-8后，结果也与上图相同。

我的服务使用套接字通信收集并显示一些统计信息。一些客户端使用 WebSocket 协议通过 Web 浏览器连接到它，而其他客户端则使用使用常规套接字的 Windows 服务。

我这样创建了一个监听端口：

let on = "0.0.0.0:8081";
let server = std::net::TcpListener::bind(on)?;

while let Ok((stream, _)) = server.accept() {
  let peer_adr = stream.peer_addr().unwrap();
  if peer_adr.to_string().starts_with("127.0.0") {
     // socket
  } else {
     // web socket
     let ws = tungstenite::accept(stream)?;
  }
}

我尝试过 IP 检查来检测客户端的类型，这对于生产来说是不可接受的。

我的问题是：

1. 有没有更好的实现方式？
2. 是否有任何标准方法来检测每个传入流的类型？（就像是stream.protocol.start_with("ws")）

环境

Rust version: `1.74 - stable`
Extra crate: `tungstenite = { version = "0.20" }`

我正在制作一个需要从WebSocket安全服务器接收实时消息的程序.

我尝试使用JavaScript执行此任务,它工作得很漂亮!
但JavaScript无法满足我的项目需求.所以我想在Python中做同样的事情.但没有成功.

我正在努力解决的错误是:

[SSL:CERTIFICATE_VERIFY_FAILED]证书验证失败(_ssl.c:777)

我认为JavaScript没有这个问题,因为它使用浏览器来验证连接.

我在用什么:

• Python 3.6.4
• Anaconda3
• Windows 10

我真的不知道该怎么办.我已经搜索了很多.
我可以通过更改代码来解决这个问题吗？
我应该使用另一个lib来建立连接吗？
是Python还是Anaconda的问题？
这是一些我无法弄清楚的新手错误吗？

这是我的Python代码:

import websocket
import websocket
import threading
import time

def on_message(ws, message):
    print(message)

def on_error(ws, error):
    print(error)

def on_close(ws):
    print("### closed ###")

def on_open(ws):
    def run(*args):
        for i in range(3):
            time.sleep(1)
            data = ws.recv()
            print(data)
        time.sleep(1)
        ws.close()
        print("thread terminating...")
    thread.start_new_thread(run, ())



websocket.enableTrace(True)
ws = websocket.WebSocketApp("wss://stream.binance.com:9443/ws/bnbbtc@ticker",
                            on_message = on_message,
                            on_error = on_error,
                            on_close = on_close)
ws.on_open = on_open

ws.run_forever()

如果有人有兴趣,这是我的JavaScript代码:

var socket = new …

如果我在main或func home上的任何地方使用chan,应用程序会运行,但它并不真正起作用.没有错误抛出,但是,它不起作用.如果删除通道引用,它将恢复工作.通过在结构或全局通道中使用chan,应用程序停止工作.

在一个GET请求时,它返回h.Message从func home 由代码添加任何频道,GET请求不会返回消息.

https://play.golang.org/p/-ZVcLhZRRRG

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
    // _ "github.com/go-sql-driver/mysql"
)

type WMessage struct {
    Message string `json:"message"`
    ch      chan string
}

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

var Chann chan string

func (h *WMessage) home(w http.ResponseWriter, r *http.Request) {
    h.Message = "hey this is the message from home"

    fmt.Fprintln(w, h.Message)
    fmt.Println(<-h.ch)
}

func main() { …

我正在阅读有关如何从套接字断开连接或离开通道的phoenix文档。

我天真的理解是 channel#leave

取消订阅服务器事件，并指示通道在服务器上终止

并socket#disconnect维护通道服务器端，以便重新连接。

因此，我的问题是何时使用一个与另一个。

听起来有两种情况需要考虑：

1. 还有其他客户端订阅了相同的频道，因此#leave将切断他们的连接，而倾向于#disconnect。
2. 但是，如果存在用户/帐户损耗，则从不调用来leave维护服务器上的“死”通道，而对于长时间运行的进程，这可能是一个问题吗？

我在想这个吗？如果我们选择只使用#disconnect-roll，我们是否应该实施定期的清理任务以杀死长时间运行的“死”通道？

谢谢！

我在将WebSocket服务器放入Docker容器时遇到麻烦。

这是服务器代码，它使用“ connected”写入新连接。

// server.go
func RootHandler(w http.ResponseWriter, r *http.Request) {
    upgrader := websocket.Upgrader{ // (Uses gorilla/websocket)
        ReadBufferSize:  4096,
        WriteBufferSize: 4096,
    }

    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        panic(err)
    }

    if err = conn.WriteMessage(websocket.TextMessage, []byte("connected")); err != nil {
        panic(err)
    }
}

func main() {
    fmt.Println("server is running")

    // For graceful shutdown
    stop := make(chan os.Signal, 1)
    signal.Notify(stop, os.Interrupt)

    server := http.Server{Addr: "localhost:8000"}
    defer server.Close()

    http.HandleFunc("/", RootHandler)

    go func() {
        err := server.ListenAndServe()
        if err …