-
Notifications
You must be signed in to change notification settings - Fork 3
/
temperatureapi_router.pb.go
156 lines (132 loc) · 4.05 KB
/
temperatureapi_router.pb.go
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
// Code generated by protoc-gen-router. DO NOT EDIT.
package gen
import (
context "context"
fmt "fmt"
router "github.com/smart-core-os/sc-golang/pkg/router"
grpc "google.golang.org/grpc"
io "io"
)
// TemperatureApiRouter is a TemperatureApiServer that allows routing named requests to specific TemperatureApiClient
type TemperatureApiRouter struct {
UnimplementedTemperatureApiServer
router.Router
}
// compile time check that we implement the interface we need
var _ TemperatureApiServer = (*TemperatureApiRouter)(nil)
func NewTemperatureApiRouter(opts ...router.Option) *TemperatureApiRouter {
return &TemperatureApiRouter{
Router: router.NewRouter(opts...),
}
}
// WithTemperatureApiClientFactory instructs the router to create a new
// client the first time Get is called for that name.
func WithTemperatureApiClientFactory(f func(name string) (TemperatureApiClient, error)) router.Option {
return router.WithFactory(func(name string) (any, error) {
return f(name)
})
}
func (r *TemperatureApiRouter) Register(server *grpc.Server) {
RegisterTemperatureApiServer(server, r)
}
// Add extends Router.Add to panic if client is not of type TemperatureApiClient.
func (r *TemperatureApiRouter) Add(name string, client any) any {
if !r.HoldsType(client) {
panic(fmt.Sprintf("not correct type: client of type %T is not a TemperatureApiClient", client))
}
return r.Router.Add(name, client)
}
func (r *TemperatureApiRouter) HoldsType(client any) bool {
_, ok := client.(TemperatureApiClient)
return ok
}
func (r *TemperatureApiRouter) AddTemperatureApiClient(name string, client TemperatureApiClient) TemperatureApiClient {
res := r.Add(name, client)
if res == nil {
return nil
}
return res.(TemperatureApiClient)
}
func (r *TemperatureApiRouter) RemoveTemperatureApiClient(name string) TemperatureApiClient {
res := r.Remove(name)
if res == nil {
return nil
}
return res.(TemperatureApiClient)
}
func (r *TemperatureApiRouter) GetTemperatureApiClient(name string) (TemperatureApiClient, error) {
res, err := r.Get(name)
if err != nil {
return nil, err
}
if res == nil {
return nil, nil
}
return res.(TemperatureApiClient), nil
}
func (r *TemperatureApiRouter) GetTemperature(ctx context.Context, request *GetTemperatureRequest) (*Temperature, error) {
child, err := r.GetTemperatureApiClient(request.Name)
if err != nil {
return nil, err
}
return child.GetTemperature(ctx, request)
}
func (r *TemperatureApiRouter) PullTemperature(request *PullTemperatureRequest, server TemperatureApi_PullTemperatureServer) error {
child, err := r.GetTemperatureApiClient(request.Name)
if err != nil {
return err
}
// so we can cancel our forwarding request if we can't send responses to our caller
reqCtx, reqDone := context.WithCancel(server.Context())
// issue the request
stream, err := child.PullTemperature(reqCtx, request)
if err != nil {
return err
}
// send the stream header
header, err := stream.Header()
if err != nil {
return err
}
if err = server.SendHeader(header); err != nil {
return err
}
// send all the messages
// false means the error is from the child, true means the error is from the caller
var callerError bool
for {
// Impl note: we could improve throughput here by issuing the Recv and Send in different goroutines, but we're doing
// it synchronously until we have a need to change the behaviour
var msg *PullTemperatureResponse
msg, err = stream.Recv()
if err != nil {
break
}
err = server.Send(msg)
if err != nil {
callerError = true
break
}
}
// err is guaranteed to be non-nil as it's the only way to exit the loop
if callerError {
// cancel the request
reqDone()
return err
} else {
if trailer := stream.Trailer(); trailer != nil {
server.SetTrailer(trailer)
}
if err == io.EOF {
return nil
}
return err
}
}
func (r *TemperatureApiRouter) UpdateTemperature(ctx context.Context, request *UpdateTemperatureRequest) (*Temperature, error) {
child, err := r.GetTemperatureApiClient(request.Name)
if err != nil {
return nil, err
}
return child.UpdateTemperature(ctx, request)
}