package mplexer import ( "context" "errors" "fmt" "io" "net" "net/http" "os" "time" "git.coolaj86.com/coolaj86/go-telebitd/mplexer/packer" "github.com/gorilla/websocket" ) // Listener defines a listener for use with http servers type Listener struct { //ParentAddr net.Addr //Conns chan *Conn ws *websocket.Conn ctx context.Context parser *packer.Parser } // Listen creates a channel for connections and returns the listener func (m *MultiplexLocal) Listen(ctx context.Context) (*Listener, error) { authz, err := m.SortingHat.Authz() if nil != err { return nil, err } wsd := websocket.Dialer{} headers := http.Header{} headers.Set("Authorization", fmt.Sprintf("Bearer %s", authz)) // *http.Response wsconn, _, err := wsd.DialContext(ctx, m.Relay, headers) if nil != err { return nil, err } //conns := make(chan *packer.Conn) //parser := &packer.NewParser(ctx, conns) /* go func() { conn, err := packer.Accept() if err != nil { fmt.Fprintf(os.Stderr, "failed to accept new relayed connection: %s\n", err) return } conns <- conn }() */ handler := &Handler{} listener := &Listener{ //Conns: conns, parser: packer.NewParser(ctx, handler), } go m.listen(ctx, wsconn, listener) return listener, nil } type Handler struct { } func (h *Handler) WriteMessage(packer.Addr, []byte) { panic(errors.New("not implemented")) } func (m *MultiplexLocal) listen(ctx context.Context, wsconn *websocket.Conn, listener *Listener) { // will cancel if ws errors out or closes // (TODO: this may also be redundant) ctx, cancel := context.WithCancel(ctx) defer cancel() // Ping every 15 seconds, or stop listening go func() { for { time.Sleep(15 * time.Second) deadline := time.Now().Add(45 * time.Second) if err := wsconn.WriteControl(websocket.PingMessage, "", deadline); nil != err { fmt.Fprintf(os.Stderr, "failed to write ping message to websocket: %s\n", err) cancel() break } } }() // The write loop (which fails if ping fails) go func() { // TODO optimal buffer size b := make([]byte, 128*1024) for { n, err := listener.packer.Read(b) if n > 0 { if err := wsconn.WriteMessage(websocket.BinaryMessage, b); nil != err { fmt.Fprintf(os.Stderr, "failed to write packer message to websocket: %s\n", err) break } } if nil != err { if io.EOF != err { fmt.Fprintf(os.Stderr, "failed to read message from packer: %s\n", err) break } fmt.Fprintf(os.Stderr, "[TODO debug] closed packer: %s\n", err) break } } // TODO handle EOF as websocket.CloseNormal? message := websocket.FormatCloseMessage(websocket.CloseGoingAway, "closing connection") deadline := time.Now().Add(10 * time.Second) if err := wsconn.WriteControl(websocket.CloseMessage, message, deadline); nil != err { fmt.Fprintf(os.Stderr, "failed to write close message to websocket: %s\n", err) } _ = wsconn.Close() }() // The read loop (also fails if ping fails) for { _, message, err := wsconn.ReadMessage() if err != nil { fmt.Fprintf(os.Stderr, "failed to read message from websocket: %s\n", err) break } // _, err = listener.packer.Write(message) if err != nil { fmt.Fprintf(os.Stderr, "failed to process message from websocket: %s\n", err) break } } // just to be sure listener.packer.Close() wsconn.Close() return } /* // Feed will block while pushing a net.Conn onto Conns func (l *Listener) Feed(conn *Conn) { l.Conns <- conn } */ // net.Listener interface /* // Accept will block and wait for a new net.Conn func (l *Listener) Accept() (*Conn, error) { select { case conn, ok := <-l.Conns: if ok { return conn, nil } return nil, io.EOF case <-l.ctx.Done(): // TODO is another error more suitable? // TODO is this redundant? return nil, io.EOF } } */ func (l *Listener) Accept() (*packer.Conn, error) { return l.Accept() } // Close will close the Conns channel func (l *Listener) Close() error { //close(l.Conns) //return nil return l.packer.Close() } // Addr returns nil to fulfill the net.Listener interface func (l *Listener) Addr() net.Addr { // Addr may (or may not) return the original TCP or TLS listener's address //return l.ParentAddr return nil }