grpc/example/example.go

180 lines
4.5 KiB
Go
Raw Normal View History

2020-01-22 13:02:06 +00:00
package main
import (
"context"
"crypto/tls"
"errors"
2020-01-22 13:02:06 +00:00
"fmt"
"io"
"io/ioutil"
"net/http"
"strings"
"time"
2020-01-22 13:02:06 +00:00
"github.com/sirupsen/logrus"
2021-11-23 14:15:47 +00:00
"google.golang.org/grpc"
2021-07-17 20:40:06 +00:00
"go.linka.cloud/grpc/client"
"go.linka.cloud/grpc/interceptors/defaulter"
metrics2 "go.linka.cloud/grpc/interceptors/metrics"
validation2 "go.linka.cloud/grpc/interceptors/validation"
"go.linka.cloud/grpc/logger"
2021-07-17 20:40:06 +00:00
"go.linka.cloud/grpc/service"
2020-01-22 13:02:06 +00:00
)
type GreeterHandler struct {
UnimplementedGreeterServer
}
2020-01-22 13:02:06 +00:00
func hello(name string) string {
return fmt.Sprintf("Hello %s !", name)
}
func (g *GreeterHandler) SayHello(ctx context.Context, req *HelloRequest) (*HelloReply, error) {
return &HelloReply{Message: hello(req.Name)}, nil
}
func (g *GreeterHandler) SayHelloStream(req *HelloStreamRequest, s Greeter_SayHelloStreamServer) error {
2020-01-22 13:02:06 +00:00
for i := int64(0); i < req.Count; i++ {
if err := s.Send(&HelloReply{Message: fmt.Sprintf("Hello %s (%d)!", req.Name, i+1)}); err != nil {
2020-01-22 13:02:06 +00:00
return err
}
// time.Sleep(time.Second)
2020-01-22 13:02:06 +00:00
}
return nil
}
func httpLogger(next http.Handler) http.Handler {
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
start := time.Now()
log := logger.From(request.Context()).WithFields(
"method", request.Method,
"host", request.Host,
"path", request.URL.Path,
"remoteAddress", request.RemoteAddr,
)
next.ServeHTTP(writer, request)
log.WithField("duration", time.Since(start)).Info()
})
}
2020-01-22 13:02:06 +00:00
func main() {
name := "greeter"
version := "v0.0.1"
secure := true
ctx, cancel := context.WithCancel(context.Background())
done := make(chan struct{})
ready := make(chan struct{})
2020-01-22 13:02:06 +00:00
defer cancel()
2020-01-22 20:20:18 +00:00
var svc service.Service
2020-01-22 13:02:06 +00:00
var err error
metrics := metrics2.NewInterceptors()
validation := validation2.NewInterceptors(true)
defaulter := defaulter.NewInterceptors()
address := "0.0.0.0:9991"
2020-01-22 20:20:18 +00:00
svc, err = service.New(
service.WithContext(ctx),
service.WithName(name),
service.WithVersion(version),
service.WithAddress(address),
// service.WithRegistry(mdns.NewRegistry()),
service.WithReflection(true),
service.WithSecure(secure),
2020-01-22 20:20:18 +00:00
service.WithAfterStart(func() error {
2020-01-22 13:02:06 +00:00
fmt.Println("Server listening on", svc.Options().Address())
close(ready)
2020-01-22 13:02:06 +00:00
return nil
}),
2020-01-22 20:20:18 +00:00
service.WithAfterStop(func() error {
2020-01-22 13:02:06 +00:00
fmt.Println("Stopping server")
close(done)
2020-01-22 13:02:06 +00:00
return nil
}),
service.WithGateway(RegisterGreeterHandler),
service.WithGatewayPrefix("/rest"),
service.WithGRPCWeb(true),
service.WithGRPCWebPrefix("/grpc"),
service.WithMiddlewares(httpLogger),
service.WithInterceptors(metrics, defaulter, validation),
2020-01-22 13:02:06 +00:00
)
if err != nil {
panic(err)
}
RegisterGreeterServer(svc, &GreeterHandler{})
go func() {
if err := svc.Start(); err != nil {
panic(err)
}
}()
<-ready
s, err := client.New(
// client.WithName(name),
// client.WithVersion(version),
client.WithAddress("localhost:9991"),
// client.WithRegistry(mdns.NewRegistry()),
client.WithSecure(secure),
2021-11-23 14:15:47 +00:00
client.WithUnaryInterceptors(func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
logger.From(ctx).WithFields("party", "client", "method", method).Info(req)
return invoker(ctx, method, req, reply, cc, opts...)
}),
)
if err != nil {
logrus.Fatal(err)
}
g := NewGreeterClient(s)
defer cancel()
res, err := g.SayHello(context.Background(), &HelloRequest{Name: "test"})
if err != nil {
logrus.Fatal(err)
2020-01-22 13:02:06 +00:00
}
logrus.Infof("received message: %s", res.Message)
res, err = g.SayHello(context.Background(), &HelloRequest{})
if err == nil {
logrus.Fatal("expected validation error")
}
stream, err := g.SayHelloStream(context.Background(), &HelloStreamRequest{Name: "test"})
if err != nil {
logrus.Fatal(err)
}
for {
m, err := stream.Recv()
if errors.Is(err, io.EOF) {
break
}
if err != nil {
logrus.Fatal(err)
}
logrus.Infof("received stream message: %s", m.Message)
}
scheme := "http://"
if secure {
scheme = "https://"
}
httpc := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
req := `{"name":"test"}`
do := func(url, contentType string) {
resp, err := httpc.Post(url, contentType, strings.NewReader(req))
if err != nil {
logrus.Fatal(err)
}
defer resp.Body.Close()
b, err := ioutil.ReadAll(resp.Body)
if err != nil {
logrus.Fatal(err)
}
logrus.Info(string(b))
}
do(scheme+address+"/rest/api/v1/greeter/hello", "application/json")
do(scheme+address+"/grpc/helloworld.Greeter/SayHello", "application/grpc-web+json")
cancel()
<-done
2020-01-22 13:02:06 +00:00
}