cubefs

1
package sarama
2

3
import "time"
4

5
// DeleteAclsResponse is a delete acl response
6
type DeleteAclsResponse struct {
7
	Version         int16
8
	ThrottleTime    time.Duration
9
	FilterResponses []*FilterResponse
10
}
11

12
func (d *DeleteAclsResponse) encode(pe packetEncoder) error {
13
	pe.putInt32(int32(d.ThrottleTime / time.Millisecond))
14

15
	if err := pe.putArrayLength(len(d.FilterResponses)); err != nil {
16
		return err
17
	}
18

19
	for _, filterResponse := range d.FilterResponses {
20
		if err := filterResponse.encode(pe, d.Version); err != nil {
21
			return err
22
		}
23
	}
24

25
	return nil
26
}
27

28
func (d *DeleteAclsResponse) decode(pd packetDecoder, version int16) (err error) {
29
	throttleTime, err := pd.getInt32()
30
	if err != nil {
31
		return err
32
	}
33
	d.ThrottleTime = time.Duration(throttleTime) * time.Millisecond
34

35
	n, err := pd.getArrayLength()
36
	if err != nil {
37
		return err
38
	}
39
	d.FilterResponses = make([]*FilterResponse, n)
40

41
	for i := 0; i < n; i++ {
42
		d.FilterResponses[i] = new(FilterResponse)
43
		if err := d.FilterResponses[i].decode(pd, version); err != nil {
44
			return err
45
		}
46
	}
47

48
	return nil
49
}
50

51
func (d *DeleteAclsResponse) key() int16 {
52
	return 31
53
}
54

55
func (d *DeleteAclsResponse) version() int16 {
56
	return d.Version
57
}
58

59
func (d *DeleteAclsResponse) headerVersion() int16 {
60
	return 0
61
}
62

63
func (d *DeleteAclsResponse) requiredVersion() KafkaVersion {
64
	return V0_11_0_0
65
}
66

67
// FilterResponse is a filter response type
68
type FilterResponse struct {
69
	Err          KError
70
	ErrMsg       *string
71
	MatchingAcls []*MatchingAcl
72
}
73

74
func (f *FilterResponse) encode(pe packetEncoder, version int16) error {
75
	pe.putInt16(int16(f.Err))
76
	if err := pe.putNullableString(f.ErrMsg); err != nil {
77
		return err
78
	}
79

80
	if err := pe.putArrayLength(len(f.MatchingAcls)); err != nil {
81
		return err
82
	}
83
	for _, matchingAcl := range f.MatchingAcls {
84
		if err := matchingAcl.encode(pe, version); err != nil {
85
			return err
86
		}
87
	}
88

89
	return nil
90
}
91

92
func (f *FilterResponse) decode(pd packetDecoder, version int16) (err error) {
93
	kerr, err := pd.getInt16()
94
	if err != nil {
95
		return err
96
	}
97
	f.Err = KError(kerr)
98

99
	if f.ErrMsg, err = pd.getNullableString(); err != nil {
100
		return err
101
	}
102

103
	n, err := pd.getArrayLength()
104
	if err != nil {
105
		return err
106
	}
107
	f.MatchingAcls = make([]*MatchingAcl, n)
108
	for i := 0; i < n; i++ {
109
		f.MatchingAcls[i] = new(MatchingAcl)
110
		if err := f.MatchingAcls[i].decode(pd, version); err != nil {
111
			return err
112
		}
113
	}
114

115
	return nil
116
}
117

118
// MatchingAcl is a matching acl type
119
type MatchingAcl struct {
120
	Err    KError
121
	ErrMsg *string
122
	Resource
123
	Acl
124
}
125

126
func (m *MatchingAcl) encode(pe packetEncoder, version int16) error {
127
	pe.putInt16(int16(m.Err))
128
	if err := pe.putNullableString(m.ErrMsg); err != nil {
129
		return err
130
	}
131

132
	if err := m.Resource.encode(pe, version); err != nil {
133
		return err
134
	}
135

136
	if err := m.Acl.encode(pe); err != nil {
137
		return err
138
	}
139

140
	return nil
141
}
142

143
func (m *MatchingAcl) decode(pd packetDecoder, version int16) (err error) {
144
	kerr, err := pd.getInt16()
145
	if err != nil {
146
		return err
147
	}
148
	m.Err = KError(kerr)
149

150
	if m.ErrMsg, err = pd.getNullableString(); err != nil {
151
		return err
152
	}
153

154
	if err := m.Resource.decode(pd, version); err != nil {
155
		return err
156
	}
157

158
	if err := m.Acl.decode(pd, version); err != nil {
159
		return err
160
	}
161

162
	return nil
163
}
164