Debian Codegraph @

internal/rpc/rpc.go

raw
1 // Package rpc implements some of the lower-level functionality required to
2 // communicate with the namenode and datanodes.
3 package rpc
4
5 import (
6 "encoding/binary"
7 "errors"
8 "io"
9 "math/rand"
10 "time"
11
12 "google.golang.org/protobuf/proto"
13 )
14
15 var errInvalidResponse = errors.New("invalid response from namenode")
16
17 // Used for client ID generation, below.
18 const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
19
20 func newClientID() []byte {
21 id := make([]byte, 16)
22
23 rand.Seed(time.Now().UTC().UnixNano())
24 for i := range id {
25 id[i] = chars[rand.Intn(len(chars))]
26 }
27
28 return id
29 }
30
31 func makePrefixedMessage(msg proto.Message) ([]byte, error) {
32 msgBytes, err := proto.Marshal(msg)
33 if err != nil {
34 return nil, err
35 }
36
37 lengthBytes := make([]byte, 10)
38 n := binary.PutUvarint(lengthBytes, uint64(len(msgBytes)))
39 return append(lengthBytes[:n], msgBytes...), nil
40 }
41
42 func makeRPCPacket(msgs ...proto.Message) ([]byte, error) {
43 packet := make([]byte, 4, 128)
44
45 length := 0
46 for _, msg := range msgs {
47 b, err := makePrefixedMessage(msg)
48 if err != nil {
49 return nil, err
50 }
51
52 packet = append(packet, b...)
53 length += len(b)
54 }
55
56 binary.BigEndian.PutUint32(packet, uint32(length))
57 return packet, nil
58 }
59
60 func readRPCPacket(r io.Reader, msgs ...proto.Message) error {
61 var packetLength uint32
62 err := binary.Read(r, binary.BigEndian, &packetLength)
63 if err != nil {
64 return err
65 }
66
67 packet := make([]byte, packetLength)
68 _, err = io.ReadFull(r, packet)
69 if err != nil {
70 return err
71 }
72
73 for _, msg := range msgs {
74 // HDFS doesn't send all the response messages all the time (for example, if
75 // the RpcResponseHeaderProto contains an error).
76 if len(packet) == 0 {
77 return nil
78 }
79
80 msgLength, n := binary.Uvarint(packet)
81 if n <= 0 || msgLength > uint64(len(packet)) {
82 return errInvalidResponse
83 }
84
85 packet = packet[n:]
86 if msgLength != 0 {
87 err = proto.Unmarshal(packet[:msgLength], msg)
88 if err != nil {
89 return err
90 }
91
92 packet = packet[msgLength:]
93 }
94 }
95
96 if len(packet) > 0 {
97 return errInvalidResponse
98 }
99
100 return nil
101 }