websocket

package
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 6, 2024 License: Apache-2.0 Imports: 15 Imported by: 0

README

websocket

Websocket is an extension package that makes the yRPC framework compatible with websocket protocol as specified in RFC 6455.

Usage

import ws "github.com/sqos/yrpc/mixer/websocket"

Test

import (
	"fmt"
	"net/http"
	"testing"
	"time"

	"github.com/sqos/yrpc"
	ws "github.com/sqos/yrpc/mixer/websocket"
	"github.com/sqos/yrpc/mixer/websocket/jsonSubProto"
	"github.com/sqos/yrpc/mixer/websocket/pbSubProto"
	"github.com/sqos/yrpc/plugin/auth"
)

type Arg struct {
	A int
	B int `param:"<range:1:>"`
}

type P struct{ yrpc.CallCtx }

func (p *P) Divide(arg *Arg) (int, *yrpc.Status) {
	return arg.A / arg.B, nil
}

func TestJSONWebsocket(t *testing.T) {
	srv := ws.NewServer("/", yrpc.PeerConfig{ListenPort: 9090})
	srv.RouteCall(new(P))
	go srv.ListenAndServe()

	time.Sleep(time.Second * 1)

	cli := ws.NewClient("/", yrpc.PeerConfig{})
	sess, stat := cli.Dial(":9090")
	if !stat.OK() {
		t.Fatal(stat)
	}
	var result int
	stat = sess.Call("/p/divide", &Arg{
		A: 10,
		B: 2,
	}, &result,
	).Status()
	if !stat.OK() {
		t.Fatal(stat)
	}
	t.Logf("10/2=%d", result)
	time.Sleep(time.Second)
}

func TestPbWebsocketTLS(t *testing.T) {
	srv := ws.NewServer("/abc", yrpc.PeerConfig{ListenPort: 9091})
	srv.RouteCall(new(P))
	srv.SetTLSConfig(yrpc.GenerateTLSConfigForServer())
	go srv.ListenAndServeProtobuf()

	time.Sleep(time.Second * 1)

	cli := ws.NewClient("/abc", yrpc.PeerConfig{})
	cli.SetTLSConfig(yrpc.GenerateTLSConfigForClient())
	sess, err := cli.DialProtobuf(":9091")
	if err != nil {
		t.Fatal(err)
	}
	var result int
	stat := sess.Call("/p/divide", &Arg{
		A: 10,
		B: 2,
	}, &result,
	).Status()
	if !stat.OK() {
		t.Fatal(stat)
	}
	t.Logf("10/2=%d", result)
	time.Sleep(time.Second)
}

func TestCustomizedWebsocket(t *testing.T) {
	srv := yrpc.NewPeer(yrpc.PeerConfig{})
	http.Handle("/ws", ws.NewPbServeHandler(srv, nil))
	go http.ListenAndServe(":9092", nil)
	srv.RouteCall(new(P))
	time.Sleep(time.Second * 1)

	cli := yrpc.NewPeer(yrpc.PeerConfig{}, ws.NewDialPlugin("/ws"))
	sess, stat := cli.Dial(":9092", pbSubProto.NewPbSubProtoFunc())
	if !stat.OK() {
		t.Fatal(stat)
	}
	var result int
	stat = sess.Call("/p/divide", &Arg{
		A: 10,
		B: 2,
	}, &result,
	).Status()
	if !stat.OK() {
		t.Fatal(stat)
	}
	t.Logf("10/2=%d", result)
	time.Sleep(time.Second)
}

func TestJSONWebsocketAuth(t *testing.T) {
	srv := ws.NewServer(
		"/auth",
		yrpc.PeerConfig{ListenPort: 9093},
		authChecker,
	)
	srv.RouteCall(new(P))
	go srv.ListenAndServe()

	time.Sleep(time.Second * 1)

	cli := ws.NewClient(
		"/auth",
		yrpc.PeerConfig{},
		authBearer,
	)
	sess, stat := cli.Dial(":9093")
	if !stat.OK() {
		t.Fatal(stat)
	}
	var result int
	stat = sess.Call("/p/divide", &Arg{
		A: 10,
		B: 2,
	}, &result,
	).Status()
	if !stat.OK() {
		t.Fatal(stat)
	}
	t.Logf("10/2=%d", result)
	time.Sleep(time.Second)
}

const clientAuthInfo = "client-auth-info-12345"

var authBearer = auth.NewBearerPlugin(
	func(sess auth.Session, fn auth.SendOnce) (stat *yrpc.Status) {
		var ret string
		stat = fn(clientAuthInfo, &ret)
		if !stat.OK() {
			return
		}
		yrpc.Infof("auth info: %s, result: %s", clientAuthInfo, ret)
		return
	},
	yrpc.WithBodyCodec('s'),
)

var authChecker = auth.NewCheckerPlugin(
	func(sess auth.Session, fn auth.RecvOnce) (ret interface{}, stat *yrpc.Status) {
		var authInfo string
		stat = fn(&authInfo)
		if !stat.OK() {
			return
		}
		yrpc.Infof("auth info: %v", authInfo)
		if clientAuthInfo != authInfo {
			return nil, yrpc.NewStatus(403, "auth fail", "auth fail detail")
		}
		return "pass", nil
	},
	yrpc.WithBodyCodec('s'),
)

func TestHandshakeWebsocketAuth(t *testing.T) {
	srv := yrpc.NewPeer(yrpc.PeerConfig{}, handshakePlugin)
	http.Handle("/token", ws.NewJSONServeHandler(srv, nil))
	go http.ListenAndServe(":9094", nil)
	srv.RouteCall(new(P))
	time.Sleep(time.Millisecond * 200)

	rawQuery := fmt.Sprintf("/token?%s=%s", clientAuthKey, clientAuthInfo)
	cli := yrpc.NewPeer(yrpc.PeerConfig{}, ws.NewDialPlugin(rawQuery))
	sess, stat := cli.Dial(":9094", jsonSubProto.NewJSONSubProtoFunc())
	if !stat.OK() {
		t.Fatal(stat)
	}
	var result int
	stat = sess.Call("/p/divide", &Arg{
		A: 10,
		B: 2,
	}, &result,
	).Status()
	if !stat.OK() {
		t.Fatal(stat)
	}
	t.Logf("10/2=%d", result)
	time.Sleep(time.Second)
}

const clientAuthKey = "access_token"
const clientUserID = "user-1234"

var handshakePlugin = ws.NewHandshakeAuthPlugin(
	func(r *http.Request) (sessionId string, status *yrpc.Status) {
		token := ws.QueryToken(clientAuthKey, r)
		yrpc.Infof("auth token: %v", token)
		if token != clientAuthInfo {
			return "", yrpc.NewStatus(yrpc.CodeUnauthorized, yrpc.CodeText(yrpc.CodeUnauthorized))
		}
		return clientUserID, nil
	},
	func(sess yrpc.Session) *yrpc.Status {
		yrpc.Infof("login userID: %v", sess.ID())
		return nil
	},
)

test command:

go test -v -run=TestJSONWebsocket
go test -v -run=TestPbWebsocketTLS
go test -v -run=TestCustomizedWebsocket
go test -v -run=TestJSONWebsocketAuth

Among them, TestJSONWebsocket's request body is:

{
  "seq": 0,
  "mtype": 1,
  "serviceMethod": "/p/divide",
  "meta": "",
  "bodyCodec": 106,
  "body": "{\"A\":10,\"B\":2}",
  "xferPipe": []
}

TestJSONWebsocket's response body is:

{
  "seq": 0,
  "mtype": 2,
  "serviceMethod": "/p/divide",
  "meta": "",
  "bodyCodec": 106,
  "body": "5",
  "xferPipe": []
}

Documentation

Overview

Package websocket is an extension package that makes the yRPC framework compatible with websocket protocol as specified in RFC 6455.

Copyright 2018-2023 HenryLee. All Rights Reserved. Copyright 2024 sqos. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2021-2023 HenryLee. All Rights Reserved. Copyright 2024 sqos. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewDialPlugin 

func NewDialPlugin(rootPath string) yrpc.Plugin

NewDialPlugin creates a websocket plugin for client.

func NewJSONServeHandler 

func NewJSONServeHandler(peer yrpc.Peer, handshake func(*ws.Config, *http.Request) error) http.Handler

NewJSONServeHandler creates a websocket json handler.

func NewPbServeHandler 

func NewPbServeHandler(peer yrpc.Peer, handshake func(*ws.Config, *http.Request) error) http.Handler

NewPbServeHandler creates a websocket protobuf handler.

func NewServeHandler 

func NewServeHandler(peer yrpc.Peer, handshake func(*ws.Config, *http.Request) error, protoFunc ...yrpc.ProtoFunc) http.Handler

NewServeHandler creates a websocket handler.

func NewWsProtoFunc 

func NewWsProtoFunc(subProto ...yrpc.ProtoFunc) yrpc.ProtoFunc

NewWsProtoFunc wraps a protocol to a new websocket protocol.

func QueryToken 

func QueryToken(tokenKey string, r *http.Request) (token string)

Types

type Acceptor 

type Acceptor func(sess yrpc.Session) *yrpc.Status

Acceptor provide authenticated yrpc.Session you can get the sessionID that your return by Checker()

type Checker 

type Checker func(r *http.Request) (sessionID string, status *yrpc.Status)

Checker deal with http.Request and your authenticate logic, the a sessionID returned will used by yrpc.Session.SetID(), if auth succeeded.

type Client 

type Client struct {
	yrpc.Peer
}

Client a websocket client

func NewClient 

func NewClient(rootPath string, cfg yrpc.PeerConfig, globalLeftPlugin ...yrpc.Plugin) *Client

NewClient creates a websocket client.

func (*Client) Dial 

func (c *Client) Dial(addr string, protoFunc ...yrpc.ProtoFunc) (yrpc.Session, *yrpc.Status)

Dial connects with the peer of the destination address.

func (*Client) DialJSON 

func (c *Client) DialJSON(addr string) (yrpc.Session, *yrpc.Status)

DialJSON connects with the JSON protocol.

func (*Client) DialProtobuf 

func (c *Client) DialProtobuf(addr string) (yrpc.Session, *yrpc.Status)

DialProtobuf connects with the Protobuf protocol.

type HandshakeAuthPlugin 

type HandshakeAuthPlugin struct {
	CheckFunc  Checker
	AcceptFunc Acceptor
}

func NewHandshakeAuthPlugin 

func NewHandshakeAuthPlugin(ckFn Checker, apFn Acceptor) *HandshakeAuthPlugin

NewHandshakeAuthPlugin creates a handshake auth plugin for server.

func (*HandshakeAuthPlugin) Name 

func (p *HandshakeAuthPlugin) Name() string

func (*HandshakeAuthPlugin) PostAccept 

func (p *HandshakeAuthPlugin) PostAccept(sess yrpc.Session, conn *ws.Conn) *yrpc.Status

func (*HandshakeAuthPlugin) PreHandshake 

func (p *HandshakeAuthPlugin) PreHandshake(r *http.Request) *yrpc.Status

type PostWebsocketAcceptPlugin 

type PostWebsocketAcceptPlugin interface {
	yrpc.Plugin
	PostAccept(sess yrpc.Session, conn *ws.Conn) *yrpc.Status
}

PreHandshake executes the PostWebsocketAcceptPlugin after websocket accepting connection

type PreWebsocketHandshakePlugin 

type PreWebsocketHandshakePlugin interface {
	yrpc.Plugin
	PreHandshake(r *http.Request) *yrpc.Status
}

PreHandshake executes the PreWebsocketHandshakePlugins before websocket handshake,

type Server 

type Server struct {
	yrpc.Peer
	// contains filtered or unexported fields
}

Server a websocket server

func NewServer 

func NewServer(rootPath string, cfg yrpc.PeerConfig, globalLeftPlugin ...yrpc.Plugin) *Server

NewServer creates a websocket server.

func (*Server) Close 

func (srv *Server) Close() error

Close closes the server.

func (*Server) Handle 

func (srv *Server) Handle(rootPath string, handler http.Handler)

Handle registers the handler for the given rootPath. If a handler already exists for rootPath, Handle panics.

func (*Server) HandleFunc 

func (srv *Server) HandleFunc(rootPath string, handler func(http.ResponseWriter, *http.Request))

HandleFunc registers the handler function for the given rootPath.

func (*Server) ListenAndServe 

func (srv *Server) ListenAndServe(protoFunc ...yrpc.ProtoFunc) (err error)

ListenAndServe listens on the TCP network address addr and then calls Serve with handler to handle requests on incoming connections. Accepted connections are configured to enable TCP keep-alives.

The handler is typically nil, in which case the DefaultServeMux is used.

ListenAndServe always returns a non-nil error.

If protoFunc is empty, JSON is used by default.

func (*Server) ListenAndServeJSON 

func (srv *Server) ListenAndServeJSON() error

ListenAndServeJSON listen and serve with the JSON protocol.

func (*Server) ListenAndServeProtobuf 

func (srv *Server) ListenAndServeProtobuf() error

ListenAndServeProtobuf listen and serve with the Protobuf protocol.

func (*Server) SetHandshake 

func (srv *Server) SetHandshake(handshake func(*ws.Config, *http.Request) error)

SetHandshake sets customized handshake function.

Source Files

View all Source files

Directories

Path Synopsis
Package jsonSubProto is implemented JSON socket communication protocol.
 Package jsonSubProto is implemented JSON socket communication protocol.
Package pbSubProto is implemented PROTOBUF socket communication protocol.
 Package pbSubProto is implemented PROTOBUF socket communication protocol.
pb
Package websocket implements a client and server for the WebSocket protocol as specified in RFC 6455.
 Package websocket implements a client and server for the WebSocket protocol as specified in RFC 6455.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.