1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
// Copyright 2021-2023 The Connect Authors
//
// 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.
package connect_test
import (
"context"
"errors"
"io"
"net/http"
connect "connectrpc.com/connect"
pingv1 "connectrpc.com/connect/internal/gen/connect/ping/v1"
"connectrpc.com/connect/internal/gen/connect/ping/v1/pingv1connect"
)
// ExamplePingServer implements some trivial business logic. The Protobuf
// definition for this API is in proto/connect/ping/v1/ping.proto.
type ExamplePingServer struct {
pingv1connect.UnimplementedPingServiceHandler
}
// Ping implements pingv1connect.PingServiceHandler.
func (*ExamplePingServer) Ping(
_ context.Context,
request *connect.Request[pingv1.PingRequest],
) (*connect.Response[pingv1.PingResponse], error) {
return connect.NewResponse(
&pingv1.PingResponse{
Number: request.Msg.GetNumber(),
Text: request.Msg.GetText(),
},
), nil
}
// Sum implements pingv1connect.PingServiceHandler.
func (p *ExamplePingServer) Sum(ctx context.Context, stream *connect.ClientStream[pingv1.SumRequest]) (*connect.Response[pingv1.SumResponse], error) {
var sum int64
for stream.Receive() {
sum += stream.Msg().GetNumber()
}
if stream.Err() != nil {
return nil, stream.Err()
}
return connect.NewResponse(&pingv1.SumResponse{Sum: sum}), nil
}
// CountUp implements pingv1connect.PingServiceHandler.
func (p *ExamplePingServer) CountUp(ctx context.Context, request *connect.Request[pingv1.CountUpRequest], stream *connect.ServerStream[pingv1.CountUpResponse]) error {
for number := int64(1); number <= request.Msg.GetNumber(); number++ {
if err := stream.Send(&pingv1.CountUpResponse{Number: number}); err != nil {
return err
}
}
return nil
}
// CumSum implements pingv1connect.PingServiceHandler.
func (p *ExamplePingServer) CumSum(ctx context.Context, stream *connect.BidiStream[pingv1.CumSumRequest, pingv1.CumSumResponse]) error {
var sum int64
for {
msg, err := stream.Receive()
if errors.Is(err, io.EOF) {
return nil
} else if err != nil {
return err
}
sum += msg.GetNumber()
if err := stream.Send(&pingv1.CumSumResponse{Sum: sum}); err != nil {
return err
}
}
}
func Example_handler() {
// protoc-gen-connect-go generates constructors that return plain net/http
// Handlers, so they're compatible with most Go HTTP routers and middleware
// (for example, net/http's StripPrefix). Each handler automatically supports
// the Connect, gRPC, and gRPC-Web protocols.
mux := http.NewServeMux()
mux.Handle(
pingv1connect.NewPingServiceHandler(
&ExamplePingServer{}, // our business logic
),
)
// You can serve gRPC's health and server reflection APIs using
// connectrpc.com/grpchealth and connectrpc.com/grpcreflect.
_ = http.ListenAndServeTLS(
"localhost:8080",
"internal/testdata/server.crt",
"internal/testdata/server.key",
mux,
)
// To serve HTTP/2 requests without TLS (as many gRPC clients expect), import
// golang.org/x/net/http2/h2c and golang.org/x/net/http2 and change to:
// _ = http.ListenAndServe(
// "localhost:8080",
// h2c.NewHandler(mux, &http2.Server{}),
// )
}
|
