mirror of
https://github.com/taigrr/wasm-experiments
synced 2025-01-18 04:03:21 -08:00
253 lines
6.5 KiB
Go
253 lines
6.5 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
_ "google.golang.org/genproto/googleapis/rpc/errdetails"
|
|
spb "google.golang.org/genproto/googleapis/rpc/status"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/metadata"
|
|
"google.golang.org/grpc/status"
|
|
|
|
"github.com/johanbrandhorst/fetch"
|
|
"github.com/johanbrandhorst/wasm-experiments/grpc/proto/server"
|
|
)
|
|
|
|
// Build with Go WASM fork
|
|
//go:generate rm -f ./html/test.wasm
|
|
//go:generate bash -c "GOOS=js GOARCH=wasm GOROOT=$GOPATH/src/github.com/neelance/go/ $GOPATH/src/github.com/neelance/go/bin/go build -o ./html/test.wasm frontend.go"
|
|
|
|
// Integrate generated JS into a Go file for static loading.
|
|
//go:generate bash -c "go run assets_generate.go"
|
|
|
|
func main() {
|
|
s := newClientConn("", "web.Backend")
|
|
req := &server.GetUserRequest{
|
|
UserId: "1234",
|
|
}
|
|
resp := new(server.User)
|
|
err := s.Invoke(context.Background(), "GetUser", req, resp)
|
|
if err != nil {
|
|
st := status.Convert(err)
|
|
fmt.Println(st.Code(), st.Message(), st.Details())
|
|
return
|
|
}
|
|
fmt.Println(resp.GetId())
|
|
req.UserId = "123"
|
|
err = s.Invoke(context.Background(), "GetUser", req, resp)
|
|
if err != nil {
|
|
st := status.Convert(err)
|
|
fmt.Println(st.Code(), st.Message(), st.Details())
|
|
return
|
|
}
|
|
fmt.Println(resp.GetId())
|
|
}
|
|
|
|
type ClientConn struct {
|
|
client *http.Client
|
|
service string
|
|
host string
|
|
}
|
|
|
|
func newClientConn(host, service string) *ClientConn {
|
|
return &ClientConn{
|
|
client: &http.Client{
|
|
Transport: &fetch.Transport{},
|
|
},
|
|
service: service,
|
|
host: host,
|
|
}
|
|
}
|
|
|
|
func (cc *ClientConn) Invoke(ctx context.Context, method string, in, out proto.Message) error {
|
|
b, err := proto.Marshal(in)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
|
|
bufHeader := make([]byte, 5)
|
|
|
|
// Write length of b into buf
|
|
binary.BigEndian.PutUint32(bufHeader[1:], uint32(len(b)))
|
|
|
|
req, err := http.NewRequest(
|
|
"POST",
|
|
strings.Join([]string{cc.host, cc.service, method}, "/"),
|
|
bytes.NewBuffer(append(bufHeader, b...)),
|
|
)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
req = req.WithContext(ctx)
|
|
addHeaders(req)
|
|
|
|
resp, err := cc.client.Do(req)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
st := statusFromHeaders(resp.Header)
|
|
if st.Code() != codes.OK {
|
|
return st.Err()
|
|
}
|
|
|
|
msgHeader := make([]byte, 5)
|
|
for {
|
|
_, err := resp.Body.Read(msgHeader)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
// 1 in MSB signifies that this is the trailer. Break loop.
|
|
// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md#protocol-differences-vs-grpc-over-http2
|
|
if msgHeader[0]>>7 == 1 {
|
|
break
|
|
}
|
|
|
|
msgLen := binary.BigEndian.Uint32(msgHeader[1:])
|
|
|
|
msg := make([]byte, msgLen)
|
|
_, err = resp.Body.Read(msg)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
err = proto.Unmarshal(msg, out)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
}
|
|
|
|
if msgHeader[0]&1 == 0 {
|
|
trailers, err := readTrailers(resp.Body)
|
|
if err != nil {
|
|
return status.Error(codes.Internal, err.Error())
|
|
}
|
|
st = statusFromHeaders(trailers)
|
|
if st.Code() != codes.OK {
|
|
return st.Err()
|
|
}
|
|
} else {
|
|
// TODO(johanbrandhorst): Support compressed trailers
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func addHeaders(req *http.Request) {
|
|
// TODO: Add more headers
|
|
// https://github.com/grpc/grpc-go/blob/590da37e2dfb4705d8ebd9574ce4cb75295d9674/transport/http2_client.go#L356
|
|
req.Header.Add("content-type", "application/grpc-web+proto")
|
|
if dl, ok := req.Context().Deadline(); ok {
|
|
timeout := dl.Sub(time.Now())
|
|
req.Header.Add("grpc-timeout", encodeTimeout(timeout))
|
|
}
|
|
md, ok := metadata.FromOutgoingContext(req.Context())
|
|
if ok {
|
|
for h, vs := range md {
|
|
for _, v := range vs {
|
|
req.Header.Add(h, v)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const maxTimeoutValue int64 = 100000000 - 1
|
|
|
|
// Copied from grpc-go
|
|
// https://github.com/grpc/grpc-go/blob/590da37e2dfb4705d8ebd9574ce4cb75295d9674/transport/http_util.go#L388
|
|
// div does integer division and round-up the result. Note that this is
|
|
// equivalent to (d+r-1)/r but has less chance to overflow.
|
|
func div(d, r time.Duration) int64 {
|
|
if m := d % r; m > 0 {
|
|
return int64(d/r + 1)
|
|
}
|
|
return int64(d / r)
|
|
}
|
|
|
|
// Copied from grpc-go
|
|
// https://github.com/grpc/grpc-go/blob/590da37e2dfb4705d8ebd9574ce4cb75295d9674/transport/http_util.go#L398
|
|
func encodeTimeout(t time.Duration) string {
|
|
if t <= 0 {
|
|
return "0n"
|
|
}
|
|
if d := div(t, time.Nanosecond); d <= maxTimeoutValue {
|
|
return strconv.FormatInt(d, 10) + "n"
|
|
}
|
|
if d := div(t, time.Microsecond); d <= maxTimeoutValue {
|
|
return strconv.FormatInt(d, 10) + "u"
|
|
}
|
|
if d := div(t, time.Millisecond); d <= maxTimeoutValue {
|
|
return strconv.FormatInt(d, 10) + "m"
|
|
}
|
|
if d := div(t, time.Second); d <= maxTimeoutValue {
|
|
return strconv.FormatInt(d, 10) + "S"
|
|
}
|
|
if d := div(t, time.Minute); d <= maxTimeoutValue {
|
|
return strconv.FormatInt(d, 10) + "M"
|
|
}
|
|
// Note that maxTimeoutValue * time.Hour > MaxInt64.
|
|
return strconv.FormatInt(div(t, time.Hour), 10) + "H"
|
|
}
|
|
|
|
// Copied from grpc-go
|
|
// https://github.com/grpc/grpc-go/blob/b94ea975f3beb73799fac17cc24ee923fcd3cb5c/transport/http_util.go#L213
|
|
func decodeBinHeader(v string) ([]byte, error) {
|
|
if len(v)%4 == 0 {
|
|
// Input was padded, or padding was not necessary.
|
|
return base64.StdEncoding.DecodeString(v)
|
|
}
|
|
return base64.RawStdEncoding.DecodeString(v)
|
|
}
|
|
|
|
func readTrailers(in io.Reader) (http.Header, error) {
|
|
s := bufio.NewScanner(in)
|
|
trailers := http.Header{}
|
|
for s.Scan() {
|
|
v := s.Text()
|
|
kv := strings.SplitN(v, ": ", 2)
|
|
if len(kv) != 2 {
|
|
return nil, errors.New("malformed header: " + v)
|
|
}
|
|
trailers.Add(kv[0], kv[1])
|
|
}
|
|
|
|
return trailers, s.Err()
|
|
}
|
|
|
|
func statusFromHeaders(h http.Header) *status.Status {
|
|
details := h.Get("grpc-status-details-bin")
|
|
if details != "" {
|
|
b, err := decodeBinHeader(details)
|
|
if err != nil {
|
|
return status.New(codes.Internal, "malformed grps-status-details-bin header: "+err.Error())
|
|
}
|
|
s := &spb.Status{}
|
|
err = proto.Unmarshal(b, s)
|
|
if err != nil {
|
|
return status.New(codes.Internal, "malformed grps-status-details-bin header: "+err.Error())
|
|
}
|
|
return status.FromProto(s)
|
|
}
|
|
sh := h.Get("grpc-status")
|
|
if sh != "" {
|
|
val, err := strconv.Atoi(sh)
|
|
if err != nil {
|
|
return status.New(codes.Internal, "malformed grpc-status header: "+err.Error())
|
|
}
|
|
return status.New(codes.Code(val), h.Get("grpc-message"))
|
|
}
|
|
return status.New(codes.OK, "")
|
|
}
|