gRPC vs REST Tradeoff Quiz

package main

import (
	"context"
	"fmt"
	"time"
)

// ClientParameters mirrors google.golang.org/grpc/keepalive.ClientParameters.
// We re-declare it here so the snippet is self-contained.
type ClientParameters struct {
	Time                time.Duration
	Timeout             time.Duration
	PermitWithoutStream bool
}

type ClientConn struct {
	Target    string
	Keepalive ClientParameters
}

func newClient(target string) (*ClientConn, error) {
	return &ClientConn{
		Target: target,
		Keepalive: ClientParameters{
			Time:                30 * time.Second,
			Timeout:             5 * time.Second,
			PermitWithoutStream: true,
		},
	}, nil
}

func call(ctx context.Context, conn *ClientConn) error {
	ctx, cancel := context.WithTimeout(ctx, 30*time.Millisecond)
	defer cancel()
	_ = ctx
	_ = conn
	return nil
}

func main() {
	conn, err := newClient("svc.example.com:443")
	if err != nil {
		fmt.Println("dial error:", err)
		return
	}
	fmt.Printf("client ready: target=%s keepalive=%v\n", conn.Target, conn.Keepalive.Time)
	if err := call(context.Background(), conn); err != nil {
		fmt.Println("call error:", err)
		return
	}
	fmt.Println("call ok")
}

package main

import (
	"context"
	"fmt"
	"io"
)

// Self-contained stand-in for a generated gRPC bidi stream client.
type Chat_BidiClient interface {
	Send(*ChatMessage) error
	Recv() (*ChatMessage, error)
	CloseSend() error
}

type ChatMessage struct {
	Body string
}

// fakeStream echoes one message and then EOFs.
type fakeStream struct {
	incoming chan *ChatMessage
	closed   bool
}

func newFakeStream() *fakeStream {
	return &fakeStream{incoming: make(chan *ChatMessage, 4)}
}

func (f *fakeStream) Send(m *ChatMessage) error {
	f.incoming <- &ChatMessage{Body: "echo:" + m.Body}
	close(f.incoming)
	return nil
}

func (f *fakeStream) Recv() (*ChatMessage, error) {
	m, ok := <-f.incoming
	if !ok {
		return nil, io.EOF
	}
	return m, nil
}

func (f *fakeStream) CloseSend() error { return nil }

func chat(ctx context.Context, stream Chat_BidiClient) error {
	errCh := make(chan error, 2)
	go func() {
		for {
			msg, err := stream.Recv()
			if err == io.EOF {
				errCh <- nil
				return
			}
			if err != nil {
				errCh <- err
				return
			}
			fmt.Println("recv:", msg.Body)
		}
	}()
	if err := stream.Send(&ChatMessage{Body: "hello"}); err != nil {
		return err
	}
	return <-errCh
}

func main() {
	if err := chat(context.Background(), newFakeStream()); err != nil {
		fmt.Println("chat error:", err)
		return
	}
	fmt.Println("chat completed cleanly")
}

package main

// user.proto
//
// syntax = "proto3";
// message User {
//   int64 id = 1;
//   string name = 2;
//   string email = 3;            // present in v1
//   string created_by = 7;        // added in v2 (safe)
//   reserved 3, "email";          // proper way to remove a field
// }

import (
	"encoding/json"
	"fmt"
)

type User struct {
	Id        int64
	Name      string
	Email     string
	CreatedBy string
}

// decode is a stand-in for protoc-generated proto.Unmarshal. The playground
// has only stdlib available, so we use encoding/json as the wire format.
func decode(data []byte) (*User, error) {
	u := &User{}
	if err := json.Unmarshal(data, u); err != nil {
		return nil, err
	}
	return u, nil
}

func main() {
	wire := []byte(`{"Id":42,"Name":"Ada","Email":"[email protected]"}`)
	u, err := decode(wire)
	if err != nil {
		fmt.Println("decode error:", err)
		return
	}
	fmt.Printf("user: id=%d name=%s email=%s\n", u.Id, u.Name, u.Email)
}

package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

// Self-contained stand-ins for the gRPC + Prometheus types. The playground
// only ships the stdlib, so we re-declare just enough surface to make the
// interceptor pattern compile and demonstrate.
type UnaryServerInfo struct {
	FullMethod string
}

type UnaryHandler func(ctx context.Context, req interface{}) (interface{}, error)

type histogram struct {
	mu     sync.Mutex
	labels map[string][]float64
}

func newHistogram() *histogram { return &histogram{labels: map[string][]float64{}} }

func (h *histogram) Observe(service, method, code string, secs float64) {
	key := service + "|" + method + "|" + code
	h.mu.Lock()
	defer h.mu.Unlock()
	h.labels[key] = append(h.labels[key], secs)
}

var rpcLatency = newHistogram()

func metricsInterceptor(ctx context.Context, req interface{}, info *UnaryServerInfo, handler UnaryHandler) (interface{}, error) {
	start := time.Now()
	resp, err := handler(ctx, req)
	code := "OK"
	if err != nil {
		code = "Internal"
	}
	service, method := splitFullMethod(info.FullMethod)
	rpcLatency.Observe(service, method, code, time.Since(start).Seconds())
	return resp, err
}

func splitFullMethod(fullMethod string) (service, method string) {
	for i := len(fullMethod) - 1; i >= 0; i-- {
		if fullMethod[i] == '/' {
			return fullMethod[1:i], fullMethod[i+1:]
		}
	}
	return "", fullMethod
}

func main() {
	info := &UnaryServerInfo{FullMethod: "/users.UserService/GetUser"}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		time.Sleep(2 * time.Millisecond)
		return "user42", nil
	}
	resp, err := metricsInterceptor(context.Background(), nil, info, handler)
	fmt.Printf("resp=%v err=%v observations=%d\n", resp, err, len(rpcLatency.labels))
}