// DoCall performs an RPC with given stub and request and response sizes.
func DoCall(hc testClient, reqSize, respSize int) {
pl := testpb.NewPayload(testpb.PayloadType_COMPRESSABLE, reqSize)
req := &testpb.SimpleRequest{
ResponseType: pl.Type,
ResponseSize: int32(respSize),
Payload: pl,
}
buf, err := json.Marshal(req)
if err != nil {
grpclog.Fatalf("json marshal failed %v: %v", req, err)
}
sr := &testpb.SimpleResponse{}
resp, err := hc.Post("http://"+hc.addr+"/", "test/json", bytes.NewBuffer(buf))
if err != nil {
grpclog.Fatalf("post failed %v: %v", resp, err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
grpclog.Fatalf("read failed %v: %v", resp, err)
}
err = json.Unmarshal(body, sr)
if err != nil {
grpclog.Fatalf("json unmarshal failed %v: %v", resp, err)
}
}
// DoUnaryCall performs an unary RPC with given stub and request and response sizes.
func DoUnaryCall(tc testpb.TestServiceClient, reqSize, respSize int) {
pl := testpb.NewPayload(testpb.PayloadType_COMPRESSABLE, reqSize)
req := &testpb.SimpleRequest{
ResponseType: pl.Type,
ResponseSize: int32(respSize),
Payload: pl,
}
if _, err := tc.UnaryCall(context.Background(), req); err != nil {
grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
}
}
// DoStreamingRoundTrip performs a round trip for a single streaming rpc.
func DoStreamingRoundTrip(tc testpb.TestServiceClient, stream testpb.TestService_StreamingCallClient, reqSize, respSize int) {
pl := testpb.NewPayload(testpb.PayloadType_COMPRESSABLE, reqSize)
req := &testpb.SimpleRequest{
ResponseType: pl.Type,
ResponseSize: int32(respSize),
Payload: pl,
}
if err := stream.Send(req); err != nil {
grpclog.Fatalf("StreamingCall(_).Send: %v", err)
}
if _, err := stream.Recv(); err != nil {
grpclog.Fatalf("StreamingCall(_).Recv: %v", err)
}
}
func (s *testServer) StreamingCall(stream testpb.TestService_StreamingCallServer) error {
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
return nil
}
if err != nil {
return err
}
if err := stream.Send(&testpb.SimpleResponse{
Payload: testpb.NewPayload(in.ResponseType, int(in.ResponseSize)),
}); err != nil {
return err
}
}
}
func (s testServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
body, err := ioutil.ReadAll(req.Body)
if err != nil {
panic(err)
}
if err := req.Body.Close(); err != nil {
panic(err)
}
in := testpb.SimpleRequest{}
err = json.Unmarshal(body, &in)
if err != nil {
grpclog.Fatalf("json unmarshal failed %v: %v", req, err)
}
sr := &testpb.SimpleResponse{
Payload: testpb.NewPayload(in.ResponseType, int(in.ResponseSize)),
}
buf, err := json.Marshal(sr)
if err != nil {
grpclog.Fatalf("json marshal failed %v: %v", req, err)
}
io.Copy(w, bytes.NewBuffer(buf))
}
func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
return &testpb.SimpleResponse{
Payload: testpb.NewPayload(in.ResponseType, int(in.ResponseSize)),
}, nil
}
