1
16
17
18
19
20 package v1
21
22 import (
23 fmt "fmt"
24
25 io "io"
26
27 proto "github.com/gogo/protobuf/proto"
28 github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
29 v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
30
31 math "math"
32 math_bits "math/bits"
33 reflect "reflect"
34 strings "strings"
35
36 intstr "k8s.io/apimachinery/pkg/util/intstr"
37 )
38
39
40 var _ = proto.Marshal
41 var _ = fmt.Errorf
42 var _ = math.Inf
43
44
45
46
47
48 const _ = proto.GoGoProtoPackageIsVersion3
49
50 func (m *Eviction) Reset() { *m = Eviction{} }
51 func (*Eviction) ProtoMessage() {}
52 func (*Eviction) Descriptor() ([]byte, []int) {
53 return fileDescriptor_204bc6fa48ff56f7, []int{0}
54 }
55 func (m *Eviction) XXX_Unmarshal(b []byte) error {
56 return m.Unmarshal(b)
57 }
58 func (m *Eviction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
59 b = b[:cap(b)]
60 n, err := m.MarshalToSizedBuffer(b)
61 if err != nil {
62 return nil, err
63 }
64 return b[:n], nil
65 }
66 func (m *Eviction) XXX_Merge(src proto.Message) {
67 xxx_messageInfo_Eviction.Merge(m, src)
68 }
69 func (m *Eviction) XXX_Size() int {
70 return m.Size()
71 }
72 func (m *Eviction) XXX_DiscardUnknown() {
73 xxx_messageInfo_Eviction.DiscardUnknown(m)
74 }
75
76 var xxx_messageInfo_Eviction proto.InternalMessageInfo
77
78 func (m *PodDisruptionBudget) Reset() { *m = PodDisruptionBudget{} }
79 func (*PodDisruptionBudget) ProtoMessage() {}
80 func (*PodDisruptionBudget) Descriptor() ([]byte, []int) {
81 return fileDescriptor_204bc6fa48ff56f7, []int{1}
82 }
83 func (m *PodDisruptionBudget) XXX_Unmarshal(b []byte) error {
84 return m.Unmarshal(b)
85 }
86 func (m *PodDisruptionBudget) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
87 b = b[:cap(b)]
88 n, err := m.MarshalToSizedBuffer(b)
89 if err != nil {
90 return nil, err
91 }
92 return b[:n], nil
93 }
94 func (m *PodDisruptionBudget) XXX_Merge(src proto.Message) {
95 xxx_messageInfo_PodDisruptionBudget.Merge(m, src)
96 }
97 func (m *PodDisruptionBudget) XXX_Size() int {
98 return m.Size()
99 }
100 func (m *PodDisruptionBudget) XXX_DiscardUnknown() {
101 xxx_messageInfo_PodDisruptionBudget.DiscardUnknown(m)
102 }
103
104 var xxx_messageInfo_PodDisruptionBudget proto.InternalMessageInfo
105
106 func (m *PodDisruptionBudgetList) Reset() { *m = PodDisruptionBudgetList{} }
107 func (*PodDisruptionBudgetList) ProtoMessage() {}
108 func (*PodDisruptionBudgetList) Descriptor() ([]byte, []int) {
109 return fileDescriptor_204bc6fa48ff56f7, []int{2}
110 }
111 func (m *PodDisruptionBudgetList) XXX_Unmarshal(b []byte) error {
112 return m.Unmarshal(b)
113 }
114 func (m *PodDisruptionBudgetList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
115 b = b[:cap(b)]
116 n, err := m.MarshalToSizedBuffer(b)
117 if err != nil {
118 return nil, err
119 }
120 return b[:n], nil
121 }
122 func (m *PodDisruptionBudgetList) XXX_Merge(src proto.Message) {
123 xxx_messageInfo_PodDisruptionBudgetList.Merge(m, src)
124 }
125 func (m *PodDisruptionBudgetList) XXX_Size() int {
126 return m.Size()
127 }
128 func (m *PodDisruptionBudgetList) XXX_DiscardUnknown() {
129 xxx_messageInfo_PodDisruptionBudgetList.DiscardUnknown(m)
130 }
131
132 var xxx_messageInfo_PodDisruptionBudgetList proto.InternalMessageInfo
133
134 func (m *PodDisruptionBudgetSpec) Reset() { *m = PodDisruptionBudgetSpec{} }
135 func (*PodDisruptionBudgetSpec) ProtoMessage() {}
136 func (*PodDisruptionBudgetSpec) Descriptor() ([]byte, []int) {
137 return fileDescriptor_204bc6fa48ff56f7, []int{3}
138 }
139 func (m *PodDisruptionBudgetSpec) XXX_Unmarshal(b []byte) error {
140 return m.Unmarshal(b)
141 }
142 func (m *PodDisruptionBudgetSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
143 b = b[:cap(b)]
144 n, err := m.MarshalToSizedBuffer(b)
145 if err != nil {
146 return nil, err
147 }
148 return b[:n], nil
149 }
150 func (m *PodDisruptionBudgetSpec) XXX_Merge(src proto.Message) {
151 xxx_messageInfo_PodDisruptionBudgetSpec.Merge(m, src)
152 }
153 func (m *PodDisruptionBudgetSpec) XXX_Size() int {
154 return m.Size()
155 }
156 func (m *PodDisruptionBudgetSpec) XXX_DiscardUnknown() {
157 xxx_messageInfo_PodDisruptionBudgetSpec.DiscardUnknown(m)
158 }
159
160 var xxx_messageInfo_PodDisruptionBudgetSpec proto.InternalMessageInfo
161
162 func (m *PodDisruptionBudgetStatus) Reset() { *m = PodDisruptionBudgetStatus{} }
163 func (*PodDisruptionBudgetStatus) ProtoMessage() {}
164 func (*PodDisruptionBudgetStatus) Descriptor() ([]byte, []int) {
165 return fileDescriptor_204bc6fa48ff56f7, []int{4}
166 }
167 func (m *PodDisruptionBudgetStatus) XXX_Unmarshal(b []byte) error {
168 return m.Unmarshal(b)
169 }
170 func (m *PodDisruptionBudgetStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
171 b = b[:cap(b)]
172 n, err := m.MarshalToSizedBuffer(b)
173 if err != nil {
174 return nil, err
175 }
176 return b[:n], nil
177 }
178 func (m *PodDisruptionBudgetStatus) XXX_Merge(src proto.Message) {
179 xxx_messageInfo_PodDisruptionBudgetStatus.Merge(m, src)
180 }
181 func (m *PodDisruptionBudgetStatus) XXX_Size() int {
182 return m.Size()
183 }
184 func (m *PodDisruptionBudgetStatus) XXX_DiscardUnknown() {
185 xxx_messageInfo_PodDisruptionBudgetStatus.DiscardUnknown(m)
186 }
187
188 var xxx_messageInfo_PodDisruptionBudgetStatus proto.InternalMessageInfo
189
190 func init() {
191 proto.RegisterType((*Eviction)(nil), "k8s.io.api.policy.v1.Eviction")
192 proto.RegisterType((*PodDisruptionBudget)(nil), "k8s.io.api.policy.v1.PodDisruptionBudget")
193 proto.RegisterType((*PodDisruptionBudgetList)(nil), "k8s.io.api.policy.v1.PodDisruptionBudgetList")
194 proto.RegisterType((*PodDisruptionBudgetSpec)(nil), "k8s.io.api.policy.v1.PodDisruptionBudgetSpec")
195 proto.RegisterType((*PodDisruptionBudgetStatus)(nil), "k8s.io.api.policy.v1.PodDisruptionBudgetStatus")
196 proto.RegisterMapType((map[string]v1.Time)(nil), "k8s.io.api.policy.v1.PodDisruptionBudgetStatus.DisruptedPodsEntry")
197 }
198
199 func init() {
200 proto.RegisterFile("k8s.io/api/policy/v1/generated.proto", fileDescriptor_204bc6fa48ff56f7)
201 }
202
203 var fileDescriptor_204bc6fa48ff56f7 = []byte{
204
205 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x96, 0x4d, 0x8f, 0xdb, 0x44,
206 0x18, 0xc7, 0xe3, 0xcd, 0x66, 0xd9, 0x4e, 0x93, 0x68, 0x19, 0x16, 0x58, 0x72, 0x70, 0xaa, 0x88,
207 0xc3, 0x82, 0xd4, 0x31, 0xdb, 0x22, 0xb4, 0xea, 0x01, 0xb5, 0x6e, 0x56, 0x50, 0xd4, 0x25, 0xab,
208 0xd9, 0x56, 0x48, 0x08, 0x24, 0x26, 0xf6, 0xd3, 0x64, 0x58, 0xdb, 0x63, 0x79, 0xc6, 0xa1, 0x39,
209 0xd1, 0x8f, 0xc0, 0x57, 0xe0, 0xa3, 0x70, 0x62, 0x8f, 0xe5, 0x56, 0x71, 0x88, 0x58, 0xf3, 0x2d,
210 0x38, 0x21, 0x8f, 0x9d, 0x17, 0x27, 0x0e, 0xcd, 0x72, 0xe8, 0xcd, 0xf3, 0xcc, 0xf3, 0xff, 0x3d,
211 0xf3, 0xbc, 0xcc, 0x24, 0xe8, 0xc3, 0x8b, 0x63, 0x49, 0xb8, 0xb0, 0x58, 0xc8, 0xad, 0x50, 0x78,
212 0xdc, 0x19, 0x5b, 0xa3, 0x23, 0x6b, 0x00, 0x01, 0x44, 0x4c, 0x81, 0x4b, 0xc2, 0x48, 0x28, 0x81,
213 0xf7, 0x33, 0x2f, 0xc2, 0x42, 0x4e, 0x32, 0x2f, 0x32, 0x3a, 0x6a, 0xdd, 0x1e, 0x70, 0x35, 0x8c,
214 0xfb, 0xc4, 0x11, 0xbe, 0x35, 0x10, 0x03, 0x61, 0x69, 0xe7, 0x7e, 0xfc, 0x4c, 0xaf, 0xf4, 0x42,
215 0x7f, 0x65, 0x90, 0xd6, 0xa7, 0xf3, 0x50, 0x3e, 0x73, 0x86, 0x3c, 0x80, 0x68, 0x6c, 0x85, 0x17,
216 0x83, 0xd4, 0x20, 0x2d, 0x1f, 0x14, 0x2b, 0x09, 0xdd, 0xb2, 0xd6, 0xa9, 0xa2, 0x38, 0x50, 0xdc,
217 0x87, 0x15, 0xc1, 0x67, 0xaf, 0x13, 0x48, 0x67, 0x08, 0x3e, 0x5b, 0xd1, 0xdd, 0x5d, 0xa7, 0x8b,
218 0x15, 0xf7, 0x2c, 0x1e, 0x28, 0xa9, 0xa2, 0x65, 0x51, 0xe7, 0x4f, 0x03, 0xed, 0x9e, 0x8c, 0xb8,
219 0xa3, 0xb8, 0x08, 0xf0, 0x0f, 0x68, 0x37, 0xcd, 0xc2, 0x65, 0x8a, 0x1d, 0x18, 0xb7, 0x8c, 0xc3,
220 0x9b, 0x77, 0x3e, 0x21, 0xf3, 0xc2, 0xcd, 0xa0, 0x24, 0xbc, 0x18, 0xa4, 0x06, 0x49, 0x52, 0x6f,
221 0x32, 0x3a, 0x22, 0xbd, 0xfe, 0x8f, 0xe0, 0xa8, 0x53, 0x50, 0xcc, 0xc6, 0x97, 0x93, 0x76, 0x25,
222 0x99, 0xb4, 0xd1, 0xdc, 0x46, 0x67, 0x54, 0xec, 0xa1, 0x86, 0x0b, 0x1e, 0x28, 0xe8, 0x85, 0x69,
223 0x44, 0x79, 0xb0, 0xa5, 0xc3, 0xdc, 0xdd, 0x2c, 0x4c, 0x77, 0x51, 0x6a, 0xbf, 0x9d, 0x4c, 0xda,
224 0x8d, 0x82, 0x89, 0x16, 0xe1, 0x9d, 0x5f, 0xb7, 0xd0, 0x3b, 0x67, 0xc2, 0xed, 0x72, 0x19, 0xc5,
225 0xda, 0x64, 0xc7, 0xee, 0x00, 0xd4, 0x1b, 0xc8, 0xb3, 0x87, 0xb6, 0x65, 0x08, 0x4e, 0x9e, 0xde,
226 0x6d, 0x52, 0x36, 0x7e, 0xa4, 0xe4, 0x68, 0xe7, 0x21, 0x38, 0x76, 0x3d, 0x47, 0x6f, 0xa7, 0x2b,
227 0xaa, 0x41, 0xf8, 0x1b, 0xb4, 0x23, 0x15, 0x53, 0xb1, 0x3c, 0xa8, 0x6a, 0xa4, 0xb5, 0x39, 0x52,
228 0xcb, 0xec, 0x66, 0x0e, 0xdd, 0xc9, 0xd6, 0x34, 0xc7, 0x75, 0x7e, 0x37, 0xd0, 0xfb, 0x25, 0xaa,
229 0xc7, 0x5c, 0x2a, 0xfc, 0xdd, 0x4a, 0x9d, 0xc8, 0x66, 0x75, 0x4a, 0xd5, 0xba, 0x4a, 0x7b, 0x79,
230 0xd4, 0xdd, 0xa9, 0x65, 0xa1, 0x46, 0x5f, 0xa3, 0x1a, 0x57, 0xe0, 0xa7, 0x33, 0x50, 0x3d, 0xbc,
231 0x79, 0xe7, 0xa3, 0x8d, 0x33, 0xb2, 0x1b, 0x39, 0xb5, 0xf6, 0x28, 0xd5, 0xd3, 0x0c, 0xd3, 0xf9,
232 0xa3, 0x5a, 0x9a, 0x49, 0x5a, 0x44, 0xfc, 0x0c, 0xd5, 0x7d, 0x1e, 0x3c, 0x18, 0x31, 0xee, 0xb1,
233 0xbe, 0x07, 0xaf, 0xed, 0x7a, 0x7a, 0x65, 0x48, 0x76, 0x65, 0xc8, 0xa3, 0x40, 0xf5, 0xa2, 0x73,
234 0x15, 0xf1, 0x60, 0x60, 0xef, 0x25, 0x93, 0x76, 0xfd, 0x74, 0x81, 0x44, 0x0b, 0x5c, 0xfc, 0x3d,
235 0xda, 0x95, 0xe0, 0x81, 0xa3, 0x44, 0x74, 0xbd, 0xd1, 0x7e, 0xcc, 0xfa, 0xe0, 0x9d, 0xe7, 0x52,
236 0xbb, 0x9e, 0x96, 0x6c, 0xba, 0xa2, 0x33, 0x24, 0xf6, 0x50, 0xd3, 0x67, 0xcf, 0x9f, 0x06, 0x6c,
237 0x96, 0x48, 0xf5, 0x7f, 0x26, 0x82, 0x93, 0x49, 0xbb, 0x79, 0x5a, 0x60, 0xd1, 0x25, 0x36, 0x7e,
238 0x61, 0xa0, 0x56, 0x1c, 0x0c, 0x81, 0x79, 0x6a, 0x38, 0x3e, 0x13, 0xee, 0xf4, 0x9d, 0x38, 0xd3,
239 0xcd, 0x39, 0xd8, 0xbe, 0x65, 0x1c, 0xde, 0xb0, 0xef, 0x27, 0x93, 0x76, 0xeb, 0xe9, 0x5a, 0xaf,
240 0x7f, 0x26, 0x6d, 0x73, 0xfd, 0xee, 0x93, 0x71, 0x08, 0xf4, 0x3f, 0x62, 0x74, 0x7e, 0xab, 0xa1,
241 0x0f, 0xd6, 0xce, 0x34, 0xfe, 0x0a, 0x61, 0xd1, 0x97, 0x10, 0x8d, 0xc0, 0xfd, 0x22, 0x7b, 0xd7,
242 0xb8, 0x08, 0x74, 0x6f, 0xab, 0x76, 0x2b, 0x9f, 0x11, 0xdc, 0x5b, 0xf1, 0xa0, 0x25, 0x2a, 0xfc,
243 0x33, 0x6a, 0xb8, 0x59, 0x14, 0x70, 0xcf, 0x84, 0x3b, 0x9d, 0x4a, 0xfb, 0x9a, 0xf7, 0x8c, 0x74,
244 0x17, 0x21, 0x27, 0x81, 0x8a, 0xc6, 0xf6, 0xbb, 0xf9, 0x51, 0x1a, 0x85, 0x3d, 0x5a, 0x8c, 0x97,
245 0x26, 0xe3, 0xce, 0x90, 0xf2, 0x81, 0xe7, 0x89, 0x9f, 0xc0, 0xd5, 0xfd, 0xad, 0xcd, 0x93, 0xe9,
246 0xae, 0x78, 0xd0, 0x12, 0x15, 0xfe, 0x1c, 0x35, 0x9d, 0x38, 0x8a, 0x20, 0x50, 0x5f, 0x66, 0x95,
247 0xd5, 0xcd, 0xaa, 0xd9, 0xef, 0xe5, 0x9c, 0xe6, 0xc3, 0xc2, 0x2e, 0x5d, 0xf2, 0x4e, 0xf5, 0x2e,
248 0x48, 0x1e, 0x81, 0x3b, 0xd5, 0xd7, 0x8a, 0xfa, 0x6e, 0x61, 0x97, 0x2e, 0x79, 0xe3, 0x63, 0x54,
249 0x87, 0xe7, 0x21, 0x38, 0xd3, 0x5a, 0xee, 0x68, 0xf5, 0x7e, 0xae, 0xae, 0x9f, 0x2c, 0xec, 0xd1,
250 0x82, 0x27, 0x76, 0x10, 0x72, 0x44, 0xe0, 0xf2, 0xec, 0xd7, 0xe1, 0x2d, 0xdd, 0x03, 0x6b, 0xb3,
251 0x2b, 0xf4, 0x70, 0xaa, 0x9b, 0xbf, 0xcd, 0x33, 0x93, 0xa4, 0x0b, 0xd8, 0x96, 0x87, 0xf0, 0x6a,
252 0x9b, 0xf0, 0x1e, 0xaa, 0x5e, 0xc0, 0x58, 0x8f, 0xcf, 0x0d, 0x9a, 0x7e, 0xe2, 0xfb, 0xa8, 0x36,
253 0x62, 0x5e, 0x0c, 0xf9, 0x55, 0xfe, 0x78, 0xb3, 0x73, 0x3c, 0xe1, 0x3e, 0xd0, 0x4c, 0x78, 0x6f,
254 0xeb, 0xd8, 0xb0, 0xef, 0x5d, 0x5e, 0x99, 0x95, 0x97, 0x57, 0x66, 0xe5, 0xd5, 0x95, 0x59, 0x79,
255 0x91, 0x98, 0xc6, 0x65, 0x62, 0x1a, 0x2f, 0x13, 0xd3, 0x78, 0x95, 0x98, 0xc6, 0x5f, 0x89, 0x69,
256 0xfc, 0xf2, 0xb7, 0x59, 0xf9, 0x76, 0xbf, 0xec, 0x7f, 0xcc, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
257 0x0f, 0x42, 0xd2, 0x33, 0xde, 0x08, 0x00, 0x00,
258 }
259
260 func (m *Eviction) Marshal() (dAtA []byte, err error) {
261 size := m.Size()
262 dAtA = make([]byte, size)
263 n, err := m.MarshalToSizedBuffer(dAtA[:size])
264 if err != nil {
265 return nil, err
266 }
267 return dAtA[:n], nil
268 }
269
270 func (m *Eviction) MarshalTo(dAtA []byte) (int, error) {
271 size := m.Size()
272 return m.MarshalToSizedBuffer(dAtA[:size])
273 }
274
275 func (m *Eviction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
276 i := len(dAtA)
277 _ = i
278 var l int
279 _ = l
280 if m.DeleteOptions != nil {
281 {
282 size, err := m.DeleteOptions.MarshalToSizedBuffer(dAtA[:i])
283 if err != nil {
284 return 0, err
285 }
286 i -= size
287 i = encodeVarintGenerated(dAtA, i, uint64(size))
288 }
289 i--
290 dAtA[i] = 0x12
291 }
292 {
293 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
294 if err != nil {
295 return 0, err
296 }
297 i -= size
298 i = encodeVarintGenerated(dAtA, i, uint64(size))
299 }
300 i--
301 dAtA[i] = 0xa
302 return len(dAtA) - i, nil
303 }
304
305 func (m *PodDisruptionBudget) Marshal() (dAtA []byte, err error) {
306 size := m.Size()
307 dAtA = make([]byte, size)
308 n, err := m.MarshalToSizedBuffer(dAtA[:size])
309 if err != nil {
310 return nil, err
311 }
312 return dAtA[:n], nil
313 }
314
315 func (m *PodDisruptionBudget) MarshalTo(dAtA []byte) (int, error) {
316 size := m.Size()
317 return m.MarshalToSizedBuffer(dAtA[:size])
318 }
319
320 func (m *PodDisruptionBudget) MarshalToSizedBuffer(dAtA []byte) (int, error) {
321 i := len(dAtA)
322 _ = i
323 var l int
324 _ = l
325 {
326 size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
327 if err != nil {
328 return 0, err
329 }
330 i -= size
331 i = encodeVarintGenerated(dAtA, i, uint64(size))
332 }
333 i--
334 dAtA[i] = 0x1a
335 {
336 size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i])
337 if err != nil {
338 return 0, err
339 }
340 i -= size
341 i = encodeVarintGenerated(dAtA, i, uint64(size))
342 }
343 i--
344 dAtA[i] = 0x12
345 {
346 size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
347 if err != nil {
348 return 0, err
349 }
350 i -= size
351 i = encodeVarintGenerated(dAtA, i, uint64(size))
352 }
353 i--
354 dAtA[i] = 0xa
355 return len(dAtA) - i, nil
356 }
357
358 func (m *PodDisruptionBudgetList) Marshal() (dAtA []byte, err error) {
359 size := m.Size()
360 dAtA = make([]byte, size)
361 n, err := m.MarshalToSizedBuffer(dAtA[:size])
362 if err != nil {
363 return nil, err
364 }
365 return dAtA[:n], nil
366 }
367
368 func (m *PodDisruptionBudgetList) MarshalTo(dAtA []byte) (int, error) {
369 size := m.Size()
370 return m.MarshalToSizedBuffer(dAtA[:size])
371 }
372
373 func (m *PodDisruptionBudgetList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
374 i := len(dAtA)
375 _ = i
376 var l int
377 _ = l
378 if len(m.Items) > 0 {
379 for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
380 {
381 size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
382 if err != nil {
383 return 0, err
384 }
385 i -= size
386 i = encodeVarintGenerated(dAtA, i, uint64(size))
387 }
388 i--
389 dAtA[i] = 0x12
390 }
391 }
392 {
393 size, err := m.ListMeta.MarshalToSizedBuffer(dAtA[:i])
394 if err != nil {
395 return 0, err
396 }
397 i -= size
398 i = encodeVarintGenerated(dAtA, i, uint64(size))
399 }
400 i--
401 dAtA[i] = 0xa
402 return len(dAtA) - i, nil
403 }
404
405 func (m *PodDisruptionBudgetSpec) Marshal() (dAtA []byte, err error) {
406 size := m.Size()
407 dAtA = make([]byte, size)
408 n, err := m.MarshalToSizedBuffer(dAtA[:size])
409 if err != nil {
410 return nil, err
411 }
412 return dAtA[:n], nil
413 }
414
415 func (m *PodDisruptionBudgetSpec) MarshalTo(dAtA []byte) (int, error) {
416 size := m.Size()
417 return m.MarshalToSizedBuffer(dAtA[:size])
418 }
419
420 func (m *PodDisruptionBudgetSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
421 i := len(dAtA)
422 _ = i
423 var l int
424 _ = l
425 if m.UnhealthyPodEvictionPolicy != nil {
426 i -= len(*m.UnhealthyPodEvictionPolicy)
427 copy(dAtA[i:], *m.UnhealthyPodEvictionPolicy)
428 i = encodeVarintGenerated(dAtA, i, uint64(len(*m.UnhealthyPodEvictionPolicy)))
429 i--
430 dAtA[i] = 0x22
431 }
432 if m.MaxUnavailable != nil {
433 {
434 size, err := m.MaxUnavailable.MarshalToSizedBuffer(dAtA[:i])
435 if err != nil {
436 return 0, err
437 }
438 i -= size
439 i = encodeVarintGenerated(dAtA, i, uint64(size))
440 }
441 i--
442 dAtA[i] = 0x1a
443 }
444 if m.Selector != nil {
445 {
446 size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
447 if err != nil {
448 return 0, err
449 }
450 i -= size
451 i = encodeVarintGenerated(dAtA, i, uint64(size))
452 }
453 i--
454 dAtA[i] = 0x12
455 }
456 if m.MinAvailable != nil {
457 {
458 size, err := m.MinAvailable.MarshalToSizedBuffer(dAtA[:i])
459 if err != nil {
460 return 0, err
461 }
462 i -= size
463 i = encodeVarintGenerated(dAtA, i, uint64(size))
464 }
465 i--
466 dAtA[i] = 0xa
467 }
468 return len(dAtA) - i, nil
469 }
470
471 func (m *PodDisruptionBudgetStatus) Marshal() (dAtA []byte, err error) {
472 size := m.Size()
473 dAtA = make([]byte, size)
474 n, err := m.MarshalToSizedBuffer(dAtA[:size])
475 if err != nil {
476 return nil, err
477 }
478 return dAtA[:n], nil
479 }
480
481 func (m *PodDisruptionBudgetStatus) MarshalTo(dAtA []byte) (int, error) {
482 size := m.Size()
483 return m.MarshalToSizedBuffer(dAtA[:size])
484 }
485
486 func (m *PodDisruptionBudgetStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
487 i := len(dAtA)
488 _ = i
489 var l int
490 _ = l
491 if len(m.Conditions) > 0 {
492 for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- {
493 {
494 size, err := m.Conditions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
495 if err != nil {
496 return 0, err
497 }
498 i -= size
499 i = encodeVarintGenerated(dAtA, i, uint64(size))
500 }
501 i--
502 dAtA[i] = 0x3a
503 }
504 }
505 i = encodeVarintGenerated(dAtA, i, uint64(m.ExpectedPods))
506 i--
507 dAtA[i] = 0x30
508 i = encodeVarintGenerated(dAtA, i, uint64(m.DesiredHealthy))
509 i--
510 dAtA[i] = 0x28
511 i = encodeVarintGenerated(dAtA, i, uint64(m.CurrentHealthy))
512 i--
513 dAtA[i] = 0x20
514 i = encodeVarintGenerated(dAtA, i, uint64(m.DisruptionsAllowed))
515 i--
516 dAtA[i] = 0x18
517 if len(m.DisruptedPods) > 0 {
518 keysForDisruptedPods := make([]string, 0, len(m.DisruptedPods))
519 for k := range m.DisruptedPods {
520 keysForDisruptedPods = append(keysForDisruptedPods, string(k))
521 }
522 github_com_gogo_protobuf_sortkeys.Strings(keysForDisruptedPods)
523 for iNdEx := len(keysForDisruptedPods) - 1; iNdEx >= 0; iNdEx-- {
524 v := m.DisruptedPods[string(keysForDisruptedPods[iNdEx])]
525 baseI := i
526 {
527 size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
528 if err != nil {
529 return 0, err
530 }
531 i -= size
532 i = encodeVarintGenerated(dAtA, i, uint64(size))
533 }
534 i--
535 dAtA[i] = 0x12
536 i -= len(keysForDisruptedPods[iNdEx])
537 copy(dAtA[i:], keysForDisruptedPods[iNdEx])
538 i = encodeVarintGenerated(dAtA, i, uint64(len(keysForDisruptedPods[iNdEx])))
539 i--
540 dAtA[i] = 0xa
541 i = encodeVarintGenerated(dAtA, i, uint64(baseI-i))
542 i--
543 dAtA[i] = 0x12
544 }
545 }
546 i = encodeVarintGenerated(dAtA, i, uint64(m.ObservedGeneration))
547 i--
548 dAtA[i] = 0x8
549 return len(dAtA) - i, nil
550 }
551
552 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
553 offset -= sovGenerated(v)
554 base := offset
555 for v >= 1<<7 {
556 dAtA[offset] = uint8(v&0x7f | 0x80)
557 v >>= 7
558 offset++
559 }
560 dAtA[offset] = uint8(v)
561 return base
562 }
563 func (m *Eviction) Size() (n int) {
564 if m == nil {
565 return 0
566 }
567 var l int
568 _ = l
569 l = m.ObjectMeta.Size()
570 n += 1 + l + sovGenerated(uint64(l))
571 if m.DeleteOptions != nil {
572 l = m.DeleteOptions.Size()
573 n += 1 + l + sovGenerated(uint64(l))
574 }
575 return n
576 }
577
578 func (m *PodDisruptionBudget) Size() (n int) {
579 if m == nil {
580 return 0
581 }
582 var l int
583 _ = l
584 l = m.ObjectMeta.Size()
585 n += 1 + l + sovGenerated(uint64(l))
586 l = m.Spec.Size()
587 n += 1 + l + sovGenerated(uint64(l))
588 l = m.Status.Size()
589 n += 1 + l + sovGenerated(uint64(l))
590 return n
591 }
592
593 func (m *PodDisruptionBudgetList) Size() (n int) {
594 if m == nil {
595 return 0
596 }
597 var l int
598 _ = l
599 l = m.ListMeta.Size()
600 n += 1 + l + sovGenerated(uint64(l))
601 if len(m.Items) > 0 {
602 for _, e := range m.Items {
603 l = e.Size()
604 n += 1 + l + sovGenerated(uint64(l))
605 }
606 }
607 return n
608 }
609
610 func (m *PodDisruptionBudgetSpec) Size() (n int) {
611 if m == nil {
612 return 0
613 }
614 var l int
615 _ = l
616 if m.MinAvailable != nil {
617 l = m.MinAvailable.Size()
618 n += 1 + l + sovGenerated(uint64(l))
619 }
620 if m.Selector != nil {
621 l = m.Selector.Size()
622 n += 1 + l + sovGenerated(uint64(l))
623 }
624 if m.MaxUnavailable != nil {
625 l = m.MaxUnavailable.Size()
626 n += 1 + l + sovGenerated(uint64(l))
627 }
628 if m.UnhealthyPodEvictionPolicy != nil {
629 l = len(*m.UnhealthyPodEvictionPolicy)
630 n += 1 + l + sovGenerated(uint64(l))
631 }
632 return n
633 }
634
635 func (m *PodDisruptionBudgetStatus) Size() (n int) {
636 if m == nil {
637 return 0
638 }
639 var l int
640 _ = l
641 n += 1 + sovGenerated(uint64(m.ObservedGeneration))
642 if len(m.DisruptedPods) > 0 {
643 for k, v := range m.DisruptedPods {
644 _ = k
645 _ = v
646 l = v.Size()
647 mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + l + sovGenerated(uint64(l))
648 n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
649 }
650 }
651 n += 1 + sovGenerated(uint64(m.DisruptionsAllowed))
652 n += 1 + sovGenerated(uint64(m.CurrentHealthy))
653 n += 1 + sovGenerated(uint64(m.DesiredHealthy))
654 n += 1 + sovGenerated(uint64(m.ExpectedPods))
655 if len(m.Conditions) > 0 {
656 for _, e := range m.Conditions {
657 l = e.Size()
658 n += 1 + l + sovGenerated(uint64(l))
659 }
660 }
661 return n
662 }
663
664 func sovGenerated(x uint64) (n int) {
665 return (math_bits.Len64(x|1) + 6) / 7
666 }
667 func sozGenerated(x uint64) (n int) {
668 return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63))))
669 }
670 func (this *Eviction) String() string {
671 if this == nil {
672 return "nil"
673 }
674 s := strings.Join([]string{`&Eviction{`,
675 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
676 `DeleteOptions:` + strings.Replace(fmt.Sprintf("%v", this.DeleteOptions), "DeleteOptions", "v1.DeleteOptions", 1) + `,`,
677 `}`,
678 }, "")
679 return s
680 }
681 func (this *PodDisruptionBudget) String() string {
682 if this == nil {
683 return "nil"
684 }
685 s := strings.Join([]string{`&PodDisruptionBudget{`,
686 `ObjectMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ObjectMeta), "ObjectMeta", "v1.ObjectMeta", 1), `&`, ``, 1) + `,`,
687 `Spec:` + strings.Replace(strings.Replace(this.Spec.String(), "PodDisruptionBudgetSpec", "PodDisruptionBudgetSpec", 1), `&`, ``, 1) + `,`,
688 `Status:` + strings.Replace(strings.Replace(this.Status.String(), "PodDisruptionBudgetStatus", "PodDisruptionBudgetStatus", 1), `&`, ``, 1) + `,`,
689 `}`,
690 }, "")
691 return s
692 }
693 func (this *PodDisruptionBudgetList) String() string {
694 if this == nil {
695 return "nil"
696 }
697 repeatedStringForItems := "[]PodDisruptionBudget{"
698 for _, f := range this.Items {
699 repeatedStringForItems += strings.Replace(strings.Replace(f.String(), "PodDisruptionBudget", "PodDisruptionBudget", 1), `&`, ``, 1) + ","
700 }
701 repeatedStringForItems += "}"
702 s := strings.Join([]string{`&PodDisruptionBudgetList{`,
703 `ListMeta:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ListMeta), "ListMeta", "v1.ListMeta", 1), `&`, ``, 1) + `,`,
704 `Items:` + repeatedStringForItems + `,`,
705 `}`,
706 }, "")
707 return s
708 }
709 func (this *PodDisruptionBudgetSpec) String() string {
710 if this == nil {
711 return "nil"
712 }
713 s := strings.Join([]string{`&PodDisruptionBudgetSpec{`,
714 `MinAvailable:` + strings.Replace(fmt.Sprintf("%v", this.MinAvailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
715 `Selector:` + strings.Replace(fmt.Sprintf("%v", this.Selector), "LabelSelector", "v1.LabelSelector", 1) + `,`,
716 `MaxUnavailable:` + strings.Replace(fmt.Sprintf("%v", this.MaxUnavailable), "IntOrString", "intstr.IntOrString", 1) + `,`,
717 `UnhealthyPodEvictionPolicy:` + valueToStringGenerated(this.UnhealthyPodEvictionPolicy) + `,`,
718 `}`,
719 }, "")
720 return s
721 }
722 func (this *PodDisruptionBudgetStatus) String() string {
723 if this == nil {
724 return "nil"
725 }
726 repeatedStringForConditions := "[]Condition{"
727 for _, f := range this.Conditions {
728 repeatedStringForConditions += fmt.Sprintf("%v", f) + ","
729 }
730 repeatedStringForConditions += "}"
731 keysForDisruptedPods := make([]string, 0, len(this.DisruptedPods))
732 for k := range this.DisruptedPods {
733 keysForDisruptedPods = append(keysForDisruptedPods, k)
734 }
735 github_com_gogo_protobuf_sortkeys.Strings(keysForDisruptedPods)
736 mapStringForDisruptedPods := "map[string]v1.Time{"
737 for _, k := range keysForDisruptedPods {
738 mapStringForDisruptedPods += fmt.Sprintf("%v: %v,", k, this.DisruptedPods[k])
739 }
740 mapStringForDisruptedPods += "}"
741 s := strings.Join([]string{`&PodDisruptionBudgetStatus{`,
742 `ObservedGeneration:` + fmt.Sprintf("%v", this.ObservedGeneration) + `,`,
743 `DisruptedPods:` + mapStringForDisruptedPods + `,`,
744 `DisruptionsAllowed:` + fmt.Sprintf("%v", this.DisruptionsAllowed) + `,`,
745 `CurrentHealthy:` + fmt.Sprintf("%v", this.CurrentHealthy) + `,`,
746 `DesiredHealthy:` + fmt.Sprintf("%v", this.DesiredHealthy) + `,`,
747 `ExpectedPods:` + fmt.Sprintf("%v", this.ExpectedPods) + `,`,
748 `Conditions:` + repeatedStringForConditions + `,`,
749 `}`,
750 }, "")
751 return s
752 }
753 func valueToStringGenerated(v interface{}) string {
754 rv := reflect.ValueOf(v)
755 if rv.IsNil() {
756 return "nil"
757 }
758 pv := reflect.Indirect(rv).Interface()
759 return fmt.Sprintf("*%v", pv)
760 }
761 func (m *Eviction) Unmarshal(dAtA []byte) error {
762 l := len(dAtA)
763 iNdEx := 0
764 for iNdEx < l {
765 preIndex := iNdEx
766 var wire uint64
767 for shift := uint(0); ; shift += 7 {
768 if shift >= 64 {
769 return ErrIntOverflowGenerated
770 }
771 if iNdEx >= l {
772 return io.ErrUnexpectedEOF
773 }
774 b := dAtA[iNdEx]
775 iNdEx++
776 wire |= uint64(b&0x7F) << shift
777 if b < 0x80 {
778 break
779 }
780 }
781 fieldNum := int32(wire >> 3)
782 wireType := int(wire & 0x7)
783 if wireType == 4 {
784 return fmt.Errorf("proto: Eviction: wiretype end group for non-group")
785 }
786 if fieldNum <= 0 {
787 return fmt.Errorf("proto: Eviction: illegal tag %d (wire type %d)", fieldNum, wire)
788 }
789 switch fieldNum {
790 case 1:
791 if wireType != 2 {
792 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
793 }
794 var msglen int
795 for shift := uint(0); ; shift += 7 {
796 if shift >= 64 {
797 return ErrIntOverflowGenerated
798 }
799 if iNdEx >= l {
800 return io.ErrUnexpectedEOF
801 }
802 b := dAtA[iNdEx]
803 iNdEx++
804 msglen |= int(b&0x7F) << shift
805 if b < 0x80 {
806 break
807 }
808 }
809 if msglen < 0 {
810 return ErrInvalidLengthGenerated
811 }
812 postIndex := iNdEx + msglen
813 if postIndex < 0 {
814 return ErrInvalidLengthGenerated
815 }
816 if postIndex > l {
817 return io.ErrUnexpectedEOF
818 }
819 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
820 return err
821 }
822 iNdEx = postIndex
823 case 2:
824 if wireType != 2 {
825 return fmt.Errorf("proto: wrong wireType = %d for field DeleteOptions", wireType)
826 }
827 var msglen int
828 for shift := uint(0); ; shift += 7 {
829 if shift >= 64 {
830 return ErrIntOverflowGenerated
831 }
832 if iNdEx >= l {
833 return io.ErrUnexpectedEOF
834 }
835 b := dAtA[iNdEx]
836 iNdEx++
837 msglen |= int(b&0x7F) << shift
838 if b < 0x80 {
839 break
840 }
841 }
842 if msglen < 0 {
843 return ErrInvalidLengthGenerated
844 }
845 postIndex := iNdEx + msglen
846 if postIndex < 0 {
847 return ErrInvalidLengthGenerated
848 }
849 if postIndex > l {
850 return io.ErrUnexpectedEOF
851 }
852 if m.DeleteOptions == nil {
853 m.DeleteOptions = &v1.DeleteOptions{}
854 }
855 if err := m.DeleteOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
856 return err
857 }
858 iNdEx = postIndex
859 default:
860 iNdEx = preIndex
861 skippy, err := skipGenerated(dAtA[iNdEx:])
862 if err != nil {
863 return err
864 }
865 if (skippy < 0) || (iNdEx+skippy) < 0 {
866 return ErrInvalidLengthGenerated
867 }
868 if (iNdEx + skippy) > l {
869 return io.ErrUnexpectedEOF
870 }
871 iNdEx += skippy
872 }
873 }
874
875 if iNdEx > l {
876 return io.ErrUnexpectedEOF
877 }
878 return nil
879 }
880 func (m *PodDisruptionBudget) Unmarshal(dAtA []byte) error {
881 l := len(dAtA)
882 iNdEx := 0
883 for iNdEx < l {
884 preIndex := iNdEx
885 var wire uint64
886 for shift := uint(0); ; shift += 7 {
887 if shift >= 64 {
888 return ErrIntOverflowGenerated
889 }
890 if iNdEx >= l {
891 return io.ErrUnexpectedEOF
892 }
893 b := dAtA[iNdEx]
894 iNdEx++
895 wire |= uint64(b&0x7F) << shift
896 if b < 0x80 {
897 break
898 }
899 }
900 fieldNum := int32(wire >> 3)
901 wireType := int(wire & 0x7)
902 if wireType == 4 {
903 return fmt.Errorf("proto: PodDisruptionBudget: wiretype end group for non-group")
904 }
905 if fieldNum <= 0 {
906 return fmt.Errorf("proto: PodDisruptionBudget: illegal tag %d (wire type %d)", fieldNum, wire)
907 }
908 switch fieldNum {
909 case 1:
910 if wireType != 2 {
911 return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
912 }
913 var msglen int
914 for shift := uint(0); ; shift += 7 {
915 if shift >= 64 {
916 return ErrIntOverflowGenerated
917 }
918 if iNdEx >= l {
919 return io.ErrUnexpectedEOF
920 }
921 b := dAtA[iNdEx]
922 iNdEx++
923 msglen |= int(b&0x7F) << shift
924 if b < 0x80 {
925 break
926 }
927 }
928 if msglen < 0 {
929 return ErrInvalidLengthGenerated
930 }
931 postIndex := iNdEx + msglen
932 if postIndex < 0 {
933 return ErrInvalidLengthGenerated
934 }
935 if postIndex > l {
936 return io.ErrUnexpectedEOF
937 }
938 if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
939 return err
940 }
941 iNdEx = postIndex
942 case 2:
943 if wireType != 2 {
944 return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
945 }
946 var msglen int
947 for shift := uint(0); ; shift += 7 {
948 if shift >= 64 {
949 return ErrIntOverflowGenerated
950 }
951 if iNdEx >= l {
952 return io.ErrUnexpectedEOF
953 }
954 b := dAtA[iNdEx]
955 iNdEx++
956 msglen |= int(b&0x7F) << shift
957 if b < 0x80 {
958 break
959 }
960 }
961 if msglen < 0 {
962 return ErrInvalidLengthGenerated
963 }
964 postIndex := iNdEx + msglen
965 if postIndex < 0 {
966 return ErrInvalidLengthGenerated
967 }
968 if postIndex > l {
969 return io.ErrUnexpectedEOF
970 }
971 if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
972 return err
973 }
974 iNdEx = postIndex
975 case 3:
976 if wireType != 2 {
977 return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
978 }
979 var msglen int
980 for shift := uint(0); ; shift += 7 {
981 if shift >= 64 {
982 return ErrIntOverflowGenerated
983 }
984 if iNdEx >= l {
985 return io.ErrUnexpectedEOF
986 }
987 b := dAtA[iNdEx]
988 iNdEx++
989 msglen |= int(b&0x7F) << shift
990 if b < 0x80 {
991 break
992 }
993 }
994 if msglen < 0 {
995 return ErrInvalidLengthGenerated
996 }
997 postIndex := iNdEx + msglen
998 if postIndex < 0 {
999 return ErrInvalidLengthGenerated
1000 }
1001 if postIndex > l {
1002 return io.ErrUnexpectedEOF
1003 }
1004 if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1005 return err
1006 }
1007 iNdEx = postIndex
1008 default:
1009 iNdEx = preIndex
1010 skippy, err := skipGenerated(dAtA[iNdEx:])
1011 if err != nil {
1012 return err
1013 }
1014 if (skippy < 0) || (iNdEx+skippy) < 0 {
1015 return ErrInvalidLengthGenerated
1016 }
1017 if (iNdEx + skippy) > l {
1018 return io.ErrUnexpectedEOF
1019 }
1020 iNdEx += skippy
1021 }
1022 }
1023
1024 if iNdEx > l {
1025 return io.ErrUnexpectedEOF
1026 }
1027 return nil
1028 }
1029 func (m *PodDisruptionBudgetList) Unmarshal(dAtA []byte) error {
1030 l := len(dAtA)
1031 iNdEx := 0
1032 for iNdEx < l {
1033 preIndex := iNdEx
1034 var wire uint64
1035 for shift := uint(0); ; shift += 7 {
1036 if shift >= 64 {
1037 return ErrIntOverflowGenerated
1038 }
1039 if iNdEx >= l {
1040 return io.ErrUnexpectedEOF
1041 }
1042 b := dAtA[iNdEx]
1043 iNdEx++
1044 wire |= uint64(b&0x7F) << shift
1045 if b < 0x80 {
1046 break
1047 }
1048 }
1049 fieldNum := int32(wire >> 3)
1050 wireType := int(wire & 0x7)
1051 if wireType == 4 {
1052 return fmt.Errorf("proto: PodDisruptionBudgetList: wiretype end group for non-group")
1053 }
1054 if fieldNum <= 0 {
1055 return fmt.Errorf("proto: PodDisruptionBudgetList: illegal tag %d (wire type %d)", fieldNum, wire)
1056 }
1057 switch fieldNum {
1058 case 1:
1059 if wireType != 2 {
1060 return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType)
1061 }
1062 var msglen int
1063 for shift := uint(0); ; shift += 7 {
1064 if shift >= 64 {
1065 return ErrIntOverflowGenerated
1066 }
1067 if iNdEx >= l {
1068 return io.ErrUnexpectedEOF
1069 }
1070 b := dAtA[iNdEx]
1071 iNdEx++
1072 msglen |= int(b&0x7F) << shift
1073 if b < 0x80 {
1074 break
1075 }
1076 }
1077 if msglen < 0 {
1078 return ErrInvalidLengthGenerated
1079 }
1080 postIndex := iNdEx + msglen
1081 if postIndex < 0 {
1082 return ErrInvalidLengthGenerated
1083 }
1084 if postIndex > l {
1085 return io.ErrUnexpectedEOF
1086 }
1087 if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1088 return err
1089 }
1090 iNdEx = postIndex
1091 case 2:
1092 if wireType != 2 {
1093 return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
1094 }
1095 var msglen int
1096 for shift := uint(0); ; shift += 7 {
1097 if shift >= 64 {
1098 return ErrIntOverflowGenerated
1099 }
1100 if iNdEx >= l {
1101 return io.ErrUnexpectedEOF
1102 }
1103 b := dAtA[iNdEx]
1104 iNdEx++
1105 msglen |= int(b&0x7F) << shift
1106 if b < 0x80 {
1107 break
1108 }
1109 }
1110 if msglen < 0 {
1111 return ErrInvalidLengthGenerated
1112 }
1113 postIndex := iNdEx + msglen
1114 if postIndex < 0 {
1115 return ErrInvalidLengthGenerated
1116 }
1117 if postIndex > l {
1118 return io.ErrUnexpectedEOF
1119 }
1120 m.Items = append(m.Items, PodDisruptionBudget{})
1121 if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1122 return err
1123 }
1124 iNdEx = postIndex
1125 default:
1126 iNdEx = preIndex
1127 skippy, err := skipGenerated(dAtA[iNdEx:])
1128 if err != nil {
1129 return err
1130 }
1131 if (skippy < 0) || (iNdEx+skippy) < 0 {
1132 return ErrInvalidLengthGenerated
1133 }
1134 if (iNdEx + skippy) > l {
1135 return io.ErrUnexpectedEOF
1136 }
1137 iNdEx += skippy
1138 }
1139 }
1140
1141 if iNdEx > l {
1142 return io.ErrUnexpectedEOF
1143 }
1144 return nil
1145 }
1146 func (m *PodDisruptionBudgetSpec) Unmarshal(dAtA []byte) error {
1147 l := len(dAtA)
1148 iNdEx := 0
1149 for iNdEx < l {
1150 preIndex := iNdEx
1151 var wire uint64
1152 for shift := uint(0); ; shift += 7 {
1153 if shift >= 64 {
1154 return ErrIntOverflowGenerated
1155 }
1156 if iNdEx >= l {
1157 return io.ErrUnexpectedEOF
1158 }
1159 b := dAtA[iNdEx]
1160 iNdEx++
1161 wire |= uint64(b&0x7F) << shift
1162 if b < 0x80 {
1163 break
1164 }
1165 }
1166 fieldNum := int32(wire >> 3)
1167 wireType := int(wire & 0x7)
1168 if wireType == 4 {
1169 return fmt.Errorf("proto: PodDisruptionBudgetSpec: wiretype end group for non-group")
1170 }
1171 if fieldNum <= 0 {
1172 return fmt.Errorf("proto: PodDisruptionBudgetSpec: illegal tag %d (wire type %d)", fieldNum, wire)
1173 }
1174 switch fieldNum {
1175 case 1:
1176 if wireType != 2 {
1177 return fmt.Errorf("proto: wrong wireType = %d for field MinAvailable", wireType)
1178 }
1179 var msglen int
1180 for shift := uint(0); ; shift += 7 {
1181 if shift >= 64 {
1182 return ErrIntOverflowGenerated
1183 }
1184 if iNdEx >= l {
1185 return io.ErrUnexpectedEOF
1186 }
1187 b := dAtA[iNdEx]
1188 iNdEx++
1189 msglen |= int(b&0x7F) << shift
1190 if b < 0x80 {
1191 break
1192 }
1193 }
1194 if msglen < 0 {
1195 return ErrInvalidLengthGenerated
1196 }
1197 postIndex := iNdEx + msglen
1198 if postIndex < 0 {
1199 return ErrInvalidLengthGenerated
1200 }
1201 if postIndex > l {
1202 return io.ErrUnexpectedEOF
1203 }
1204 if m.MinAvailable == nil {
1205 m.MinAvailable = &intstr.IntOrString{}
1206 }
1207 if err := m.MinAvailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1208 return err
1209 }
1210 iNdEx = postIndex
1211 case 2:
1212 if wireType != 2 {
1213 return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
1214 }
1215 var msglen int
1216 for shift := uint(0); ; shift += 7 {
1217 if shift >= 64 {
1218 return ErrIntOverflowGenerated
1219 }
1220 if iNdEx >= l {
1221 return io.ErrUnexpectedEOF
1222 }
1223 b := dAtA[iNdEx]
1224 iNdEx++
1225 msglen |= int(b&0x7F) << shift
1226 if b < 0x80 {
1227 break
1228 }
1229 }
1230 if msglen < 0 {
1231 return ErrInvalidLengthGenerated
1232 }
1233 postIndex := iNdEx + msglen
1234 if postIndex < 0 {
1235 return ErrInvalidLengthGenerated
1236 }
1237 if postIndex > l {
1238 return io.ErrUnexpectedEOF
1239 }
1240 if m.Selector == nil {
1241 m.Selector = &v1.LabelSelector{}
1242 }
1243 if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1244 return err
1245 }
1246 iNdEx = postIndex
1247 case 3:
1248 if wireType != 2 {
1249 return fmt.Errorf("proto: wrong wireType = %d for field MaxUnavailable", wireType)
1250 }
1251 var msglen int
1252 for shift := uint(0); ; shift += 7 {
1253 if shift >= 64 {
1254 return ErrIntOverflowGenerated
1255 }
1256 if iNdEx >= l {
1257 return io.ErrUnexpectedEOF
1258 }
1259 b := dAtA[iNdEx]
1260 iNdEx++
1261 msglen |= int(b&0x7F) << shift
1262 if b < 0x80 {
1263 break
1264 }
1265 }
1266 if msglen < 0 {
1267 return ErrInvalidLengthGenerated
1268 }
1269 postIndex := iNdEx + msglen
1270 if postIndex < 0 {
1271 return ErrInvalidLengthGenerated
1272 }
1273 if postIndex > l {
1274 return io.ErrUnexpectedEOF
1275 }
1276 if m.MaxUnavailable == nil {
1277 m.MaxUnavailable = &intstr.IntOrString{}
1278 }
1279 if err := m.MaxUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1280 return err
1281 }
1282 iNdEx = postIndex
1283 case 4:
1284 if wireType != 2 {
1285 return fmt.Errorf("proto: wrong wireType = %d for field UnhealthyPodEvictionPolicy", wireType)
1286 }
1287 var stringLen uint64
1288 for shift := uint(0); ; shift += 7 {
1289 if shift >= 64 {
1290 return ErrIntOverflowGenerated
1291 }
1292 if iNdEx >= l {
1293 return io.ErrUnexpectedEOF
1294 }
1295 b := dAtA[iNdEx]
1296 iNdEx++
1297 stringLen |= uint64(b&0x7F) << shift
1298 if b < 0x80 {
1299 break
1300 }
1301 }
1302 intStringLen := int(stringLen)
1303 if intStringLen < 0 {
1304 return ErrInvalidLengthGenerated
1305 }
1306 postIndex := iNdEx + intStringLen
1307 if postIndex < 0 {
1308 return ErrInvalidLengthGenerated
1309 }
1310 if postIndex > l {
1311 return io.ErrUnexpectedEOF
1312 }
1313 s := UnhealthyPodEvictionPolicyType(dAtA[iNdEx:postIndex])
1314 m.UnhealthyPodEvictionPolicy = &s
1315 iNdEx = postIndex
1316 default:
1317 iNdEx = preIndex
1318 skippy, err := skipGenerated(dAtA[iNdEx:])
1319 if err != nil {
1320 return err
1321 }
1322 if (skippy < 0) || (iNdEx+skippy) < 0 {
1323 return ErrInvalidLengthGenerated
1324 }
1325 if (iNdEx + skippy) > l {
1326 return io.ErrUnexpectedEOF
1327 }
1328 iNdEx += skippy
1329 }
1330 }
1331
1332 if iNdEx > l {
1333 return io.ErrUnexpectedEOF
1334 }
1335 return nil
1336 }
1337 func (m *PodDisruptionBudgetStatus) Unmarshal(dAtA []byte) error {
1338 l := len(dAtA)
1339 iNdEx := 0
1340 for iNdEx < l {
1341 preIndex := iNdEx
1342 var wire uint64
1343 for shift := uint(0); ; shift += 7 {
1344 if shift >= 64 {
1345 return ErrIntOverflowGenerated
1346 }
1347 if iNdEx >= l {
1348 return io.ErrUnexpectedEOF
1349 }
1350 b := dAtA[iNdEx]
1351 iNdEx++
1352 wire |= uint64(b&0x7F) << shift
1353 if b < 0x80 {
1354 break
1355 }
1356 }
1357 fieldNum := int32(wire >> 3)
1358 wireType := int(wire & 0x7)
1359 if wireType == 4 {
1360 return fmt.Errorf("proto: PodDisruptionBudgetStatus: wiretype end group for non-group")
1361 }
1362 if fieldNum <= 0 {
1363 return fmt.Errorf("proto: PodDisruptionBudgetStatus: illegal tag %d (wire type %d)", fieldNum, wire)
1364 }
1365 switch fieldNum {
1366 case 1:
1367 if wireType != 0 {
1368 return fmt.Errorf("proto: wrong wireType = %d for field ObservedGeneration", wireType)
1369 }
1370 m.ObservedGeneration = 0
1371 for shift := uint(0); ; shift += 7 {
1372 if shift >= 64 {
1373 return ErrIntOverflowGenerated
1374 }
1375 if iNdEx >= l {
1376 return io.ErrUnexpectedEOF
1377 }
1378 b := dAtA[iNdEx]
1379 iNdEx++
1380 m.ObservedGeneration |= int64(b&0x7F) << shift
1381 if b < 0x80 {
1382 break
1383 }
1384 }
1385 case 2:
1386 if wireType != 2 {
1387 return fmt.Errorf("proto: wrong wireType = %d for field DisruptedPods", wireType)
1388 }
1389 var msglen int
1390 for shift := uint(0); ; shift += 7 {
1391 if shift >= 64 {
1392 return ErrIntOverflowGenerated
1393 }
1394 if iNdEx >= l {
1395 return io.ErrUnexpectedEOF
1396 }
1397 b := dAtA[iNdEx]
1398 iNdEx++
1399 msglen |= int(b&0x7F) << shift
1400 if b < 0x80 {
1401 break
1402 }
1403 }
1404 if msglen < 0 {
1405 return ErrInvalidLengthGenerated
1406 }
1407 postIndex := iNdEx + msglen
1408 if postIndex < 0 {
1409 return ErrInvalidLengthGenerated
1410 }
1411 if postIndex > l {
1412 return io.ErrUnexpectedEOF
1413 }
1414 if m.DisruptedPods == nil {
1415 m.DisruptedPods = make(map[string]v1.Time)
1416 }
1417 var mapkey string
1418 mapvalue := &v1.Time{}
1419 for iNdEx < postIndex {
1420 entryPreIndex := iNdEx
1421 var wire uint64
1422 for shift := uint(0); ; shift += 7 {
1423 if shift >= 64 {
1424 return ErrIntOverflowGenerated
1425 }
1426 if iNdEx >= l {
1427 return io.ErrUnexpectedEOF
1428 }
1429 b := dAtA[iNdEx]
1430 iNdEx++
1431 wire |= uint64(b&0x7F) << shift
1432 if b < 0x80 {
1433 break
1434 }
1435 }
1436 fieldNum := int32(wire >> 3)
1437 if fieldNum == 1 {
1438 var stringLenmapkey uint64
1439 for shift := uint(0); ; shift += 7 {
1440 if shift >= 64 {
1441 return ErrIntOverflowGenerated
1442 }
1443 if iNdEx >= l {
1444 return io.ErrUnexpectedEOF
1445 }
1446 b := dAtA[iNdEx]
1447 iNdEx++
1448 stringLenmapkey |= uint64(b&0x7F) << shift
1449 if b < 0x80 {
1450 break
1451 }
1452 }
1453 intStringLenmapkey := int(stringLenmapkey)
1454 if intStringLenmapkey < 0 {
1455 return ErrInvalidLengthGenerated
1456 }
1457 postStringIndexmapkey := iNdEx + intStringLenmapkey
1458 if postStringIndexmapkey < 0 {
1459 return ErrInvalidLengthGenerated
1460 }
1461 if postStringIndexmapkey > l {
1462 return io.ErrUnexpectedEOF
1463 }
1464 mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
1465 iNdEx = postStringIndexmapkey
1466 } else if fieldNum == 2 {
1467 var mapmsglen int
1468 for shift := uint(0); ; shift += 7 {
1469 if shift >= 64 {
1470 return ErrIntOverflowGenerated
1471 }
1472 if iNdEx >= l {
1473 return io.ErrUnexpectedEOF
1474 }
1475 b := dAtA[iNdEx]
1476 iNdEx++
1477 mapmsglen |= int(b&0x7F) << shift
1478 if b < 0x80 {
1479 break
1480 }
1481 }
1482 if mapmsglen < 0 {
1483 return ErrInvalidLengthGenerated
1484 }
1485 postmsgIndex := iNdEx + mapmsglen
1486 if postmsgIndex < 0 {
1487 return ErrInvalidLengthGenerated
1488 }
1489 if postmsgIndex > l {
1490 return io.ErrUnexpectedEOF
1491 }
1492 mapvalue = &v1.Time{}
1493 if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
1494 return err
1495 }
1496 iNdEx = postmsgIndex
1497 } else {
1498 iNdEx = entryPreIndex
1499 skippy, err := skipGenerated(dAtA[iNdEx:])
1500 if err != nil {
1501 return err
1502 }
1503 if (skippy < 0) || (iNdEx+skippy) < 0 {
1504 return ErrInvalidLengthGenerated
1505 }
1506 if (iNdEx + skippy) > postIndex {
1507 return io.ErrUnexpectedEOF
1508 }
1509 iNdEx += skippy
1510 }
1511 }
1512 m.DisruptedPods[mapkey] = *mapvalue
1513 iNdEx = postIndex
1514 case 3:
1515 if wireType != 0 {
1516 return fmt.Errorf("proto: wrong wireType = %d for field DisruptionsAllowed", wireType)
1517 }
1518 m.DisruptionsAllowed = 0
1519 for shift := uint(0); ; shift += 7 {
1520 if shift >= 64 {
1521 return ErrIntOverflowGenerated
1522 }
1523 if iNdEx >= l {
1524 return io.ErrUnexpectedEOF
1525 }
1526 b := dAtA[iNdEx]
1527 iNdEx++
1528 m.DisruptionsAllowed |= int32(b&0x7F) << shift
1529 if b < 0x80 {
1530 break
1531 }
1532 }
1533 case 4:
1534 if wireType != 0 {
1535 return fmt.Errorf("proto: wrong wireType = %d for field CurrentHealthy", wireType)
1536 }
1537 m.CurrentHealthy = 0
1538 for shift := uint(0); ; shift += 7 {
1539 if shift >= 64 {
1540 return ErrIntOverflowGenerated
1541 }
1542 if iNdEx >= l {
1543 return io.ErrUnexpectedEOF
1544 }
1545 b := dAtA[iNdEx]
1546 iNdEx++
1547 m.CurrentHealthy |= int32(b&0x7F) << shift
1548 if b < 0x80 {
1549 break
1550 }
1551 }
1552 case 5:
1553 if wireType != 0 {
1554 return fmt.Errorf("proto: wrong wireType = %d for field DesiredHealthy", wireType)
1555 }
1556 m.DesiredHealthy = 0
1557 for shift := uint(0); ; shift += 7 {
1558 if shift >= 64 {
1559 return ErrIntOverflowGenerated
1560 }
1561 if iNdEx >= l {
1562 return io.ErrUnexpectedEOF
1563 }
1564 b := dAtA[iNdEx]
1565 iNdEx++
1566 m.DesiredHealthy |= int32(b&0x7F) << shift
1567 if b < 0x80 {
1568 break
1569 }
1570 }
1571 case 6:
1572 if wireType != 0 {
1573 return fmt.Errorf("proto: wrong wireType = %d for field ExpectedPods", wireType)
1574 }
1575 m.ExpectedPods = 0
1576 for shift := uint(0); ; shift += 7 {
1577 if shift >= 64 {
1578 return ErrIntOverflowGenerated
1579 }
1580 if iNdEx >= l {
1581 return io.ErrUnexpectedEOF
1582 }
1583 b := dAtA[iNdEx]
1584 iNdEx++
1585 m.ExpectedPods |= int32(b&0x7F) << shift
1586 if b < 0x80 {
1587 break
1588 }
1589 }
1590 case 7:
1591 if wireType != 2 {
1592 return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType)
1593 }
1594 var msglen int
1595 for shift := uint(0); ; shift += 7 {
1596 if shift >= 64 {
1597 return ErrIntOverflowGenerated
1598 }
1599 if iNdEx >= l {
1600 return io.ErrUnexpectedEOF
1601 }
1602 b := dAtA[iNdEx]
1603 iNdEx++
1604 msglen |= int(b&0x7F) << shift
1605 if b < 0x80 {
1606 break
1607 }
1608 }
1609 if msglen < 0 {
1610 return ErrInvalidLengthGenerated
1611 }
1612 postIndex := iNdEx + msglen
1613 if postIndex < 0 {
1614 return ErrInvalidLengthGenerated
1615 }
1616 if postIndex > l {
1617 return io.ErrUnexpectedEOF
1618 }
1619 m.Conditions = append(m.Conditions, v1.Condition{})
1620 if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
1621 return err
1622 }
1623 iNdEx = postIndex
1624 default:
1625 iNdEx = preIndex
1626 skippy, err := skipGenerated(dAtA[iNdEx:])
1627 if err != nil {
1628 return err
1629 }
1630 if (skippy < 0) || (iNdEx+skippy) < 0 {
1631 return ErrInvalidLengthGenerated
1632 }
1633 if (iNdEx + skippy) > l {
1634 return io.ErrUnexpectedEOF
1635 }
1636 iNdEx += skippy
1637 }
1638 }
1639
1640 if iNdEx > l {
1641 return io.ErrUnexpectedEOF
1642 }
1643 return nil
1644 }
1645 func skipGenerated(dAtA []byte) (n int, err error) {
1646 l := len(dAtA)
1647 iNdEx := 0
1648 depth := 0
1649 for iNdEx < l {
1650 var wire uint64
1651 for shift := uint(0); ; shift += 7 {
1652 if shift >= 64 {
1653 return 0, ErrIntOverflowGenerated
1654 }
1655 if iNdEx >= l {
1656 return 0, io.ErrUnexpectedEOF
1657 }
1658 b := dAtA[iNdEx]
1659 iNdEx++
1660 wire |= (uint64(b) & 0x7F) << shift
1661 if b < 0x80 {
1662 break
1663 }
1664 }
1665 wireType := int(wire & 0x7)
1666 switch wireType {
1667 case 0:
1668 for shift := uint(0); ; shift += 7 {
1669 if shift >= 64 {
1670 return 0, ErrIntOverflowGenerated
1671 }
1672 if iNdEx >= l {
1673 return 0, io.ErrUnexpectedEOF
1674 }
1675 iNdEx++
1676 if dAtA[iNdEx-1] < 0x80 {
1677 break
1678 }
1679 }
1680 case 1:
1681 iNdEx += 8
1682 case 2:
1683 var length int
1684 for shift := uint(0); ; shift += 7 {
1685 if shift >= 64 {
1686 return 0, ErrIntOverflowGenerated
1687 }
1688 if iNdEx >= l {
1689 return 0, io.ErrUnexpectedEOF
1690 }
1691 b := dAtA[iNdEx]
1692 iNdEx++
1693 length |= (int(b) & 0x7F) << shift
1694 if b < 0x80 {
1695 break
1696 }
1697 }
1698 if length < 0 {
1699 return 0, ErrInvalidLengthGenerated
1700 }
1701 iNdEx += length
1702 case 3:
1703 depth++
1704 case 4:
1705 if depth == 0 {
1706 return 0, ErrUnexpectedEndOfGroupGenerated
1707 }
1708 depth--
1709 case 5:
1710 iNdEx += 4
1711 default:
1712 return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
1713 }
1714 if iNdEx < 0 {
1715 return 0, ErrInvalidLengthGenerated
1716 }
1717 if depth == 0 {
1718 return iNdEx, nil
1719 }
1720 }
1721 return 0, io.ErrUnexpectedEOF
1722 }
1723
1724 var (
1725 ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
1726 ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow")
1727 ErrUnexpectedEndOfGroupGenerated = fmt.Errorf("proto: unexpected end of group")
1728 )
1729
View as plain text