Golang Gorilla Websocket mit Web Proxy

Question

Ich arbeite an einem POC mit Gorilla/Websocket, um über einen Web Proxy mit der Websocket Check Website "echo.websocket.org" zu kommunizieren.

Ich benutze den kostenlosen Online-Proxy "hide.me/en/" zum Testen.

Wenn ich einfach versuche, mit "echo.websocket.org" (Server-Seite) zu kommunizieren, erreiche mein Websocket POC auf der Client-Seite die Antwort.

Aber wenn ich versuche, die Proxy-Geste an, geht alles schief :(

Hier ist ein Beispiel von meinem Code ist:

package main 

import (
    "flag" 
    "log" 
    "net/url" 
    "os" 
    "os/signal" 
    "time" 

    "github.com/gorilla/websocket" 
    "net/http" 
) 

var addrWebsocket = flag.String("addrWebsocket", "echo.websocket.org", "http service address") 

func main() { 
    flag.Parse() 
    log.SetFlags(0) 

    interrupt := make(chan os.Signal, 1) 
    signal.Notify(interrupt, os.Interrupt) 

    //Initialize the WebSocket URL and the Path to follow 
    uWS := url.URL{Scheme: "wss", Host: *addrWebsocket} 

    //Initialize the Proxy URL and the Path to follow 
    uProxy, _ := url.Parse("https://hide.me/en/proxy") 

    //Set the Dialer (especially the proxy) 
    dialer := websocket.Dialer{ 
     Proxy: http.ProxyURL(uProxy), 
    } 
    //dialer := websocket.DefaultDialer ==> with this default dialer, it works ! 

    c, _, err := dialer.Dial(uWS.String(), nil) // ==> With the proxy config, it fails here ! 
    defer c.Close() 

    done := make(chan struct{}) 

    go func() { 
     defer c.Close() 
     defer close(done) 
     for { 
      _, message, err := c.ReadMessage() 
      if err != nil { 
       log.Println("read:", err) 
       return 
      } 
      log.Printf("recv: %s", message) 
     } 
    }() 

    ticker := time.NewTicker(time.Second) 
    defer ticker.Stop() 

    for { 
     select { 
     case t := <-ticker.C: 
      err := c.WriteMessage(websocket.TextMessage, []byte(t.String())) 
      if err != nil { 
       log.Println("write:", err) 
       return 
      } 
     case <-interrupt: 
      log.Println("interrupt") 
      err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")) 
      if err != nil { 
       log.Println("write close:", err) 
       return 
      } 
       select { 
       case <-done: 
       case <-time.After(time.Second): 
       } 
      c.Close() 
      return 
     } 
    } 
} 

ich ein sehr Anfänger in Go bin nicht so tun zögern, mich zu korrigieren, wenn mein Code un nicht klar und sauber.

Vielen Dank für Ihre Hilfe!

Answer 1

Der Code korrekt ist. Der Server https://hide.me ist kein Proxy-Server.