1/* 2 * 3 * Copyright 2014 gRPC authors. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 19package grpc 20 21import ( 22 "bytes" 23 "compress/gzip" 24 "context" 25 "encoding/binary" 26 "fmt" 27 "io" 28 "io/ioutil" 29 "math" 30 "net/url" 31 "strings" 32 "sync" 33 "time" 34 35 "google.golang.org/grpc/codes" 36 "google.golang.org/grpc/credentials" 37 "google.golang.org/grpc/encoding" 38 "google.golang.org/grpc/encoding/proto" 39 "google.golang.org/grpc/internal/transport" 40 "google.golang.org/grpc/metadata" 41 "google.golang.org/grpc/peer" 42 "google.golang.org/grpc/stats" 43 "google.golang.org/grpc/status" 44) 45 46// Compressor defines the interface gRPC uses to compress a message. 47// 48// Deprecated: use package encoding. 49type Compressor interface { 50 // Do compresses p into w. 51 Do(w io.Writer, p []byte) error 52 // Type returns the compression algorithm the Compressor uses. 53 Type() string 54} 55 56type gzipCompressor struct { 57 pool sync.Pool 58} 59 60// NewGZIPCompressor creates a Compressor based on GZIP. 61// 62// Deprecated: use package encoding/gzip. 63func NewGZIPCompressor() Compressor { 64 c, _ := NewGZIPCompressorWithLevel(gzip.DefaultCompression) 65 return c 66} 67 68// NewGZIPCompressorWithLevel is like NewGZIPCompressor but specifies the gzip compression level instead 69// of assuming DefaultCompression. 70// 71// The error returned will be nil if the level is valid. 72// 73// Deprecated: use package encoding/gzip. 74func NewGZIPCompressorWithLevel(level int) (Compressor, error) { 75 if level < gzip.DefaultCompression || level > gzip.BestCompression { 76 return nil, fmt.Errorf("grpc: invalid compression level: %d", level) 77 } 78 return &gzipCompressor{ 79 pool: sync.Pool{ 80 New: func() interface{} { 81 w, err := gzip.NewWriterLevel(ioutil.Discard, level) 82 if err != nil { 83 panic(err) 84 } 85 return w 86 }, 87 }, 88 }, nil 89} 90 91func (c *gzipCompressor) Do(w io.Writer, p []byte) error { 92 z := c.pool.Get().(*gzip.Writer) 93 defer c.pool.Put(z) 94 z.Reset(w) 95 if _, err := z.Write(p); err != nil { 96 return err 97 } 98 return z.Close() 99} 100 101func (c *gzipCompressor) Type() string { 102 return "gzip" 103} 104 105// Decompressor defines the interface gRPC uses to decompress a message. 106// 107// Deprecated: use package encoding. 108type Decompressor interface { 109 // Do reads the data from r and uncompress them. 110 Do(r io.Reader) ([]byte, error) 111 // Type returns the compression algorithm the Decompressor uses. 112 Type() string 113} 114 115type gzipDecompressor struct { 116 pool sync.Pool 117} 118 119// NewGZIPDecompressor creates a Decompressor based on GZIP. 120// 121// Deprecated: use package encoding/gzip. 122func NewGZIPDecompressor() Decompressor { 123 return &gzipDecompressor{} 124} 125 126func (d *gzipDecompressor) Do(r io.Reader) ([]byte, error) { 127 var z *gzip.Reader 128 switch maybeZ := d.pool.Get().(type) { 129 case nil: 130 newZ, err := gzip.NewReader(r) 131 if err != nil { 132 return nil, err 133 } 134 z = newZ 135 case *gzip.Reader: 136 z = maybeZ 137 if err := z.Reset(r); err != nil { 138 d.pool.Put(z) 139 return nil, err 140 } 141 } 142 143 defer func() { 144 z.Close() 145 d.pool.Put(z) 146 }() 147 return ioutil.ReadAll(z) 148} 149 150func (d *gzipDecompressor) Type() string { 151 return "gzip" 152} 153 154// callInfo contains all related configuration and information about an RPC. 155type callInfo struct { 156 compressorType string 157 failFast bool 158 stream ClientStream 159 maxReceiveMessageSize *int 160 maxSendMessageSize *int 161 creds credentials.PerRPCCredentials 162 contentSubtype string 163 codec baseCodec 164 maxRetryRPCBufferSize int 165} 166 167func defaultCallInfo() *callInfo { 168 return &callInfo{ 169 failFast: true, 170 maxRetryRPCBufferSize: 256 * 1024, // 256KB 171 } 172} 173 174// CallOption configures a Call before it starts or extracts information from 175// a Call after it completes. 176type CallOption interface { 177 // before is called before the call is sent to any server. If before 178 // returns a non-nil error, the RPC fails with that error. 179 before(*callInfo) error 180 181 // after is called after the call has completed. after cannot return an 182 // error, so any failures should be reported via output parameters. 183 after(*callInfo) 184} 185 186// EmptyCallOption does not alter the Call configuration. 187// It can be embedded in another structure to carry satellite data for use 188// by interceptors. 189type EmptyCallOption struct{} 190 191func (EmptyCallOption) before(*callInfo) error { return nil } 192func (EmptyCallOption) after(*callInfo) {} 193 194// Header returns a CallOptions that retrieves the header metadata 195// for a unary RPC. 196func Header(md *metadata.MD) CallOption { 197 return HeaderCallOption{HeaderAddr: md} 198} 199 200// HeaderCallOption is a CallOption for collecting response header metadata. 201// The metadata field will be populated *after* the RPC completes. 202// This is an EXPERIMENTAL API. 203type HeaderCallOption struct { 204 HeaderAddr *metadata.MD 205} 206 207func (o HeaderCallOption) before(c *callInfo) error { return nil } 208func (o HeaderCallOption) after(c *callInfo) { 209 if c.stream != nil { 210 *o.HeaderAddr, _ = c.stream.Header() 211 } 212} 213 214// Trailer returns a CallOptions that retrieves the trailer metadata 215// for a unary RPC. 216func Trailer(md *metadata.MD) CallOption { 217 return TrailerCallOption{TrailerAddr: md} 218} 219 220// TrailerCallOption is a CallOption for collecting response trailer metadata. 221// The metadata field will be populated *after* the RPC completes. 222// This is an EXPERIMENTAL API. 223type TrailerCallOption struct { 224 TrailerAddr *metadata.MD 225} 226 227func (o TrailerCallOption) before(c *callInfo) error { return nil } 228func (o TrailerCallOption) after(c *callInfo) { 229 if c.stream != nil { 230 *o.TrailerAddr = c.stream.Trailer() 231 } 232} 233 234// Peer returns a CallOption that retrieves peer information for a unary RPC. 235// The peer field will be populated *after* the RPC completes. 236func Peer(p *peer.Peer) CallOption { 237 return PeerCallOption{PeerAddr: p} 238} 239 240// PeerCallOption is a CallOption for collecting the identity of the remote 241// peer. The peer field will be populated *after* the RPC completes. 242// This is an EXPERIMENTAL API. 243type PeerCallOption struct { 244 PeerAddr *peer.Peer 245} 246 247func (o PeerCallOption) before(c *callInfo) error { return nil } 248func (o PeerCallOption) after(c *callInfo) { 249 if c.stream != nil { 250 if x, ok := peer.FromContext(c.stream.Context()); ok { 251 *o.PeerAddr = *x 252 } 253 } 254} 255 256// WaitForReady configures the action to take when an RPC is attempted on broken 257// connections or unreachable servers. If waitForReady is false, the RPC will fail 258// immediately. Otherwise, the RPC client will block the call until a 259// connection is available (or the call is canceled or times out) and will 260// retry the call if it fails due to a transient error. gRPC will not retry if 261// data was written to the wire unless the server indicates it did not process 262// the data. Please refer to 263// https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md. 264// 265// By default, RPCs don't "wait for ready". 266func WaitForReady(waitForReady bool) CallOption { 267 return FailFastCallOption{FailFast: !waitForReady} 268} 269 270// FailFast is the opposite of WaitForReady. 271// 272// Deprecated: use WaitForReady. 273func FailFast(failFast bool) CallOption { 274 return FailFastCallOption{FailFast: failFast} 275} 276 277// FailFastCallOption is a CallOption for indicating whether an RPC should fail 278// fast or not. 279// This is an EXPERIMENTAL API. 280type FailFastCallOption struct { 281 FailFast bool 282} 283 284func (o FailFastCallOption) before(c *callInfo) error { 285 c.failFast = o.FailFast 286 return nil 287} 288func (o FailFastCallOption) after(c *callInfo) {} 289 290// MaxCallRecvMsgSize returns a CallOption which sets the maximum message size the client can receive. 291func MaxCallRecvMsgSize(s int) CallOption { 292 return MaxRecvMsgSizeCallOption{MaxRecvMsgSize: s} 293} 294 295// MaxRecvMsgSizeCallOption is a CallOption that indicates the maximum message 296// size the client can receive. 297// This is an EXPERIMENTAL API. 298type MaxRecvMsgSizeCallOption struct { 299 MaxRecvMsgSize int 300} 301 302func (o MaxRecvMsgSizeCallOption) before(c *callInfo) error { 303 c.maxReceiveMessageSize = &o.MaxRecvMsgSize 304 return nil 305} 306func (o MaxRecvMsgSizeCallOption) after(c *callInfo) {} 307 308// MaxCallSendMsgSize returns a CallOption which sets the maximum message size the client can send. 309func MaxCallSendMsgSize(s int) CallOption { 310 return MaxSendMsgSizeCallOption{MaxSendMsgSize: s} 311} 312 313// MaxSendMsgSizeCallOption is a CallOption that indicates the maximum message 314// size the client can send. 315// This is an EXPERIMENTAL API. 316type MaxSendMsgSizeCallOption struct { 317 MaxSendMsgSize int 318} 319 320func (o MaxSendMsgSizeCallOption) before(c *callInfo) error { 321 c.maxSendMessageSize = &o.MaxSendMsgSize 322 return nil 323} 324func (o MaxSendMsgSizeCallOption) after(c *callInfo) {} 325 326// PerRPCCredentials returns a CallOption that sets credentials.PerRPCCredentials 327// for a call. 328func PerRPCCredentials(creds credentials.PerRPCCredentials) CallOption { 329 return PerRPCCredsCallOption{Creds: creds} 330} 331 332// PerRPCCredsCallOption is a CallOption that indicates the per-RPC 333// credentials to use for the call. 334// This is an EXPERIMENTAL API. 335type PerRPCCredsCallOption struct { 336 Creds credentials.PerRPCCredentials 337} 338 339func (o PerRPCCredsCallOption) before(c *callInfo) error { 340 c.creds = o.Creds 341 return nil 342} 343func (o PerRPCCredsCallOption) after(c *callInfo) {} 344 345// UseCompressor returns a CallOption which sets the compressor used when 346// sending the request. If WithCompressor is also set, UseCompressor has 347// higher priority. 348// 349// This API is EXPERIMENTAL. 350func UseCompressor(name string) CallOption { 351 return CompressorCallOption{CompressorType: name} 352} 353 354// CompressorCallOption is a CallOption that indicates the compressor to use. 355// This is an EXPERIMENTAL API. 356type CompressorCallOption struct { 357 CompressorType string 358} 359 360func (o CompressorCallOption) before(c *callInfo) error { 361 c.compressorType = o.CompressorType 362 return nil 363} 364func (o CompressorCallOption) after(c *callInfo) {} 365 366// CallContentSubtype returns a CallOption that will set the content-subtype 367// for a call. For example, if content-subtype is "json", the Content-Type over 368// the wire will be "application/grpc+json". The content-subtype is converted 369// to lowercase before being included in Content-Type. See Content-Type on 370// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for 371// more details. 372// 373// If ForceCodec is not also used, the content-subtype will be used to look up 374// the Codec to use in the registry controlled by RegisterCodec. See the 375// documentation on RegisterCodec for details on registration. The lookup of 376// content-subtype is case-insensitive. If no such Codec is found, the call 377// will result in an error with code codes.Internal. 378// 379// If ForceCodec is also used, that Codec will be used for all request and 380// response messages, with the content-subtype set to the given contentSubtype 381// here for requests. 382func CallContentSubtype(contentSubtype string) CallOption { 383 return ContentSubtypeCallOption{ContentSubtype: strings.ToLower(contentSubtype)} 384} 385 386// ContentSubtypeCallOption is a CallOption that indicates the content-subtype 387// used for marshaling messages. 388// This is an EXPERIMENTAL API. 389type ContentSubtypeCallOption struct { 390 ContentSubtype string 391} 392 393func (o ContentSubtypeCallOption) before(c *callInfo) error { 394 c.contentSubtype = o.ContentSubtype 395 return nil 396} 397func (o ContentSubtypeCallOption) after(c *callInfo) {} 398 399// ForceCodec returns a CallOption that will set the given Codec to be 400// used for all request and response messages for a call. The result of calling 401// String() will be used as the content-subtype in a case-insensitive manner. 402// 403// See Content-Type on 404// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for 405// more details. Also see the documentation on RegisterCodec and 406// CallContentSubtype for more details on the interaction between Codec and 407// content-subtype. 408// 409// This function is provided for advanced users; prefer to use only 410// CallContentSubtype to select a registered codec instead. 411// 412// This is an EXPERIMENTAL API. 413func ForceCodec(codec encoding.Codec) CallOption { 414 return ForceCodecCallOption{Codec: codec} 415} 416 417// ForceCodecCallOption is a CallOption that indicates the codec used for 418// marshaling messages. 419// 420// This is an EXPERIMENTAL API. 421type ForceCodecCallOption struct { 422 Codec encoding.Codec 423} 424 425func (o ForceCodecCallOption) before(c *callInfo) error { 426 c.codec = o.Codec 427 return nil 428} 429func (o ForceCodecCallOption) after(c *callInfo) {} 430 431// CallCustomCodec behaves like ForceCodec, but accepts a grpc.Codec instead of 432// an encoding.Codec. 433// 434// Deprecated: use ForceCodec instead. 435func CallCustomCodec(codec Codec) CallOption { 436 return CustomCodecCallOption{Codec: codec} 437} 438 439// CustomCodecCallOption is a CallOption that indicates the codec used for 440// marshaling messages. 441// 442// This is an EXPERIMENTAL API. 443type CustomCodecCallOption struct { 444 Codec Codec 445} 446 447func (o CustomCodecCallOption) before(c *callInfo) error { 448 c.codec = o.Codec 449 return nil 450} 451func (o CustomCodecCallOption) after(c *callInfo) {} 452 453// MaxRetryRPCBufferSize returns a CallOption that limits the amount of memory 454// used for buffering this RPC's requests for retry purposes. 455// 456// This API is EXPERIMENTAL. 457func MaxRetryRPCBufferSize(bytes int) CallOption { 458 return MaxRetryRPCBufferSizeCallOption{bytes} 459} 460 461// MaxRetryRPCBufferSizeCallOption is a CallOption indicating the amount of 462// memory to be used for caching this RPC for retry purposes. 463// This is an EXPERIMENTAL API. 464type MaxRetryRPCBufferSizeCallOption struct { 465 MaxRetryRPCBufferSize int 466} 467 468func (o MaxRetryRPCBufferSizeCallOption) before(c *callInfo) error { 469 c.maxRetryRPCBufferSize = o.MaxRetryRPCBufferSize 470 return nil 471} 472func (o MaxRetryRPCBufferSizeCallOption) after(c *callInfo) {} 473 474// The format of the payload: compressed or not? 475type payloadFormat uint8 476 477const ( 478 compressionNone payloadFormat = 0 // no compression 479 compressionMade payloadFormat = 1 // compressed 480) 481 482// parser reads complete gRPC messages from the underlying reader. 483type parser struct { 484 // r is the underlying reader. 485 // See the comment on recvMsg for the permissible 486 // error types. 487 r io.Reader 488 489 // The header of a gRPC message. Find more detail at 490 // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md 491 header [5]byte 492} 493 494// recvMsg reads a complete gRPC message from the stream. 495// 496// It returns the message and its payload (compression/encoding) 497// format. The caller owns the returned msg memory. 498// 499// If there is an error, possible values are: 500// * io.EOF, when no messages remain 501// * io.ErrUnexpectedEOF 502// * of type transport.ConnectionError 503// * an error from the status package 504// No other error values or types must be returned, which also means 505// that the underlying io.Reader must not return an incompatible 506// error. 507func (p *parser) recvMsg(maxReceiveMessageSize int) (pf payloadFormat, msg []byte, err error) { 508 if _, err := p.r.Read(p.header[:]); err != nil { 509 return 0, nil, err 510 } 511 512 pf = payloadFormat(p.header[0]) 513 length := binary.BigEndian.Uint32(p.header[1:]) 514 515 if length == 0 { 516 return pf, nil, nil 517 } 518 if int64(length) > int64(maxInt) { 519 return 0, nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max length allowed on current machine (%d vs. %d)", length, maxInt) 520 } 521 if int(length) > maxReceiveMessageSize { 522 return 0, nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", length, maxReceiveMessageSize) 523 } 524 // TODO(bradfitz,zhaoq): garbage. reuse buffer after proto decoding instead 525 // of making it for each message: 526 msg = make([]byte, int(length)) 527 if _, err := p.r.Read(msg); err != nil { 528 if err == io.EOF { 529 err = io.ErrUnexpectedEOF 530 } 531 return 0, nil, err 532 } 533 return pf, msg, nil 534} 535 536// encode serializes msg and returns a buffer containing the message, or an 537// error if it is too large to be transmitted by grpc. If msg is nil, it 538// generates an empty message. 539func encode(c baseCodec, msg interface{}) ([]byte, error) { 540 if msg == nil { // NOTE: typed nils will not be caught by this check 541 return nil, nil 542 } 543 b, err := c.Marshal(msg) 544 if err != nil { 545 return nil, status.Errorf(codes.Internal, "grpc: error while marshaling: %v", err.Error()) 546 } 547 if uint(len(b)) > math.MaxUint32 { 548 return nil, status.Errorf(codes.ResourceExhausted, "grpc: message too large (%d bytes)", len(b)) 549 } 550 return b, nil 551} 552 553// compress returns the input bytes compressed by compressor or cp. If both 554// compressors are nil, returns nil. 555// 556// TODO(dfawley): eliminate cp parameter by wrapping Compressor in an encoding.Compressor. 557func compress(in []byte, cp Compressor, compressor encoding.Compressor) ([]byte, error) { 558 if compressor == nil && cp == nil { 559 return nil, nil 560 } 561 wrapErr := func(err error) error { 562 return status.Errorf(codes.Internal, "grpc: error while compressing: %v", err.Error()) 563 } 564 cbuf := &bytes.Buffer{} 565 if compressor != nil { 566 z, err := compressor.Compress(cbuf) 567 if err != nil { 568 return nil, wrapErr(err) 569 } 570 if _, err := z.Write(in); err != nil { 571 return nil, wrapErr(err) 572 } 573 if err := z.Close(); err != nil { 574 return nil, wrapErr(err) 575 } 576 } else { 577 if err := cp.Do(cbuf, in); err != nil { 578 return nil, wrapErr(err) 579 } 580 } 581 return cbuf.Bytes(), nil 582} 583 584const ( 585 payloadLen = 1 586 sizeLen = 4 587 headerLen = payloadLen + sizeLen 588) 589 590// msgHeader returns a 5-byte header for the message being transmitted and the 591// payload, which is compData if non-nil or data otherwise. 592func msgHeader(data, compData []byte) (hdr []byte, payload []byte) { 593 hdr = make([]byte, headerLen) 594 if compData != nil { 595 hdr[0] = byte(compressionMade) 596 data = compData 597 } else { 598 hdr[0] = byte(compressionNone) 599 } 600 601 // Write length of payload into buf 602 binary.BigEndian.PutUint32(hdr[payloadLen:], uint32(len(data))) 603 return hdr, data 604} 605 606func outPayload(client bool, msg interface{}, data, payload []byte, t time.Time) *stats.OutPayload { 607 return &stats.OutPayload{ 608 Client: client, 609 Payload: msg, 610 Data: data, 611 Length: len(data), 612 WireLength: len(payload) + headerLen, 613 SentTime: t, 614 } 615} 616 617func checkRecvPayload(pf payloadFormat, recvCompress string, haveCompressor bool) *status.Status { 618 switch pf { 619 case compressionNone: 620 case compressionMade: 621 if recvCompress == "" || recvCompress == encoding.Identity { 622 return status.New(codes.Internal, "grpc: compressed flag set with identity or empty encoding") 623 } 624 if !haveCompressor { 625 return status.Newf(codes.Unimplemented, "grpc: Decompressor is not installed for grpc-encoding %q", recvCompress) 626 } 627 default: 628 return status.Newf(codes.Internal, "grpc: received unexpected payload format %d", pf) 629 } 630 return nil 631} 632 633type payloadInfo struct { 634 wireLength int // The compressed length got from wire. 635 uncompressedBytes []byte 636} 637 638func recvAndDecompress(p *parser, s *transport.Stream, dc Decompressor, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor) ([]byte, error) { 639 pf, d, err := p.recvMsg(maxReceiveMessageSize) 640 if err != nil { 641 return nil, err 642 } 643 if payInfo != nil { 644 payInfo.wireLength = len(d) 645 } 646 647 if st := checkRecvPayload(pf, s.RecvCompress(), compressor != nil || dc != nil); st != nil { 648 return nil, st.Err() 649 } 650 651 if pf == compressionMade { 652 // To match legacy behavior, if the decompressor is set by WithDecompressor or RPCDecompressor, 653 // use this decompressor as the default. 654 if dc != nil { 655 d, err = dc.Do(bytes.NewReader(d)) 656 if err != nil { 657 return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err) 658 } 659 } else { 660 dcReader, err := compressor.Decompress(bytes.NewReader(d)) 661 if err != nil { 662 return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err) 663 } 664 // Read from LimitReader with limit max+1. So if the underlying 665 // reader is over limit, the result will be bigger than max. 666 d, err = ioutil.ReadAll(io.LimitReader(dcReader, int64(maxReceiveMessageSize)+1)) 667 if err != nil { 668 return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message %v", err) 669 } 670 } 671 } 672 if len(d) > maxReceiveMessageSize { 673 // TODO: Revisit the error code. Currently keep it consistent with java 674 // implementation. 675 return nil, status.Errorf(codes.ResourceExhausted, "grpc: received message larger than max (%d vs. %d)", len(d), maxReceiveMessageSize) 676 } 677 return d, nil 678} 679 680// For the two compressor parameters, both should not be set, but if they are, 681// dc takes precedence over compressor. 682// TODO(dfawley): wrap the old compressor/decompressor using the new API? 683func recv(p *parser, c baseCodec, s *transport.Stream, dc Decompressor, m interface{}, maxReceiveMessageSize int, payInfo *payloadInfo, compressor encoding.Compressor) error { 684 d, err := recvAndDecompress(p, s, dc, maxReceiveMessageSize, payInfo, compressor) 685 if err != nil { 686 return err 687 } 688 if err := c.Unmarshal(d, m); err != nil { 689 return status.Errorf(codes.Internal, "grpc: failed to unmarshal the received message %v", err) 690 } 691 if payInfo != nil { 692 payInfo.uncompressedBytes = d 693 } 694 return nil 695} 696 697type rpcInfo struct { 698 failfast bool 699} 700 701type rpcInfoContextKey struct{} 702 703func newContextWithRPCInfo(ctx context.Context, failfast bool) context.Context { 704 return context.WithValue(ctx, rpcInfoContextKey{}, &rpcInfo{failfast: failfast}) 705} 706 707func rpcInfoFromContext(ctx context.Context) (s *rpcInfo, ok bool) { 708 s, ok = ctx.Value(rpcInfoContextKey{}).(*rpcInfo) 709 return 710} 711 712// Code returns the error code for err if it was produced by the rpc system. 713// Otherwise, it returns codes.Unknown. 714// 715// Deprecated: use status.Code instead. 716func Code(err error) codes.Code { 717 return status.Code(err) 718} 719 720// ErrorDesc returns the error description of err if it was produced by the rpc system. 721// Otherwise, it returns err.Error() or empty string when err is nil. 722// 723// Deprecated: use status.Convert and Message method instead. 724func ErrorDesc(err error) string { 725 return status.Convert(err).Message() 726} 727 728// Errorf returns an error containing an error code and a description; 729// Errorf returns nil if c is OK. 730// 731// Deprecated: use status.Errorf instead. 732func Errorf(c codes.Code, format string, a ...interface{}) error { 733 return status.Errorf(c, format, a...) 734} 735 736// toRPCErr converts an error into an error from the status package. 737func toRPCErr(err error) error { 738 if err == nil || err == io.EOF { 739 return err 740 } 741 if err == io.ErrUnexpectedEOF { 742 return status.Error(codes.Internal, err.Error()) 743 } 744 if _, ok := status.FromError(err); ok { 745 return err 746 } 747 switch e := err.(type) { 748 case transport.ConnectionError: 749 return status.Error(codes.Unavailable, e.Desc) 750 default: 751 switch err { 752 case context.DeadlineExceeded: 753 return status.Error(codes.DeadlineExceeded, err.Error()) 754 case context.Canceled: 755 return status.Error(codes.Canceled, err.Error()) 756 } 757 } 758 return status.Error(codes.Unknown, err.Error()) 759} 760 761// setCallInfoCodec should only be called after CallOptions have been applied. 762func setCallInfoCodec(c *callInfo) error { 763 if c.codec != nil { 764 // codec was already set by a CallOption; use it. 765 return nil 766 } 767 768 if c.contentSubtype == "" { 769 // No codec specified in CallOptions; use proto by default. 770 c.codec = encoding.GetCodec(proto.Name) 771 return nil 772 } 773 774 // c.contentSubtype is already lowercased in CallContentSubtype 775 c.codec = encoding.GetCodec(c.contentSubtype) 776 if c.codec == nil { 777 return status.Errorf(codes.Internal, "no codec registered for content-subtype %s", c.contentSubtype) 778 } 779 return nil 780} 781 782// parseDialTarget returns the network and address to pass to dialer 783func parseDialTarget(target string) (net string, addr string) { 784 net = "tcp" 785 786 m1 := strings.Index(target, ":") 787 m2 := strings.Index(target, ":/") 788 789 // handle unix:addr which will fail with url.Parse 790 if m1 >= 0 && m2 < 0 { 791 if n := target[0:m1]; n == "unix" { 792 net = n 793 addr = target[m1+1:] 794 return net, addr 795 } 796 } 797 if m2 >= 0 { 798 t, err := url.Parse(target) 799 if err != nil { 800 return net, target 801 } 802 scheme := t.Scheme 803 addr = t.Path 804 if scheme == "unix" { 805 net = scheme 806 if addr == "" { 807 addr = t.Host 808 } 809 return net, addr 810 } 811 } 812 813 return net, target 814} 815 816// channelzData is used to store channelz related data for ClientConn, addrConn and Server. 817// These fields cannot be embedded in the original structs (e.g. ClientConn), since to do atomic 818// operation on int64 variable on 32-bit machine, user is responsible to enforce memory alignment. 819// Here, by grouping those int64 fields inside a struct, we are enforcing the alignment. 820type channelzData struct { 821 callsStarted int64 822 callsFailed int64 823 callsSucceeded int64 824 // lastCallStartedTime stores the timestamp that last call starts. It is of int64 type instead of 825 // time.Time since it's more costly to atomically update time.Time variable than int64 variable. 826 lastCallStartedTime int64 827} 828 829// The SupportPackageIsVersion variables are referenced from generated protocol 830// buffer files to ensure compatibility with the gRPC version used. The latest 831// support package version is 5. 832// 833// Older versions are kept for compatibility. They may be removed if 834// compatibility cannot be maintained. 835// 836// These constants should not be referenced from any other code. 837const ( 838 SupportPackageIsVersion3 = true 839 SupportPackageIsVersion4 = true 840 SupportPackageIsVersion5 = true 841) 842 843const grpcUA = "grpc-go/" + Version 844