001 // Generated by the protocol buffer compiler. DO NOT EDIT!
002 // source: RpcHeader.proto
003
004 package org.apache.hadoop.ipc.protobuf;
005
006 public final class RpcHeaderProtos {
007 private RpcHeaderProtos() {}
008 public static void registerAllExtensions(
009 com.google.protobuf.ExtensionRegistry registry) {
010 }
011 /**
012 * Protobuf enum {@code hadoop.common.RpcKindProto}
013 *
014 * <pre>
015 **
016 * RpcKind determine the rpcEngine and the serialization of the rpc request
017 * </pre>
018 */
019 public enum RpcKindProto
020 implements com.google.protobuf.ProtocolMessageEnum {
021 /**
022 * <code>RPC_BUILTIN = 0;</code>
023 *
024 * <pre>
025 * Used for built in calls by tests
026 * </pre>
027 */
028 RPC_BUILTIN(0, 0),
029 /**
030 * <code>RPC_WRITABLE = 1;</code>
031 *
032 * <pre>
033 * Use WritableRpcEngine
034 * </pre>
035 */
036 RPC_WRITABLE(1, 1),
037 /**
038 * <code>RPC_PROTOCOL_BUFFER = 2;</code>
039 *
040 * <pre>
041 * Use ProtobufRpcEngine
042 * </pre>
043 */
044 RPC_PROTOCOL_BUFFER(2, 2),
045 ;
046
047 /**
048 * <code>RPC_BUILTIN = 0;</code>
049 *
050 * <pre>
051 * Used for built in calls by tests
052 * </pre>
053 */
054 public static final int RPC_BUILTIN_VALUE = 0;
055 /**
056 * <code>RPC_WRITABLE = 1;</code>
057 *
058 * <pre>
059 * Use WritableRpcEngine
060 * </pre>
061 */
062 public static final int RPC_WRITABLE_VALUE = 1;
063 /**
064 * <code>RPC_PROTOCOL_BUFFER = 2;</code>
065 *
066 * <pre>
067 * Use ProtobufRpcEngine
068 * </pre>
069 */
070 public static final int RPC_PROTOCOL_BUFFER_VALUE = 2;
071
072
073 public final int getNumber() { return value; }
074
075 public static RpcKindProto valueOf(int value) {
076 switch (value) {
077 case 0: return RPC_BUILTIN;
078 case 1: return RPC_WRITABLE;
079 case 2: return RPC_PROTOCOL_BUFFER;
080 default: return null;
081 }
082 }
083
084 public static com.google.protobuf.Internal.EnumLiteMap<RpcKindProto>
085 internalGetValueMap() {
086 return internalValueMap;
087 }
088 private static com.google.protobuf.Internal.EnumLiteMap<RpcKindProto>
089 internalValueMap =
090 new com.google.protobuf.Internal.EnumLiteMap<RpcKindProto>() {
091 public RpcKindProto findValueByNumber(int number) {
092 return RpcKindProto.valueOf(number);
093 }
094 };
095
096 public final com.google.protobuf.Descriptors.EnumValueDescriptor
097 getValueDescriptor() {
098 return getDescriptor().getValues().get(index);
099 }
100 public final com.google.protobuf.Descriptors.EnumDescriptor
101 getDescriptorForType() {
102 return getDescriptor();
103 }
104 public static final com.google.protobuf.Descriptors.EnumDescriptor
105 getDescriptor() {
106 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.getDescriptor().getEnumTypes().get(0);
107 }
108
109 private static final RpcKindProto[] VALUES = values();
110
111 public static RpcKindProto valueOf(
112 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
113 if (desc.getType() != getDescriptor()) {
114 throw new java.lang.IllegalArgumentException(
115 "EnumValueDescriptor is not for this type.");
116 }
117 return VALUES[desc.getIndex()];
118 }
119
120 private final int index;
121 private final int value;
122
123 private RpcKindProto(int index, int value) {
124 this.index = index;
125 this.value = value;
126 }
127
128 // @@protoc_insertion_point(enum_scope:hadoop.common.RpcKindProto)
129 }
130
131 public interface RpcRequestHeaderProtoOrBuilder
132 extends com.google.protobuf.MessageOrBuilder {
133
134 // optional .hadoop.common.RpcKindProto rpcKind = 1;
135 /**
136 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
137 */
138 boolean hasRpcKind();
139 /**
140 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
141 */
142 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto getRpcKind();
143
144 // optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;
145 /**
146 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
147 */
148 boolean hasRpcOp();
149 /**
150 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
151 */
152 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto getRpcOp();
153
154 // required sint32 callId = 3;
155 /**
156 * <code>required sint32 callId = 3;</code>
157 *
158 * <pre>
159 * a sequence number that is sent back in response
160 * </pre>
161 */
162 boolean hasCallId();
163 /**
164 * <code>required sint32 callId = 3;</code>
165 *
166 * <pre>
167 * a sequence number that is sent back in response
168 * </pre>
169 */
170 int getCallId();
171
172 // required bytes clientId = 4;
173 /**
174 * <code>required bytes clientId = 4;</code>
175 *
176 * <pre>
177 * Globally unique client ID
178 * </pre>
179 */
180 boolean hasClientId();
181 /**
182 * <code>required bytes clientId = 4;</code>
183 *
184 * <pre>
185 * Globally unique client ID
186 * </pre>
187 */
188 com.google.protobuf.ByteString getClientId();
189
190 // optional sint32 retryCount = 5 [default = -1];
191 /**
192 * <code>optional sint32 retryCount = 5 [default = -1];</code>
193 *
194 * <pre>
195 * clientId + callId uniquely identifies a request
196 * retry count, 1 means this is the first retry
197 * </pre>
198 */
199 boolean hasRetryCount();
200 /**
201 * <code>optional sint32 retryCount = 5 [default = -1];</code>
202 *
203 * <pre>
204 * clientId + callId uniquely identifies a request
205 * retry count, 1 means this is the first retry
206 * </pre>
207 */
208 int getRetryCount();
209 }
210 /**
211 * Protobuf type {@code hadoop.common.RpcRequestHeaderProto}
212 *
213 * <pre>
214 * the header for the RpcRequest
215 * </pre>
216 */
217 public static final class RpcRequestHeaderProto extends
218 com.google.protobuf.GeneratedMessage
219 implements RpcRequestHeaderProtoOrBuilder {
220 // Use RpcRequestHeaderProto.newBuilder() to construct.
221 private RpcRequestHeaderProto(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
222 super(builder);
223 this.unknownFields = builder.getUnknownFields();
224 }
225 private RpcRequestHeaderProto(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
226
227 private static final RpcRequestHeaderProto defaultInstance;
228 public static RpcRequestHeaderProto getDefaultInstance() {
229 return defaultInstance;
230 }
231
232 public RpcRequestHeaderProto getDefaultInstanceForType() {
233 return defaultInstance;
234 }
235
236 private final com.google.protobuf.UnknownFieldSet unknownFields;
237 @java.lang.Override
238 public final com.google.protobuf.UnknownFieldSet
239 getUnknownFields() {
240 return this.unknownFields;
241 }
242 private RpcRequestHeaderProto(
243 com.google.protobuf.CodedInputStream input,
244 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
245 throws com.google.protobuf.InvalidProtocolBufferException {
246 initFields();
247 int mutable_bitField0_ = 0;
248 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
249 com.google.protobuf.UnknownFieldSet.newBuilder();
250 try {
251 boolean done = false;
252 while (!done) {
253 int tag = input.readTag();
254 switch (tag) {
255 case 0:
256 done = true;
257 break;
258 default: {
259 if (!parseUnknownField(input, unknownFields,
260 extensionRegistry, tag)) {
261 done = true;
262 }
263 break;
264 }
265 case 8: {
266 int rawValue = input.readEnum();
267 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto value = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto.valueOf(rawValue);
268 if (value == null) {
269 unknownFields.mergeVarintField(1, rawValue);
270 } else {
271 bitField0_ |= 0x00000001;
272 rpcKind_ = value;
273 }
274 break;
275 }
276 case 16: {
277 int rawValue = input.readEnum();
278 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto value = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto.valueOf(rawValue);
279 if (value == null) {
280 unknownFields.mergeVarintField(2, rawValue);
281 } else {
282 bitField0_ |= 0x00000002;
283 rpcOp_ = value;
284 }
285 break;
286 }
287 case 24: {
288 bitField0_ |= 0x00000004;
289 callId_ = input.readSInt32();
290 break;
291 }
292 case 34: {
293 bitField0_ |= 0x00000008;
294 clientId_ = input.readBytes();
295 break;
296 }
297 case 40: {
298 bitField0_ |= 0x00000010;
299 retryCount_ = input.readSInt32();
300 break;
301 }
302 }
303 }
304 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
305 throw e.setUnfinishedMessage(this);
306 } catch (java.io.IOException e) {
307 throw new com.google.protobuf.InvalidProtocolBufferException(
308 e.getMessage()).setUnfinishedMessage(this);
309 } finally {
310 this.unknownFields = unknownFields.build();
311 makeExtensionsImmutable();
312 }
313 }
314 public static final com.google.protobuf.Descriptors.Descriptor
315 getDescriptor() {
316 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcRequestHeaderProto_descriptor;
317 }
318
319 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
320 internalGetFieldAccessorTable() {
321 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcRequestHeaderProto_fieldAccessorTable
322 .ensureFieldAccessorsInitialized(
323 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.Builder.class);
324 }
325
326 public static com.google.protobuf.Parser<RpcRequestHeaderProto> PARSER =
327 new com.google.protobuf.AbstractParser<RpcRequestHeaderProto>() {
328 public RpcRequestHeaderProto parsePartialFrom(
329 com.google.protobuf.CodedInputStream input,
330 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
331 throws com.google.protobuf.InvalidProtocolBufferException {
332 return new RpcRequestHeaderProto(input, extensionRegistry);
333 }
334 };
335
336 @java.lang.Override
337 public com.google.protobuf.Parser<RpcRequestHeaderProto> getParserForType() {
338 return PARSER;
339 }
340
341 /**
342 * Protobuf enum {@code hadoop.common.RpcRequestHeaderProto.OperationProto}
343 */
344 public enum OperationProto
345 implements com.google.protobuf.ProtocolMessageEnum {
346 /**
347 * <code>RPC_FINAL_PACKET = 0;</code>
348 *
349 * <pre>
350 * The final RPC Packet
351 * </pre>
352 */
353 RPC_FINAL_PACKET(0, 0),
354 /**
355 * <code>RPC_CONTINUATION_PACKET = 1;</code>
356 *
357 * <pre>
358 * not implemented yet
359 * </pre>
360 */
361 RPC_CONTINUATION_PACKET(1, 1),
362 /**
363 * <code>RPC_CLOSE_CONNECTION = 2;</code>
364 *
365 * <pre>
366 * close the rpc connection
367 * </pre>
368 */
369 RPC_CLOSE_CONNECTION(2, 2),
370 ;
371
372 /**
373 * <code>RPC_FINAL_PACKET = 0;</code>
374 *
375 * <pre>
376 * The final RPC Packet
377 * </pre>
378 */
379 public static final int RPC_FINAL_PACKET_VALUE = 0;
380 /**
381 * <code>RPC_CONTINUATION_PACKET = 1;</code>
382 *
383 * <pre>
384 * not implemented yet
385 * </pre>
386 */
387 public static final int RPC_CONTINUATION_PACKET_VALUE = 1;
388 /**
389 * <code>RPC_CLOSE_CONNECTION = 2;</code>
390 *
391 * <pre>
392 * close the rpc connection
393 * </pre>
394 */
395 public static final int RPC_CLOSE_CONNECTION_VALUE = 2;
396
397
398 public final int getNumber() { return value; }
399
400 public static OperationProto valueOf(int value) {
401 switch (value) {
402 case 0: return RPC_FINAL_PACKET;
403 case 1: return RPC_CONTINUATION_PACKET;
404 case 2: return RPC_CLOSE_CONNECTION;
405 default: return null;
406 }
407 }
408
409 public static com.google.protobuf.Internal.EnumLiteMap<OperationProto>
410 internalGetValueMap() {
411 return internalValueMap;
412 }
413 private static com.google.protobuf.Internal.EnumLiteMap<OperationProto>
414 internalValueMap =
415 new com.google.protobuf.Internal.EnumLiteMap<OperationProto>() {
416 public OperationProto findValueByNumber(int number) {
417 return OperationProto.valueOf(number);
418 }
419 };
420
421 public final com.google.protobuf.Descriptors.EnumValueDescriptor
422 getValueDescriptor() {
423 return getDescriptor().getValues().get(index);
424 }
425 public final com.google.protobuf.Descriptors.EnumDescriptor
426 getDescriptorForType() {
427 return getDescriptor();
428 }
429 public static final com.google.protobuf.Descriptors.EnumDescriptor
430 getDescriptor() {
431 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.getDescriptor().getEnumTypes().get(0);
432 }
433
434 private static final OperationProto[] VALUES = values();
435
436 public static OperationProto valueOf(
437 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
438 if (desc.getType() != getDescriptor()) {
439 throw new java.lang.IllegalArgumentException(
440 "EnumValueDescriptor is not for this type.");
441 }
442 return VALUES[desc.getIndex()];
443 }
444
445 private final int index;
446 private final int value;
447
448 private OperationProto(int index, int value) {
449 this.index = index;
450 this.value = value;
451 }
452
453 // @@protoc_insertion_point(enum_scope:hadoop.common.RpcRequestHeaderProto.OperationProto)
454 }
455
456 private int bitField0_;
457 // optional .hadoop.common.RpcKindProto rpcKind = 1;
458 public static final int RPCKIND_FIELD_NUMBER = 1;
459 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto rpcKind_;
460 /**
461 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
462 */
463 public boolean hasRpcKind() {
464 return ((bitField0_ & 0x00000001) == 0x00000001);
465 }
466 /**
467 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
468 */
469 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto getRpcKind() {
470 return rpcKind_;
471 }
472
473 // optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;
474 public static final int RPCOP_FIELD_NUMBER = 2;
475 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto rpcOp_;
476 /**
477 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
478 */
479 public boolean hasRpcOp() {
480 return ((bitField0_ & 0x00000002) == 0x00000002);
481 }
482 /**
483 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
484 */
485 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto getRpcOp() {
486 return rpcOp_;
487 }
488
489 // required sint32 callId = 3;
490 public static final int CALLID_FIELD_NUMBER = 3;
491 private int callId_;
492 /**
493 * <code>required sint32 callId = 3;</code>
494 *
495 * <pre>
496 * a sequence number that is sent back in response
497 * </pre>
498 */
499 public boolean hasCallId() {
500 return ((bitField0_ & 0x00000004) == 0x00000004);
501 }
502 /**
503 * <code>required sint32 callId = 3;</code>
504 *
505 * <pre>
506 * a sequence number that is sent back in response
507 * </pre>
508 */
509 public int getCallId() {
510 return callId_;
511 }
512
513 // required bytes clientId = 4;
514 public static final int CLIENTID_FIELD_NUMBER = 4;
515 private com.google.protobuf.ByteString clientId_;
516 /**
517 * <code>required bytes clientId = 4;</code>
518 *
519 * <pre>
520 * Globally unique client ID
521 * </pre>
522 */
523 public boolean hasClientId() {
524 return ((bitField0_ & 0x00000008) == 0x00000008);
525 }
526 /**
527 * <code>required bytes clientId = 4;</code>
528 *
529 * <pre>
530 * Globally unique client ID
531 * </pre>
532 */
533 public com.google.protobuf.ByteString getClientId() {
534 return clientId_;
535 }
536
537 // optional sint32 retryCount = 5 [default = -1];
538 public static final int RETRYCOUNT_FIELD_NUMBER = 5;
539 private int retryCount_;
540 /**
541 * <code>optional sint32 retryCount = 5 [default = -1];</code>
542 *
543 * <pre>
544 * clientId + callId uniquely identifies a request
545 * retry count, 1 means this is the first retry
546 * </pre>
547 */
548 public boolean hasRetryCount() {
549 return ((bitField0_ & 0x00000010) == 0x00000010);
550 }
551 /**
552 * <code>optional sint32 retryCount = 5 [default = -1];</code>
553 *
554 * <pre>
555 * clientId + callId uniquely identifies a request
556 * retry count, 1 means this is the first retry
557 * </pre>
558 */
559 public int getRetryCount() {
560 return retryCount_;
561 }
562
563 private void initFields() {
564 rpcKind_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto.RPC_BUILTIN;
565 rpcOp_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto.RPC_FINAL_PACKET;
566 callId_ = 0;
567 clientId_ = com.google.protobuf.ByteString.EMPTY;
568 retryCount_ = -1;
569 }
570 private byte memoizedIsInitialized = -1;
571 public final boolean isInitialized() {
572 byte isInitialized = memoizedIsInitialized;
573 if (isInitialized != -1) return isInitialized == 1;
574
575 if (!hasCallId()) {
576 memoizedIsInitialized = 0;
577 return false;
578 }
579 if (!hasClientId()) {
580 memoizedIsInitialized = 0;
581 return false;
582 }
583 memoizedIsInitialized = 1;
584 return true;
585 }
586
587 public void writeTo(com.google.protobuf.CodedOutputStream output)
588 throws java.io.IOException {
589 getSerializedSize();
590 if (((bitField0_ & 0x00000001) == 0x00000001)) {
591 output.writeEnum(1, rpcKind_.getNumber());
592 }
593 if (((bitField0_ & 0x00000002) == 0x00000002)) {
594 output.writeEnum(2, rpcOp_.getNumber());
595 }
596 if (((bitField0_ & 0x00000004) == 0x00000004)) {
597 output.writeSInt32(3, callId_);
598 }
599 if (((bitField0_ & 0x00000008) == 0x00000008)) {
600 output.writeBytes(4, clientId_);
601 }
602 if (((bitField0_ & 0x00000010) == 0x00000010)) {
603 output.writeSInt32(5, retryCount_);
604 }
605 getUnknownFields().writeTo(output);
606 }
607
608 private int memoizedSerializedSize = -1;
609 public int getSerializedSize() {
610 int size = memoizedSerializedSize;
611 if (size != -1) return size;
612
613 size = 0;
614 if (((bitField0_ & 0x00000001) == 0x00000001)) {
615 size += com.google.protobuf.CodedOutputStream
616 .computeEnumSize(1, rpcKind_.getNumber());
617 }
618 if (((bitField0_ & 0x00000002) == 0x00000002)) {
619 size += com.google.protobuf.CodedOutputStream
620 .computeEnumSize(2, rpcOp_.getNumber());
621 }
622 if (((bitField0_ & 0x00000004) == 0x00000004)) {
623 size += com.google.protobuf.CodedOutputStream
624 .computeSInt32Size(3, callId_);
625 }
626 if (((bitField0_ & 0x00000008) == 0x00000008)) {
627 size += com.google.protobuf.CodedOutputStream
628 .computeBytesSize(4, clientId_);
629 }
630 if (((bitField0_ & 0x00000010) == 0x00000010)) {
631 size += com.google.protobuf.CodedOutputStream
632 .computeSInt32Size(5, retryCount_);
633 }
634 size += getUnknownFields().getSerializedSize();
635 memoizedSerializedSize = size;
636 return size;
637 }
638
639 private static final long serialVersionUID = 0L;
640 @java.lang.Override
641 protected java.lang.Object writeReplace()
642 throws java.io.ObjectStreamException {
643 return super.writeReplace();
644 }
645
646 @java.lang.Override
647 public boolean equals(final java.lang.Object obj) {
648 if (obj == this) {
649 return true;
650 }
651 if (!(obj instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto)) {
652 return super.equals(obj);
653 }
654 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto other = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto) obj;
655
656 boolean result = true;
657 result = result && (hasRpcKind() == other.hasRpcKind());
658 if (hasRpcKind()) {
659 result = result &&
660 (getRpcKind() == other.getRpcKind());
661 }
662 result = result && (hasRpcOp() == other.hasRpcOp());
663 if (hasRpcOp()) {
664 result = result &&
665 (getRpcOp() == other.getRpcOp());
666 }
667 result = result && (hasCallId() == other.hasCallId());
668 if (hasCallId()) {
669 result = result && (getCallId()
670 == other.getCallId());
671 }
672 result = result && (hasClientId() == other.hasClientId());
673 if (hasClientId()) {
674 result = result && getClientId()
675 .equals(other.getClientId());
676 }
677 result = result && (hasRetryCount() == other.hasRetryCount());
678 if (hasRetryCount()) {
679 result = result && (getRetryCount()
680 == other.getRetryCount());
681 }
682 result = result &&
683 getUnknownFields().equals(other.getUnknownFields());
684 return result;
685 }
686
687 private int memoizedHashCode = 0;
688 @java.lang.Override
689 public int hashCode() {
690 if (memoizedHashCode != 0) {
691 return memoizedHashCode;
692 }
693 int hash = 41;
694 hash = (19 * hash) + getDescriptorForType().hashCode();
695 if (hasRpcKind()) {
696 hash = (37 * hash) + RPCKIND_FIELD_NUMBER;
697 hash = (53 * hash) + hashEnum(getRpcKind());
698 }
699 if (hasRpcOp()) {
700 hash = (37 * hash) + RPCOP_FIELD_NUMBER;
701 hash = (53 * hash) + hashEnum(getRpcOp());
702 }
703 if (hasCallId()) {
704 hash = (37 * hash) + CALLID_FIELD_NUMBER;
705 hash = (53 * hash) + getCallId();
706 }
707 if (hasClientId()) {
708 hash = (37 * hash) + CLIENTID_FIELD_NUMBER;
709 hash = (53 * hash) + getClientId().hashCode();
710 }
711 if (hasRetryCount()) {
712 hash = (37 * hash) + RETRYCOUNT_FIELD_NUMBER;
713 hash = (53 * hash) + getRetryCount();
714 }
715 hash = (29 * hash) + getUnknownFields().hashCode();
716 memoizedHashCode = hash;
717 return hash;
718 }
719
720 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(
721 com.google.protobuf.ByteString data)
722 throws com.google.protobuf.InvalidProtocolBufferException {
723 return PARSER.parseFrom(data);
724 }
725 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(
726 com.google.protobuf.ByteString data,
727 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
728 throws com.google.protobuf.InvalidProtocolBufferException {
729 return PARSER.parseFrom(data, extensionRegistry);
730 }
731 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(byte[] data)
732 throws com.google.protobuf.InvalidProtocolBufferException {
733 return PARSER.parseFrom(data);
734 }
735 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(
736 byte[] data,
737 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
738 throws com.google.protobuf.InvalidProtocolBufferException {
739 return PARSER.parseFrom(data, extensionRegistry);
740 }
741 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(java.io.InputStream input)
742 throws java.io.IOException {
743 return PARSER.parseFrom(input);
744 }
745 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(
746 java.io.InputStream input,
747 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
748 throws java.io.IOException {
749 return PARSER.parseFrom(input, extensionRegistry);
750 }
751 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseDelimitedFrom(java.io.InputStream input)
752 throws java.io.IOException {
753 return PARSER.parseDelimitedFrom(input);
754 }
755 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseDelimitedFrom(
756 java.io.InputStream input,
757 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
758 throws java.io.IOException {
759 return PARSER.parseDelimitedFrom(input, extensionRegistry);
760 }
761 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(
762 com.google.protobuf.CodedInputStream input)
763 throws java.io.IOException {
764 return PARSER.parseFrom(input);
765 }
766 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parseFrom(
767 com.google.protobuf.CodedInputStream input,
768 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
769 throws java.io.IOException {
770 return PARSER.parseFrom(input, extensionRegistry);
771 }
772
773 public static Builder newBuilder() { return Builder.create(); }
774 public Builder newBuilderForType() { return newBuilder(); }
775 public static Builder newBuilder(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto prototype) {
776 return newBuilder().mergeFrom(prototype);
777 }
778 public Builder toBuilder() { return newBuilder(this); }
779
780 @java.lang.Override
781 protected Builder newBuilderForType(
782 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
783 Builder builder = new Builder(parent);
784 return builder;
785 }
786 /**
787 * Protobuf type {@code hadoop.common.RpcRequestHeaderProto}
788 *
789 * <pre>
790 * the header for the RpcRequest
791 * </pre>
792 */
793 public static final class Builder extends
794 com.google.protobuf.GeneratedMessage.Builder<Builder>
795 implements org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProtoOrBuilder {
796 public static final com.google.protobuf.Descriptors.Descriptor
797 getDescriptor() {
798 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcRequestHeaderProto_descriptor;
799 }
800
801 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
802 internalGetFieldAccessorTable() {
803 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcRequestHeaderProto_fieldAccessorTable
804 .ensureFieldAccessorsInitialized(
805 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.Builder.class);
806 }
807
808 // Construct using org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.newBuilder()
809 private Builder() {
810 maybeForceBuilderInitialization();
811 }
812
813 private Builder(
814 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
815 super(parent);
816 maybeForceBuilderInitialization();
817 }
818 private void maybeForceBuilderInitialization() {
819 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
820 }
821 }
822 private static Builder create() {
823 return new Builder();
824 }
825
826 public Builder clear() {
827 super.clear();
828 rpcKind_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto.RPC_BUILTIN;
829 bitField0_ = (bitField0_ & ~0x00000001);
830 rpcOp_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto.RPC_FINAL_PACKET;
831 bitField0_ = (bitField0_ & ~0x00000002);
832 callId_ = 0;
833 bitField0_ = (bitField0_ & ~0x00000004);
834 clientId_ = com.google.protobuf.ByteString.EMPTY;
835 bitField0_ = (bitField0_ & ~0x00000008);
836 retryCount_ = -1;
837 bitField0_ = (bitField0_ & ~0x00000010);
838 return this;
839 }
840
841 public Builder clone() {
842 return create().mergeFrom(buildPartial());
843 }
844
845 public com.google.protobuf.Descriptors.Descriptor
846 getDescriptorForType() {
847 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcRequestHeaderProto_descriptor;
848 }
849
850 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto getDefaultInstanceForType() {
851 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.getDefaultInstance();
852 }
853
854 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto build() {
855 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto result = buildPartial();
856 if (!result.isInitialized()) {
857 throw newUninitializedMessageException(result);
858 }
859 return result;
860 }
861
862 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto buildPartial() {
863 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto result = new org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto(this);
864 int from_bitField0_ = bitField0_;
865 int to_bitField0_ = 0;
866 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
867 to_bitField0_ |= 0x00000001;
868 }
869 result.rpcKind_ = rpcKind_;
870 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
871 to_bitField0_ |= 0x00000002;
872 }
873 result.rpcOp_ = rpcOp_;
874 if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
875 to_bitField0_ |= 0x00000004;
876 }
877 result.callId_ = callId_;
878 if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
879 to_bitField0_ |= 0x00000008;
880 }
881 result.clientId_ = clientId_;
882 if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
883 to_bitField0_ |= 0x00000010;
884 }
885 result.retryCount_ = retryCount_;
886 result.bitField0_ = to_bitField0_;
887 onBuilt();
888 return result;
889 }
890
891 public Builder mergeFrom(com.google.protobuf.Message other) {
892 if (other instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto) {
893 return mergeFrom((org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto)other);
894 } else {
895 super.mergeFrom(other);
896 return this;
897 }
898 }
899
900 public Builder mergeFrom(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto other) {
901 if (other == org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.getDefaultInstance()) return this;
902 if (other.hasRpcKind()) {
903 setRpcKind(other.getRpcKind());
904 }
905 if (other.hasRpcOp()) {
906 setRpcOp(other.getRpcOp());
907 }
908 if (other.hasCallId()) {
909 setCallId(other.getCallId());
910 }
911 if (other.hasClientId()) {
912 setClientId(other.getClientId());
913 }
914 if (other.hasRetryCount()) {
915 setRetryCount(other.getRetryCount());
916 }
917 this.mergeUnknownFields(other.getUnknownFields());
918 return this;
919 }
920
921 public final boolean isInitialized() {
922 if (!hasCallId()) {
923
924 return false;
925 }
926 if (!hasClientId()) {
927
928 return false;
929 }
930 return true;
931 }
932
933 public Builder mergeFrom(
934 com.google.protobuf.CodedInputStream input,
935 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
936 throws java.io.IOException {
937 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto parsedMessage = null;
938 try {
939 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
940 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
941 parsedMessage = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto) e.getUnfinishedMessage();
942 throw e;
943 } finally {
944 if (parsedMessage != null) {
945 mergeFrom(parsedMessage);
946 }
947 }
948 return this;
949 }
950 private int bitField0_;
951
952 // optional .hadoop.common.RpcKindProto rpcKind = 1;
953 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto rpcKind_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto.RPC_BUILTIN;
954 /**
955 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
956 */
957 public boolean hasRpcKind() {
958 return ((bitField0_ & 0x00000001) == 0x00000001);
959 }
960 /**
961 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
962 */
963 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto getRpcKind() {
964 return rpcKind_;
965 }
966 /**
967 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
968 */
969 public Builder setRpcKind(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto value) {
970 if (value == null) {
971 throw new NullPointerException();
972 }
973 bitField0_ |= 0x00000001;
974 rpcKind_ = value;
975 onChanged();
976 return this;
977 }
978 /**
979 * <code>optional .hadoop.common.RpcKindProto rpcKind = 1;</code>
980 */
981 public Builder clearRpcKind() {
982 bitField0_ = (bitField0_ & ~0x00000001);
983 rpcKind_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcKindProto.RPC_BUILTIN;
984 onChanged();
985 return this;
986 }
987
988 // optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;
989 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto rpcOp_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto.RPC_FINAL_PACKET;
990 /**
991 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
992 */
993 public boolean hasRpcOp() {
994 return ((bitField0_ & 0x00000002) == 0x00000002);
995 }
996 /**
997 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
998 */
999 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto getRpcOp() {
1000 return rpcOp_;
1001 }
1002 /**
1003 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
1004 */
1005 public Builder setRpcOp(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto value) {
1006 if (value == null) {
1007 throw new NullPointerException();
1008 }
1009 bitField0_ |= 0x00000002;
1010 rpcOp_ = value;
1011 onChanged();
1012 return this;
1013 }
1014 /**
1015 * <code>optional .hadoop.common.RpcRequestHeaderProto.OperationProto rpcOp = 2;</code>
1016 */
1017 public Builder clearRpcOp() {
1018 bitField0_ = (bitField0_ & ~0x00000002);
1019 rpcOp_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcRequestHeaderProto.OperationProto.RPC_FINAL_PACKET;
1020 onChanged();
1021 return this;
1022 }
1023
1024 // required sint32 callId = 3;
1025 private int callId_ ;
1026 /**
1027 * <code>required sint32 callId = 3;</code>
1028 *
1029 * <pre>
1030 * a sequence number that is sent back in response
1031 * </pre>
1032 */
1033 public boolean hasCallId() {
1034 return ((bitField0_ & 0x00000004) == 0x00000004);
1035 }
1036 /**
1037 * <code>required sint32 callId = 3;</code>
1038 *
1039 * <pre>
1040 * a sequence number that is sent back in response
1041 * </pre>
1042 */
1043 public int getCallId() {
1044 return callId_;
1045 }
1046 /**
1047 * <code>required sint32 callId = 3;</code>
1048 *
1049 * <pre>
1050 * a sequence number that is sent back in response
1051 * </pre>
1052 */
1053 public Builder setCallId(int value) {
1054 bitField0_ |= 0x00000004;
1055 callId_ = value;
1056 onChanged();
1057 return this;
1058 }
1059 /**
1060 * <code>required sint32 callId = 3;</code>
1061 *
1062 * <pre>
1063 * a sequence number that is sent back in response
1064 * </pre>
1065 */
1066 public Builder clearCallId() {
1067 bitField0_ = (bitField0_ & ~0x00000004);
1068 callId_ = 0;
1069 onChanged();
1070 return this;
1071 }
1072
1073 // required bytes clientId = 4;
1074 private com.google.protobuf.ByteString clientId_ = com.google.protobuf.ByteString.EMPTY;
1075 /**
1076 * <code>required bytes clientId = 4;</code>
1077 *
1078 * <pre>
1079 * Globally unique client ID
1080 * </pre>
1081 */
1082 public boolean hasClientId() {
1083 return ((bitField0_ & 0x00000008) == 0x00000008);
1084 }
1085 /**
1086 * <code>required bytes clientId = 4;</code>
1087 *
1088 * <pre>
1089 * Globally unique client ID
1090 * </pre>
1091 */
1092 public com.google.protobuf.ByteString getClientId() {
1093 return clientId_;
1094 }
1095 /**
1096 * <code>required bytes clientId = 4;</code>
1097 *
1098 * <pre>
1099 * Globally unique client ID
1100 * </pre>
1101 */
1102 public Builder setClientId(com.google.protobuf.ByteString value) {
1103 if (value == null) {
1104 throw new NullPointerException();
1105 }
1106 bitField0_ |= 0x00000008;
1107 clientId_ = value;
1108 onChanged();
1109 return this;
1110 }
1111 /**
1112 * <code>required bytes clientId = 4;</code>
1113 *
1114 * <pre>
1115 * Globally unique client ID
1116 * </pre>
1117 */
1118 public Builder clearClientId() {
1119 bitField0_ = (bitField0_ & ~0x00000008);
1120 clientId_ = getDefaultInstance().getClientId();
1121 onChanged();
1122 return this;
1123 }
1124
1125 // optional sint32 retryCount = 5 [default = -1];
1126 private int retryCount_ = -1;
1127 /**
1128 * <code>optional sint32 retryCount = 5 [default = -1];</code>
1129 *
1130 * <pre>
1131 * clientId + callId uniquely identifies a request
1132 * retry count, 1 means this is the first retry
1133 * </pre>
1134 */
1135 public boolean hasRetryCount() {
1136 return ((bitField0_ & 0x00000010) == 0x00000010);
1137 }
1138 /**
1139 * <code>optional sint32 retryCount = 5 [default = -1];</code>
1140 *
1141 * <pre>
1142 * clientId + callId uniquely identifies a request
1143 * retry count, 1 means this is the first retry
1144 * </pre>
1145 */
1146 public int getRetryCount() {
1147 return retryCount_;
1148 }
1149 /**
1150 * <code>optional sint32 retryCount = 5 [default = -1];</code>
1151 *
1152 * <pre>
1153 * clientId + callId uniquely identifies a request
1154 * retry count, 1 means this is the first retry
1155 * </pre>
1156 */
1157 public Builder setRetryCount(int value) {
1158 bitField0_ |= 0x00000010;
1159 retryCount_ = value;
1160 onChanged();
1161 return this;
1162 }
1163 /**
1164 * <code>optional sint32 retryCount = 5 [default = -1];</code>
1165 *
1166 * <pre>
1167 * clientId + callId uniquely identifies a request
1168 * retry count, 1 means this is the first retry
1169 * </pre>
1170 */
1171 public Builder clearRetryCount() {
1172 bitField0_ = (bitField0_ & ~0x00000010);
1173 retryCount_ = -1;
1174 onChanged();
1175 return this;
1176 }
1177
1178 // @@protoc_insertion_point(builder_scope:hadoop.common.RpcRequestHeaderProto)
1179 }
1180
1181 static {
1182 defaultInstance = new RpcRequestHeaderProto(true);
1183 defaultInstance.initFields();
1184 }
1185
1186 // @@protoc_insertion_point(class_scope:hadoop.common.RpcRequestHeaderProto)
1187 }
1188
1189 public interface RpcResponseHeaderProtoOrBuilder
1190 extends com.google.protobuf.MessageOrBuilder {
1191
1192 // required uint32 callId = 1;
1193 /**
1194 * <code>required uint32 callId = 1;</code>
1195 *
1196 * <pre>
1197 * callId used in Request
1198 * </pre>
1199 */
1200 boolean hasCallId();
1201 /**
1202 * <code>required uint32 callId = 1;</code>
1203 *
1204 * <pre>
1205 * callId used in Request
1206 * </pre>
1207 */
1208 int getCallId();
1209
1210 // required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;
1211 /**
1212 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
1213 */
1214 boolean hasStatus();
1215 /**
1216 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
1217 */
1218 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto getStatus();
1219
1220 // optional uint32 serverIpcVersionNum = 3;
1221 /**
1222 * <code>optional uint32 serverIpcVersionNum = 3;</code>
1223 *
1224 * <pre>
1225 * Sent if success or fail
1226 * </pre>
1227 */
1228 boolean hasServerIpcVersionNum();
1229 /**
1230 * <code>optional uint32 serverIpcVersionNum = 3;</code>
1231 *
1232 * <pre>
1233 * Sent if success or fail
1234 * </pre>
1235 */
1236 int getServerIpcVersionNum();
1237
1238 // optional string exceptionClassName = 4;
1239 /**
1240 * <code>optional string exceptionClassName = 4;</code>
1241 *
1242 * <pre>
1243 * if request fails
1244 * </pre>
1245 */
1246 boolean hasExceptionClassName();
1247 /**
1248 * <code>optional string exceptionClassName = 4;</code>
1249 *
1250 * <pre>
1251 * if request fails
1252 * </pre>
1253 */
1254 java.lang.String getExceptionClassName();
1255 /**
1256 * <code>optional string exceptionClassName = 4;</code>
1257 *
1258 * <pre>
1259 * if request fails
1260 * </pre>
1261 */
1262 com.google.protobuf.ByteString
1263 getExceptionClassNameBytes();
1264
1265 // optional string errorMsg = 5;
1266 /**
1267 * <code>optional string errorMsg = 5;</code>
1268 *
1269 * <pre>
1270 * if request fails, often contains strack trace
1271 * </pre>
1272 */
1273 boolean hasErrorMsg();
1274 /**
1275 * <code>optional string errorMsg = 5;</code>
1276 *
1277 * <pre>
1278 * if request fails, often contains strack trace
1279 * </pre>
1280 */
1281 java.lang.String getErrorMsg();
1282 /**
1283 * <code>optional string errorMsg = 5;</code>
1284 *
1285 * <pre>
1286 * if request fails, often contains strack trace
1287 * </pre>
1288 */
1289 com.google.protobuf.ByteString
1290 getErrorMsgBytes();
1291
1292 // optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
1293 /**
1294 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
1295 *
1296 * <pre>
1297 * in case of error
1298 * </pre>
1299 */
1300 boolean hasErrorDetail();
1301 /**
1302 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
1303 *
1304 * <pre>
1305 * in case of error
1306 * </pre>
1307 */
1308 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto getErrorDetail();
1309
1310 // optional bytes clientId = 7;
1311 /**
1312 * <code>optional bytes clientId = 7;</code>
1313 *
1314 * <pre>
1315 * Globally unique client ID
1316 * </pre>
1317 */
1318 boolean hasClientId();
1319 /**
1320 * <code>optional bytes clientId = 7;</code>
1321 *
1322 * <pre>
1323 * Globally unique client ID
1324 * </pre>
1325 */
1326 com.google.protobuf.ByteString getClientId();
1327
1328 // optional sint32 retryCount = 8 [default = -1];
1329 /**
1330 * <code>optional sint32 retryCount = 8 [default = -1];</code>
1331 */
1332 boolean hasRetryCount();
1333 /**
1334 * <code>optional sint32 retryCount = 8 [default = -1];</code>
1335 */
1336 int getRetryCount();
1337 }
1338 /**
1339 * Protobuf type {@code hadoop.common.RpcResponseHeaderProto}
1340 *
1341 * <pre>
1342 **
1343 * Rpc Response Header
1344 * +------------------------------------------------------------------+
1345 * | Rpc total response length in bytes (4 bytes int) |
1346 * | (sum of next two parts) |
1347 * +------------------------------------------------------------------+
1348 * | RpcResponseHeaderProto - serialized delimited ie has len |
1349 * +------------------------------------------------------------------+
1350 * | if request is successful: |
1351 * | - RpcResponse - The actual rpc response bytes follow |
1352 * | the response header |
1353 * | This response is serialized based on RpcKindProto |
1354 * | if request fails : |
1355 * | The rpc response header contains the necessary info |
1356 * +------------------------------------------------------------------+
1357 *
1358 * Note that rpc response header is also used when connection setup fails.
1359 * Ie the response looks like a rpc response with a fake callId.
1360 * </pre>
1361 */
1362 public static final class RpcResponseHeaderProto extends
1363 com.google.protobuf.GeneratedMessage
1364 implements RpcResponseHeaderProtoOrBuilder {
1365 // Use RpcResponseHeaderProto.newBuilder() to construct.
1366 private RpcResponseHeaderProto(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
1367 super(builder);
1368 this.unknownFields = builder.getUnknownFields();
1369 }
1370 private RpcResponseHeaderProto(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
1371
1372 private static final RpcResponseHeaderProto defaultInstance;
1373 public static RpcResponseHeaderProto getDefaultInstance() {
1374 return defaultInstance;
1375 }
1376
1377 public RpcResponseHeaderProto getDefaultInstanceForType() {
1378 return defaultInstance;
1379 }
1380
1381 private final com.google.protobuf.UnknownFieldSet unknownFields;
1382 @java.lang.Override
1383 public final com.google.protobuf.UnknownFieldSet
1384 getUnknownFields() {
1385 return this.unknownFields;
1386 }
1387 private RpcResponseHeaderProto(
1388 com.google.protobuf.CodedInputStream input,
1389 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1390 throws com.google.protobuf.InvalidProtocolBufferException {
1391 initFields();
1392 int mutable_bitField0_ = 0;
1393 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
1394 com.google.protobuf.UnknownFieldSet.newBuilder();
1395 try {
1396 boolean done = false;
1397 while (!done) {
1398 int tag = input.readTag();
1399 switch (tag) {
1400 case 0:
1401 done = true;
1402 break;
1403 default: {
1404 if (!parseUnknownField(input, unknownFields,
1405 extensionRegistry, tag)) {
1406 done = true;
1407 }
1408 break;
1409 }
1410 case 8: {
1411 bitField0_ |= 0x00000001;
1412 callId_ = input.readUInt32();
1413 break;
1414 }
1415 case 16: {
1416 int rawValue = input.readEnum();
1417 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto value = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto.valueOf(rawValue);
1418 if (value == null) {
1419 unknownFields.mergeVarintField(2, rawValue);
1420 } else {
1421 bitField0_ |= 0x00000002;
1422 status_ = value;
1423 }
1424 break;
1425 }
1426 case 24: {
1427 bitField0_ |= 0x00000004;
1428 serverIpcVersionNum_ = input.readUInt32();
1429 break;
1430 }
1431 case 34: {
1432 bitField0_ |= 0x00000008;
1433 exceptionClassName_ = input.readBytes();
1434 break;
1435 }
1436 case 42: {
1437 bitField0_ |= 0x00000010;
1438 errorMsg_ = input.readBytes();
1439 break;
1440 }
1441 case 48: {
1442 int rawValue = input.readEnum();
1443 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto value = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto.valueOf(rawValue);
1444 if (value == null) {
1445 unknownFields.mergeVarintField(6, rawValue);
1446 } else {
1447 bitField0_ |= 0x00000020;
1448 errorDetail_ = value;
1449 }
1450 break;
1451 }
1452 case 58: {
1453 bitField0_ |= 0x00000040;
1454 clientId_ = input.readBytes();
1455 break;
1456 }
1457 case 64: {
1458 bitField0_ |= 0x00000080;
1459 retryCount_ = input.readSInt32();
1460 break;
1461 }
1462 }
1463 }
1464 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
1465 throw e.setUnfinishedMessage(this);
1466 } catch (java.io.IOException e) {
1467 throw new com.google.protobuf.InvalidProtocolBufferException(
1468 e.getMessage()).setUnfinishedMessage(this);
1469 } finally {
1470 this.unknownFields = unknownFields.build();
1471 makeExtensionsImmutable();
1472 }
1473 }
1474 public static final com.google.protobuf.Descriptors.Descriptor
1475 getDescriptor() {
1476 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcResponseHeaderProto_descriptor;
1477 }
1478
1479 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
1480 internalGetFieldAccessorTable() {
1481 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcResponseHeaderProto_fieldAccessorTable
1482 .ensureFieldAccessorsInitialized(
1483 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.Builder.class);
1484 }
1485
1486 public static com.google.protobuf.Parser<RpcResponseHeaderProto> PARSER =
1487 new com.google.protobuf.AbstractParser<RpcResponseHeaderProto>() {
1488 public RpcResponseHeaderProto parsePartialFrom(
1489 com.google.protobuf.CodedInputStream input,
1490 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
1491 throws com.google.protobuf.InvalidProtocolBufferException {
1492 return new RpcResponseHeaderProto(input, extensionRegistry);
1493 }
1494 };
1495
1496 @java.lang.Override
1497 public com.google.protobuf.Parser<RpcResponseHeaderProto> getParserForType() {
1498 return PARSER;
1499 }
1500
1501 /**
1502 * Protobuf enum {@code hadoop.common.RpcResponseHeaderProto.RpcStatusProto}
1503 */
1504 public enum RpcStatusProto
1505 implements com.google.protobuf.ProtocolMessageEnum {
1506 /**
1507 * <code>SUCCESS = 0;</code>
1508 *
1509 * <pre>
1510 * RPC succeeded
1511 * </pre>
1512 */
1513 SUCCESS(0, 0),
1514 /**
1515 * <code>ERROR = 1;</code>
1516 *
1517 * <pre>
1518 * RPC or error - connection left open for future calls
1519 * </pre>
1520 */
1521 ERROR(1, 1),
1522 /**
1523 * <code>FATAL = 2;</code>
1524 *
1525 * <pre>
1526 * Fatal error - connection closed
1527 * </pre>
1528 */
1529 FATAL(2, 2),
1530 ;
1531
1532 /**
1533 * <code>SUCCESS = 0;</code>
1534 *
1535 * <pre>
1536 * RPC succeeded
1537 * </pre>
1538 */
1539 public static final int SUCCESS_VALUE = 0;
1540 /**
1541 * <code>ERROR = 1;</code>
1542 *
1543 * <pre>
1544 * RPC or error - connection left open for future calls
1545 * </pre>
1546 */
1547 public static final int ERROR_VALUE = 1;
1548 /**
1549 * <code>FATAL = 2;</code>
1550 *
1551 * <pre>
1552 * Fatal error - connection closed
1553 * </pre>
1554 */
1555 public static final int FATAL_VALUE = 2;
1556
1557
1558 public final int getNumber() { return value; }
1559
1560 public static RpcStatusProto valueOf(int value) {
1561 switch (value) {
1562 case 0: return SUCCESS;
1563 case 1: return ERROR;
1564 case 2: return FATAL;
1565 default: return null;
1566 }
1567 }
1568
1569 public static com.google.protobuf.Internal.EnumLiteMap<RpcStatusProto>
1570 internalGetValueMap() {
1571 return internalValueMap;
1572 }
1573 private static com.google.protobuf.Internal.EnumLiteMap<RpcStatusProto>
1574 internalValueMap =
1575 new com.google.protobuf.Internal.EnumLiteMap<RpcStatusProto>() {
1576 public RpcStatusProto findValueByNumber(int number) {
1577 return RpcStatusProto.valueOf(number);
1578 }
1579 };
1580
1581 public final com.google.protobuf.Descriptors.EnumValueDescriptor
1582 getValueDescriptor() {
1583 return getDescriptor().getValues().get(index);
1584 }
1585 public final com.google.protobuf.Descriptors.EnumDescriptor
1586 getDescriptorForType() {
1587 return getDescriptor();
1588 }
1589 public static final com.google.protobuf.Descriptors.EnumDescriptor
1590 getDescriptor() {
1591 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.getDescriptor().getEnumTypes().get(0);
1592 }
1593
1594 private static final RpcStatusProto[] VALUES = values();
1595
1596 public static RpcStatusProto valueOf(
1597 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1598 if (desc.getType() != getDescriptor()) {
1599 throw new java.lang.IllegalArgumentException(
1600 "EnumValueDescriptor is not for this type.");
1601 }
1602 return VALUES[desc.getIndex()];
1603 }
1604
1605 private final int index;
1606 private final int value;
1607
1608 private RpcStatusProto(int index, int value) {
1609 this.index = index;
1610 this.value = value;
1611 }
1612
1613 // @@protoc_insertion_point(enum_scope:hadoop.common.RpcResponseHeaderProto.RpcStatusProto)
1614 }
1615
1616 /**
1617 * Protobuf enum {@code hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto}
1618 */
1619 public enum RpcErrorCodeProto
1620 implements com.google.protobuf.ProtocolMessageEnum {
1621 /**
1622 * <code>ERROR_APPLICATION = 1;</code>
1623 *
1624 * <pre>
1625 * Non-fatal Rpc error - connection left open for future rpc calls
1626 * </pre>
1627 */
1628 ERROR_APPLICATION(0, 1),
1629 /**
1630 * <code>ERROR_NO_SUCH_METHOD = 2;</code>
1631 *
1632 * <pre>
1633 * Rpc error - no such method
1634 * </pre>
1635 */
1636 ERROR_NO_SUCH_METHOD(1, 2),
1637 /**
1638 * <code>ERROR_NO_SUCH_PROTOCOL = 3;</code>
1639 *
1640 * <pre>
1641 * Rpc error - no such protocol
1642 * </pre>
1643 */
1644 ERROR_NO_SUCH_PROTOCOL(2, 3),
1645 /**
1646 * <code>ERROR_RPC_SERVER = 4;</code>
1647 *
1648 * <pre>
1649 * Rpc error on server side
1650 * </pre>
1651 */
1652 ERROR_RPC_SERVER(3, 4),
1653 /**
1654 * <code>ERROR_SERIALIZING_RESPONSE = 5;</code>
1655 *
1656 * <pre>
1657 * error serializign response
1658 * </pre>
1659 */
1660 ERROR_SERIALIZING_RESPONSE(4, 5),
1661 /**
1662 * <code>ERROR_RPC_VERSION_MISMATCH = 6;</code>
1663 *
1664 * <pre>
1665 * Rpc protocol version mismatch
1666 * </pre>
1667 */
1668 ERROR_RPC_VERSION_MISMATCH(5, 6),
1669 /**
1670 * <code>FATAL_UNKNOWN = 10;</code>
1671 *
1672 * <pre>
1673 * Fatal Server side Rpc error - connection closed
1674 * </pre>
1675 */
1676 FATAL_UNKNOWN(6, 10),
1677 /**
1678 * <code>FATAL_UNSUPPORTED_SERIALIZATION = 11;</code>
1679 *
1680 * <pre>
1681 * IPC layer serilization type invalid
1682 * </pre>
1683 */
1684 FATAL_UNSUPPORTED_SERIALIZATION(7, 11),
1685 /**
1686 * <code>FATAL_INVALID_RPC_HEADER = 12;</code>
1687 *
1688 * <pre>
1689 * fields of RpcHeader are invalid
1690 * </pre>
1691 */
1692 FATAL_INVALID_RPC_HEADER(8, 12),
1693 /**
1694 * <code>FATAL_DESERIALIZING_REQUEST = 13;</code>
1695 *
1696 * <pre>
1697 * could not deserilize rpc request
1698 * </pre>
1699 */
1700 FATAL_DESERIALIZING_REQUEST(9, 13),
1701 /**
1702 * <code>FATAL_VERSION_MISMATCH = 14;</code>
1703 *
1704 * <pre>
1705 * Ipc Layer version mismatch
1706 * </pre>
1707 */
1708 FATAL_VERSION_MISMATCH(10, 14),
1709 /**
1710 * <code>FATAL_UNAUTHORIZED = 15;</code>
1711 *
1712 * <pre>
1713 * Auth failed
1714 * </pre>
1715 */
1716 FATAL_UNAUTHORIZED(11, 15),
1717 ;
1718
1719 /**
1720 * <code>ERROR_APPLICATION = 1;</code>
1721 *
1722 * <pre>
1723 * Non-fatal Rpc error - connection left open for future rpc calls
1724 * </pre>
1725 */
1726 public static final int ERROR_APPLICATION_VALUE = 1;
1727 /**
1728 * <code>ERROR_NO_SUCH_METHOD = 2;</code>
1729 *
1730 * <pre>
1731 * Rpc error - no such method
1732 * </pre>
1733 */
1734 public static final int ERROR_NO_SUCH_METHOD_VALUE = 2;
1735 /**
1736 * <code>ERROR_NO_SUCH_PROTOCOL = 3;</code>
1737 *
1738 * <pre>
1739 * Rpc error - no such protocol
1740 * </pre>
1741 */
1742 public static final int ERROR_NO_SUCH_PROTOCOL_VALUE = 3;
1743 /**
1744 * <code>ERROR_RPC_SERVER = 4;</code>
1745 *
1746 * <pre>
1747 * Rpc error on server side
1748 * </pre>
1749 */
1750 public static final int ERROR_RPC_SERVER_VALUE = 4;
1751 /**
1752 * <code>ERROR_SERIALIZING_RESPONSE = 5;</code>
1753 *
1754 * <pre>
1755 * error serializign response
1756 * </pre>
1757 */
1758 public static final int ERROR_SERIALIZING_RESPONSE_VALUE = 5;
1759 /**
1760 * <code>ERROR_RPC_VERSION_MISMATCH = 6;</code>
1761 *
1762 * <pre>
1763 * Rpc protocol version mismatch
1764 * </pre>
1765 */
1766 public static final int ERROR_RPC_VERSION_MISMATCH_VALUE = 6;
1767 /**
1768 * <code>FATAL_UNKNOWN = 10;</code>
1769 *
1770 * <pre>
1771 * Fatal Server side Rpc error - connection closed
1772 * </pre>
1773 */
1774 public static final int FATAL_UNKNOWN_VALUE = 10;
1775 /**
1776 * <code>FATAL_UNSUPPORTED_SERIALIZATION = 11;</code>
1777 *
1778 * <pre>
1779 * IPC layer serilization type invalid
1780 * </pre>
1781 */
1782 public static final int FATAL_UNSUPPORTED_SERIALIZATION_VALUE = 11;
1783 /**
1784 * <code>FATAL_INVALID_RPC_HEADER = 12;</code>
1785 *
1786 * <pre>
1787 * fields of RpcHeader are invalid
1788 * </pre>
1789 */
1790 public static final int FATAL_INVALID_RPC_HEADER_VALUE = 12;
1791 /**
1792 * <code>FATAL_DESERIALIZING_REQUEST = 13;</code>
1793 *
1794 * <pre>
1795 * could not deserilize rpc request
1796 * </pre>
1797 */
1798 public static final int FATAL_DESERIALIZING_REQUEST_VALUE = 13;
1799 /**
1800 * <code>FATAL_VERSION_MISMATCH = 14;</code>
1801 *
1802 * <pre>
1803 * Ipc Layer version mismatch
1804 * </pre>
1805 */
1806 public static final int FATAL_VERSION_MISMATCH_VALUE = 14;
1807 /**
1808 * <code>FATAL_UNAUTHORIZED = 15;</code>
1809 *
1810 * <pre>
1811 * Auth failed
1812 * </pre>
1813 */
1814 public static final int FATAL_UNAUTHORIZED_VALUE = 15;
1815
1816
1817 public final int getNumber() { return value; }
1818
1819 public static RpcErrorCodeProto valueOf(int value) {
1820 switch (value) {
1821 case 1: return ERROR_APPLICATION;
1822 case 2: return ERROR_NO_SUCH_METHOD;
1823 case 3: return ERROR_NO_SUCH_PROTOCOL;
1824 case 4: return ERROR_RPC_SERVER;
1825 case 5: return ERROR_SERIALIZING_RESPONSE;
1826 case 6: return ERROR_RPC_VERSION_MISMATCH;
1827 case 10: return FATAL_UNKNOWN;
1828 case 11: return FATAL_UNSUPPORTED_SERIALIZATION;
1829 case 12: return FATAL_INVALID_RPC_HEADER;
1830 case 13: return FATAL_DESERIALIZING_REQUEST;
1831 case 14: return FATAL_VERSION_MISMATCH;
1832 case 15: return FATAL_UNAUTHORIZED;
1833 default: return null;
1834 }
1835 }
1836
1837 public static com.google.protobuf.Internal.EnumLiteMap<RpcErrorCodeProto>
1838 internalGetValueMap() {
1839 return internalValueMap;
1840 }
1841 private static com.google.protobuf.Internal.EnumLiteMap<RpcErrorCodeProto>
1842 internalValueMap =
1843 new com.google.protobuf.Internal.EnumLiteMap<RpcErrorCodeProto>() {
1844 public RpcErrorCodeProto findValueByNumber(int number) {
1845 return RpcErrorCodeProto.valueOf(number);
1846 }
1847 };
1848
1849 public final com.google.protobuf.Descriptors.EnumValueDescriptor
1850 getValueDescriptor() {
1851 return getDescriptor().getValues().get(index);
1852 }
1853 public final com.google.protobuf.Descriptors.EnumDescriptor
1854 getDescriptorForType() {
1855 return getDescriptor();
1856 }
1857 public static final com.google.protobuf.Descriptors.EnumDescriptor
1858 getDescriptor() {
1859 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.getDescriptor().getEnumTypes().get(1);
1860 }
1861
1862 private static final RpcErrorCodeProto[] VALUES = values();
1863
1864 public static RpcErrorCodeProto valueOf(
1865 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1866 if (desc.getType() != getDescriptor()) {
1867 throw new java.lang.IllegalArgumentException(
1868 "EnumValueDescriptor is not for this type.");
1869 }
1870 return VALUES[desc.getIndex()];
1871 }
1872
1873 private final int index;
1874 private final int value;
1875
1876 private RpcErrorCodeProto(int index, int value) {
1877 this.index = index;
1878 this.value = value;
1879 }
1880
1881 // @@protoc_insertion_point(enum_scope:hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto)
1882 }
1883
1884 private int bitField0_;
1885 // required uint32 callId = 1;
1886 public static final int CALLID_FIELD_NUMBER = 1;
1887 private int callId_;
1888 /**
1889 * <code>required uint32 callId = 1;</code>
1890 *
1891 * <pre>
1892 * callId used in Request
1893 * </pre>
1894 */
1895 public boolean hasCallId() {
1896 return ((bitField0_ & 0x00000001) == 0x00000001);
1897 }
1898 /**
1899 * <code>required uint32 callId = 1;</code>
1900 *
1901 * <pre>
1902 * callId used in Request
1903 * </pre>
1904 */
1905 public int getCallId() {
1906 return callId_;
1907 }
1908
1909 // required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;
1910 public static final int STATUS_FIELD_NUMBER = 2;
1911 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto status_;
1912 /**
1913 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
1914 */
1915 public boolean hasStatus() {
1916 return ((bitField0_ & 0x00000002) == 0x00000002);
1917 }
1918 /**
1919 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
1920 */
1921 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto getStatus() {
1922 return status_;
1923 }
1924
1925 // optional uint32 serverIpcVersionNum = 3;
1926 public static final int SERVERIPCVERSIONNUM_FIELD_NUMBER = 3;
1927 private int serverIpcVersionNum_;
1928 /**
1929 * <code>optional uint32 serverIpcVersionNum = 3;</code>
1930 *
1931 * <pre>
1932 * Sent if success or fail
1933 * </pre>
1934 */
1935 public boolean hasServerIpcVersionNum() {
1936 return ((bitField0_ & 0x00000004) == 0x00000004);
1937 }
1938 /**
1939 * <code>optional uint32 serverIpcVersionNum = 3;</code>
1940 *
1941 * <pre>
1942 * Sent if success or fail
1943 * </pre>
1944 */
1945 public int getServerIpcVersionNum() {
1946 return serverIpcVersionNum_;
1947 }
1948
1949 // optional string exceptionClassName = 4;
1950 public static final int EXCEPTIONCLASSNAME_FIELD_NUMBER = 4;
1951 private java.lang.Object exceptionClassName_;
1952 /**
1953 * <code>optional string exceptionClassName = 4;</code>
1954 *
1955 * <pre>
1956 * if request fails
1957 * </pre>
1958 */
1959 public boolean hasExceptionClassName() {
1960 return ((bitField0_ & 0x00000008) == 0x00000008);
1961 }
1962 /**
1963 * <code>optional string exceptionClassName = 4;</code>
1964 *
1965 * <pre>
1966 * if request fails
1967 * </pre>
1968 */
1969 public java.lang.String getExceptionClassName() {
1970 java.lang.Object ref = exceptionClassName_;
1971 if (ref instanceof java.lang.String) {
1972 return (java.lang.String) ref;
1973 } else {
1974 com.google.protobuf.ByteString bs =
1975 (com.google.protobuf.ByteString) ref;
1976 java.lang.String s = bs.toStringUtf8();
1977 if (bs.isValidUtf8()) {
1978 exceptionClassName_ = s;
1979 }
1980 return s;
1981 }
1982 }
1983 /**
1984 * <code>optional string exceptionClassName = 4;</code>
1985 *
1986 * <pre>
1987 * if request fails
1988 * </pre>
1989 */
1990 public com.google.protobuf.ByteString
1991 getExceptionClassNameBytes() {
1992 java.lang.Object ref = exceptionClassName_;
1993 if (ref instanceof java.lang.String) {
1994 com.google.protobuf.ByteString b =
1995 com.google.protobuf.ByteString.copyFromUtf8(
1996 (java.lang.String) ref);
1997 exceptionClassName_ = b;
1998 return b;
1999 } else {
2000 return (com.google.protobuf.ByteString) ref;
2001 }
2002 }
2003
2004 // optional string errorMsg = 5;
2005 public static final int ERRORMSG_FIELD_NUMBER = 5;
2006 private java.lang.Object errorMsg_;
2007 /**
2008 * <code>optional string errorMsg = 5;</code>
2009 *
2010 * <pre>
2011 * if request fails, often contains strack trace
2012 * </pre>
2013 */
2014 public boolean hasErrorMsg() {
2015 return ((bitField0_ & 0x00000010) == 0x00000010);
2016 }
2017 /**
2018 * <code>optional string errorMsg = 5;</code>
2019 *
2020 * <pre>
2021 * if request fails, often contains strack trace
2022 * </pre>
2023 */
2024 public java.lang.String getErrorMsg() {
2025 java.lang.Object ref = errorMsg_;
2026 if (ref instanceof java.lang.String) {
2027 return (java.lang.String) ref;
2028 } else {
2029 com.google.protobuf.ByteString bs =
2030 (com.google.protobuf.ByteString) ref;
2031 java.lang.String s = bs.toStringUtf8();
2032 if (bs.isValidUtf8()) {
2033 errorMsg_ = s;
2034 }
2035 return s;
2036 }
2037 }
2038 /**
2039 * <code>optional string errorMsg = 5;</code>
2040 *
2041 * <pre>
2042 * if request fails, often contains strack trace
2043 * </pre>
2044 */
2045 public com.google.protobuf.ByteString
2046 getErrorMsgBytes() {
2047 java.lang.Object ref = errorMsg_;
2048 if (ref instanceof java.lang.String) {
2049 com.google.protobuf.ByteString b =
2050 com.google.protobuf.ByteString.copyFromUtf8(
2051 (java.lang.String) ref);
2052 errorMsg_ = b;
2053 return b;
2054 } else {
2055 return (com.google.protobuf.ByteString) ref;
2056 }
2057 }
2058
2059 // optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
2060 public static final int ERRORDETAIL_FIELD_NUMBER = 6;
2061 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail_;
2062 /**
2063 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
2064 *
2065 * <pre>
2066 * in case of error
2067 * </pre>
2068 */
2069 public boolean hasErrorDetail() {
2070 return ((bitField0_ & 0x00000020) == 0x00000020);
2071 }
2072 /**
2073 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
2074 *
2075 * <pre>
2076 * in case of error
2077 * </pre>
2078 */
2079 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto getErrorDetail() {
2080 return errorDetail_;
2081 }
2082
2083 // optional bytes clientId = 7;
2084 public static final int CLIENTID_FIELD_NUMBER = 7;
2085 private com.google.protobuf.ByteString clientId_;
2086 /**
2087 * <code>optional bytes clientId = 7;</code>
2088 *
2089 * <pre>
2090 * Globally unique client ID
2091 * </pre>
2092 */
2093 public boolean hasClientId() {
2094 return ((bitField0_ & 0x00000040) == 0x00000040);
2095 }
2096 /**
2097 * <code>optional bytes clientId = 7;</code>
2098 *
2099 * <pre>
2100 * Globally unique client ID
2101 * </pre>
2102 */
2103 public com.google.protobuf.ByteString getClientId() {
2104 return clientId_;
2105 }
2106
2107 // optional sint32 retryCount = 8 [default = -1];
2108 public static final int RETRYCOUNT_FIELD_NUMBER = 8;
2109 private int retryCount_;
2110 /**
2111 * <code>optional sint32 retryCount = 8 [default = -1];</code>
2112 */
2113 public boolean hasRetryCount() {
2114 return ((bitField0_ & 0x00000080) == 0x00000080);
2115 }
2116 /**
2117 * <code>optional sint32 retryCount = 8 [default = -1];</code>
2118 */
2119 public int getRetryCount() {
2120 return retryCount_;
2121 }
2122
2123 private void initFields() {
2124 callId_ = 0;
2125 status_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto.SUCCESS;
2126 serverIpcVersionNum_ = 0;
2127 exceptionClassName_ = "";
2128 errorMsg_ = "";
2129 errorDetail_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto.ERROR_APPLICATION;
2130 clientId_ = com.google.protobuf.ByteString.EMPTY;
2131 retryCount_ = -1;
2132 }
2133 private byte memoizedIsInitialized = -1;
2134 public final boolean isInitialized() {
2135 byte isInitialized = memoizedIsInitialized;
2136 if (isInitialized != -1) return isInitialized == 1;
2137
2138 if (!hasCallId()) {
2139 memoizedIsInitialized = 0;
2140 return false;
2141 }
2142 if (!hasStatus()) {
2143 memoizedIsInitialized = 0;
2144 return false;
2145 }
2146 memoizedIsInitialized = 1;
2147 return true;
2148 }
2149
2150 public void writeTo(com.google.protobuf.CodedOutputStream output)
2151 throws java.io.IOException {
2152 getSerializedSize();
2153 if (((bitField0_ & 0x00000001) == 0x00000001)) {
2154 output.writeUInt32(1, callId_);
2155 }
2156 if (((bitField0_ & 0x00000002) == 0x00000002)) {
2157 output.writeEnum(2, status_.getNumber());
2158 }
2159 if (((bitField0_ & 0x00000004) == 0x00000004)) {
2160 output.writeUInt32(3, serverIpcVersionNum_);
2161 }
2162 if (((bitField0_ & 0x00000008) == 0x00000008)) {
2163 output.writeBytes(4, getExceptionClassNameBytes());
2164 }
2165 if (((bitField0_ & 0x00000010) == 0x00000010)) {
2166 output.writeBytes(5, getErrorMsgBytes());
2167 }
2168 if (((bitField0_ & 0x00000020) == 0x00000020)) {
2169 output.writeEnum(6, errorDetail_.getNumber());
2170 }
2171 if (((bitField0_ & 0x00000040) == 0x00000040)) {
2172 output.writeBytes(7, clientId_);
2173 }
2174 if (((bitField0_ & 0x00000080) == 0x00000080)) {
2175 output.writeSInt32(8, retryCount_);
2176 }
2177 getUnknownFields().writeTo(output);
2178 }
2179
2180 private int memoizedSerializedSize = -1;
2181 public int getSerializedSize() {
2182 int size = memoizedSerializedSize;
2183 if (size != -1) return size;
2184
2185 size = 0;
2186 if (((bitField0_ & 0x00000001) == 0x00000001)) {
2187 size += com.google.protobuf.CodedOutputStream
2188 .computeUInt32Size(1, callId_);
2189 }
2190 if (((bitField0_ & 0x00000002) == 0x00000002)) {
2191 size += com.google.protobuf.CodedOutputStream
2192 .computeEnumSize(2, status_.getNumber());
2193 }
2194 if (((bitField0_ & 0x00000004) == 0x00000004)) {
2195 size += com.google.protobuf.CodedOutputStream
2196 .computeUInt32Size(3, serverIpcVersionNum_);
2197 }
2198 if (((bitField0_ & 0x00000008) == 0x00000008)) {
2199 size += com.google.protobuf.CodedOutputStream
2200 .computeBytesSize(4, getExceptionClassNameBytes());
2201 }
2202 if (((bitField0_ & 0x00000010) == 0x00000010)) {
2203 size += com.google.protobuf.CodedOutputStream
2204 .computeBytesSize(5, getErrorMsgBytes());
2205 }
2206 if (((bitField0_ & 0x00000020) == 0x00000020)) {
2207 size += com.google.protobuf.CodedOutputStream
2208 .computeEnumSize(6, errorDetail_.getNumber());
2209 }
2210 if (((bitField0_ & 0x00000040) == 0x00000040)) {
2211 size += com.google.protobuf.CodedOutputStream
2212 .computeBytesSize(7, clientId_);
2213 }
2214 if (((bitField0_ & 0x00000080) == 0x00000080)) {
2215 size += com.google.protobuf.CodedOutputStream
2216 .computeSInt32Size(8, retryCount_);
2217 }
2218 size += getUnknownFields().getSerializedSize();
2219 memoizedSerializedSize = size;
2220 return size;
2221 }
2222
2223 private static final long serialVersionUID = 0L;
2224 @java.lang.Override
2225 protected java.lang.Object writeReplace()
2226 throws java.io.ObjectStreamException {
2227 return super.writeReplace();
2228 }
2229
2230 @java.lang.Override
2231 public boolean equals(final java.lang.Object obj) {
2232 if (obj == this) {
2233 return true;
2234 }
2235 if (!(obj instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto)) {
2236 return super.equals(obj);
2237 }
2238 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto other = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto) obj;
2239
2240 boolean result = true;
2241 result = result && (hasCallId() == other.hasCallId());
2242 if (hasCallId()) {
2243 result = result && (getCallId()
2244 == other.getCallId());
2245 }
2246 result = result && (hasStatus() == other.hasStatus());
2247 if (hasStatus()) {
2248 result = result &&
2249 (getStatus() == other.getStatus());
2250 }
2251 result = result && (hasServerIpcVersionNum() == other.hasServerIpcVersionNum());
2252 if (hasServerIpcVersionNum()) {
2253 result = result && (getServerIpcVersionNum()
2254 == other.getServerIpcVersionNum());
2255 }
2256 result = result && (hasExceptionClassName() == other.hasExceptionClassName());
2257 if (hasExceptionClassName()) {
2258 result = result && getExceptionClassName()
2259 .equals(other.getExceptionClassName());
2260 }
2261 result = result && (hasErrorMsg() == other.hasErrorMsg());
2262 if (hasErrorMsg()) {
2263 result = result && getErrorMsg()
2264 .equals(other.getErrorMsg());
2265 }
2266 result = result && (hasErrorDetail() == other.hasErrorDetail());
2267 if (hasErrorDetail()) {
2268 result = result &&
2269 (getErrorDetail() == other.getErrorDetail());
2270 }
2271 result = result && (hasClientId() == other.hasClientId());
2272 if (hasClientId()) {
2273 result = result && getClientId()
2274 .equals(other.getClientId());
2275 }
2276 result = result && (hasRetryCount() == other.hasRetryCount());
2277 if (hasRetryCount()) {
2278 result = result && (getRetryCount()
2279 == other.getRetryCount());
2280 }
2281 result = result &&
2282 getUnknownFields().equals(other.getUnknownFields());
2283 return result;
2284 }
2285
2286 private int memoizedHashCode = 0;
2287 @java.lang.Override
2288 public int hashCode() {
2289 if (memoizedHashCode != 0) {
2290 return memoizedHashCode;
2291 }
2292 int hash = 41;
2293 hash = (19 * hash) + getDescriptorForType().hashCode();
2294 if (hasCallId()) {
2295 hash = (37 * hash) + CALLID_FIELD_NUMBER;
2296 hash = (53 * hash) + getCallId();
2297 }
2298 if (hasStatus()) {
2299 hash = (37 * hash) + STATUS_FIELD_NUMBER;
2300 hash = (53 * hash) + hashEnum(getStatus());
2301 }
2302 if (hasServerIpcVersionNum()) {
2303 hash = (37 * hash) + SERVERIPCVERSIONNUM_FIELD_NUMBER;
2304 hash = (53 * hash) + getServerIpcVersionNum();
2305 }
2306 if (hasExceptionClassName()) {
2307 hash = (37 * hash) + EXCEPTIONCLASSNAME_FIELD_NUMBER;
2308 hash = (53 * hash) + getExceptionClassName().hashCode();
2309 }
2310 if (hasErrorMsg()) {
2311 hash = (37 * hash) + ERRORMSG_FIELD_NUMBER;
2312 hash = (53 * hash) + getErrorMsg().hashCode();
2313 }
2314 if (hasErrorDetail()) {
2315 hash = (37 * hash) + ERRORDETAIL_FIELD_NUMBER;
2316 hash = (53 * hash) + hashEnum(getErrorDetail());
2317 }
2318 if (hasClientId()) {
2319 hash = (37 * hash) + CLIENTID_FIELD_NUMBER;
2320 hash = (53 * hash) + getClientId().hashCode();
2321 }
2322 if (hasRetryCount()) {
2323 hash = (37 * hash) + RETRYCOUNT_FIELD_NUMBER;
2324 hash = (53 * hash) + getRetryCount();
2325 }
2326 hash = (29 * hash) + getUnknownFields().hashCode();
2327 memoizedHashCode = hash;
2328 return hash;
2329 }
2330
2331 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(
2332 com.google.protobuf.ByteString data)
2333 throws com.google.protobuf.InvalidProtocolBufferException {
2334 return PARSER.parseFrom(data);
2335 }
2336 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(
2337 com.google.protobuf.ByteString data,
2338 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2339 throws com.google.protobuf.InvalidProtocolBufferException {
2340 return PARSER.parseFrom(data, extensionRegistry);
2341 }
2342 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(byte[] data)
2343 throws com.google.protobuf.InvalidProtocolBufferException {
2344 return PARSER.parseFrom(data);
2345 }
2346 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(
2347 byte[] data,
2348 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2349 throws com.google.protobuf.InvalidProtocolBufferException {
2350 return PARSER.parseFrom(data, extensionRegistry);
2351 }
2352 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(java.io.InputStream input)
2353 throws java.io.IOException {
2354 return PARSER.parseFrom(input);
2355 }
2356 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(
2357 java.io.InputStream input,
2358 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2359 throws java.io.IOException {
2360 return PARSER.parseFrom(input, extensionRegistry);
2361 }
2362 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseDelimitedFrom(java.io.InputStream input)
2363 throws java.io.IOException {
2364 return PARSER.parseDelimitedFrom(input);
2365 }
2366 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseDelimitedFrom(
2367 java.io.InputStream input,
2368 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2369 throws java.io.IOException {
2370 return PARSER.parseDelimitedFrom(input, extensionRegistry);
2371 }
2372 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(
2373 com.google.protobuf.CodedInputStream input)
2374 throws java.io.IOException {
2375 return PARSER.parseFrom(input);
2376 }
2377 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parseFrom(
2378 com.google.protobuf.CodedInputStream input,
2379 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2380 throws java.io.IOException {
2381 return PARSER.parseFrom(input, extensionRegistry);
2382 }
2383
2384 public static Builder newBuilder() { return Builder.create(); }
2385 public Builder newBuilderForType() { return newBuilder(); }
2386 public static Builder newBuilder(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto prototype) {
2387 return newBuilder().mergeFrom(prototype);
2388 }
2389 public Builder toBuilder() { return newBuilder(this); }
2390
2391 @java.lang.Override
2392 protected Builder newBuilderForType(
2393 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2394 Builder builder = new Builder(parent);
2395 return builder;
2396 }
2397 /**
2398 * Protobuf type {@code hadoop.common.RpcResponseHeaderProto}
2399 *
2400 * <pre>
2401 **
2402 * Rpc Response Header
2403 * +------------------------------------------------------------------+
2404 * | Rpc total response length in bytes (4 bytes int) |
2405 * | (sum of next two parts) |
2406 * +------------------------------------------------------------------+
2407 * | RpcResponseHeaderProto - serialized delimited ie has len |
2408 * +------------------------------------------------------------------+
2409 * | if request is successful: |
2410 * | - RpcResponse - The actual rpc response bytes follow |
2411 * | the response header |
2412 * | This response is serialized based on RpcKindProto |
2413 * | if request fails : |
2414 * | The rpc response header contains the necessary info |
2415 * +------------------------------------------------------------------+
2416 *
2417 * Note that rpc response header is also used when connection setup fails.
2418 * Ie the response looks like a rpc response with a fake callId.
2419 * </pre>
2420 */
2421 public static final class Builder extends
2422 com.google.protobuf.GeneratedMessage.Builder<Builder>
2423 implements org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProtoOrBuilder {
2424 public static final com.google.protobuf.Descriptors.Descriptor
2425 getDescriptor() {
2426 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcResponseHeaderProto_descriptor;
2427 }
2428
2429 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
2430 internalGetFieldAccessorTable() {
2431 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcResponseHeaderProto_fieldAccessorTable
2432 .ensureFieldAccessorsInitialized(
2433 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.Builder.class);
2434 }
2435
2436 // Construct using org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.newBuilder()
2437 private Builder() {
2438 maybeForceBuilderInitialization();
2439 }
2440
2441 private Builder(
2442 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
2443 super(parent);
2444 maybeForceBuilderInitialization();
2445 }
2446 private void maybeForceBuilderInitialization() {
2447 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
2448 }
2449 }
2450 private static Builder create() {
2451 return new Builder();
2452 }
2453
2454 public Builder clear() {
2455 super.clear();
2456 callId_ = 0;
2457 bitField0_ = (bitField0_ & ~0x00000001);
2458 status_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto.SUCCESS;
2459 bitField0_ = (bitField0_ & ~0x00000002);
2460 serverIpcVersionNum_ = 0;
2461 bitField0_ = (bitField0_ & ~0x00000004);
2462 exceptionClassName_ = "";
2463 bitField0_ = (bitField0_ & ~0x00000008);
2464 errorMsg_ = "";
2465 bitField0_ = (bitField0_ & ~0x00000010);
2466 errorDetail_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto.ERROR_APPLICATION;
2467 bitField0_ = (bitField0_ & ~0x00000020);
2468 clientId_ = com.google.protobuf.ByteString.EMPTY;
2469 bitField0_ = (bitField0_ & ~0x00000040);
2470 retryCount_ = -1;
2471 bitField0_ = (bitField0_ & ~0x00000080);
2472 return this;
2473 }
2474
2475 public Builder clone() {
2476 return create().mergeFrom(buildPartial());
2477 }
2478
2479 public com.google.protobuf.Descriptors.Descriptor
2480 getDescriptorForType() {
2481 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcResponseHeaderProto_descriptor;
2482 }
2483
2484 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto getDefaultInstanceForType() {
2485 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.getDefaultInstance();
2486 }
2487
2488 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto build() {
2489 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto result = buildPartial();
2490 if (!result.isInitialized()) {
2491 throw newUninitializedMessageException(result);
2492 }
2493 return result;
2494 }
2495
2496 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto buildPartial() {
2497 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto result = new org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto(this);
2498 int from_bitField0_ = bitField0_;
2499 int to_bitField0_ = 0;
2500 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
2501 to_bitField0_ |= 0x00000001;
2502 }
2503 result.callId_ = callId_;
2504 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
2505 to_bitField0_ |= 0x00000002;
2506 }
2507 result.status_ = status_;
2508 if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
2509 to_bitField0_ |= 0x00000004;
2510 }
2511 result.serverIpcVersionNum_ = serverIpcVersionNum_;
2512 if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
2513 to_bitField0_ |= 0x00000008;
2514 }
2515 result.exceptionClassName_ = exceptionClassName_;
2516 if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
2517 to_bitField0_ |= 0x00000010;
2518 }
2519 result.errorMsg_ = errorMsg_;
2520 if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
2521 to_bitField0_ |= 0x00000020;
2522 }
2523 result.errorDetail_ = errorDetail_;
2524 if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
2525 to_bitField0_ |= 0x00000040;
2526 }
2527 result.clientId_ = clientId_;
2528 if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
2529 to_bitField0_ |= 0x00000080;
2530 }
2531 result.retryCount_ = retryCount_;
2532 result.bitField0_ = to_bitField0_;
2533 onBuilt();
2534 return result;
2535 }
2536
2537 public Builder mergeFrom(com.google.protobuf.Message other) {
2538 if (other instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto) {
2539 return mergeFrom((org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto)other);
2540 } else {
2541 super.mergeFrom(other);
2542 return this;
2543 }
2544 }
2545
2546 public Builder mergeFrom(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto other) {
2547 if (other == org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.getDefaultInstance()) return this;
2548 if (other.hasCallId()) {
2549 setCallId(other.getCallId());
2550 }
2551 if (other.hasStatus()) {
2552 setStatus(other.getStatus());
2553 }
2554 if (other.hasServerIpcVersionNum()) {
2555 setServerIpcVersionNum(other.getServerIpcVersionNum());
2556 }
2557 if (other.hasExceptionClassName()) {
2558 bitField0_ |= 0x00000008;
2559 exceptionClassName_ = other.exceptionClassName_;
2560 onChanged();
2561 }
2562 if (other.hasErrorMsg()) {
2563 bitField0_ |= 0x00000010;
2564 errorMsg_ = other.errorMsg_;
2565 onChanged();
2566 }
2567 if (other.hasErrorDetail()) {
2568 setErrorDetail(other.getErrorDetail());
2569 }
2570 if (other.hasClientId()) {
2571 setClientId(other.getClientId());
2572 }
2573 if (other.hasRetryCount()) {
2574 setRetryCount(other.getRetryCount());
2575 }
2576 this.mergeUnknownFields(other.getUnknownFields());
2577 return this;
2578 }
2579
2580 public final boolean isInitialized() {
2581 if (!hasCallId()) {
2582
2583 return false;
2584 }
2585 if (!hasStatus()) {
2586
2587 return false;
2588 }
2589 return true;
2590 }
2591
2592 public Builder mergeFrom(
2593 com.google.protobuf.CodedInputStream input,
2594 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
2595 throws java.io.IOException {
2596 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto parsedMessage = null;
2597 try {
2598 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
2599 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
2600 parsedMessage = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto) e.getUnfinishedMessage();
2601 throw e;
2602 } finally {
2603 if (parsedMessage != null) {
2604 mergeFrom(parsedMessage);
2605 }
2606 }
2607 return this;
2608 }
2609 private int bitField0_;
2610
2611 // required uint32 callId = 1;
2612 private int callId_ ;
2613 /**
2614 * <code>required uint32 callId = 1;</code>
2615 *
2616 * <pre>
2617 * callId used in Request
2618 * </pre>
2619 */
2620 public boolean hasCallId() {
2621 return ((bitField0_ & 0x00000001) == 0x00000001);
2622 }
2623 /**
2624 * <code>required uint32 callId = 1;</code>
2625 *
2626 * <pre>
2627 * callId used in Request
2628 * </pre>
2629 */
2630 public int getCallId() {
2631 return callId_;
2632 }
2633 /**
2634 * <code>required uint32 callId = 1;</code>
2635 *
2636 * <pre>
2637 * callId used in Request
2638 * </pre>
2639 */
2640 public Builder setCallId(int value) {
2641 bitField0_ |= 0x00000001;
2642 callId_ = value;
2643 onChanged();
2644 return this;
2645 }
2646 /**
2647 * <code>required uint32 callId = 1;</code>
2648 *
2649 * <pre>
2650 * callId used in Request
2651 * </pre>
2652 */
2653 public Builder clearCallId() {
2654 bitField0_ = (bitField0_ & ~0x00000001);
2655 callId_ = 0;
2656 onChanged();
2657 return this;
2658 }
2659
2660 // required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;
2661 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto status_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto.SUCCESS;
2662 /**
2663 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
2664 */
2665 public boolean hasStatus() {
2666 return ((bitField0_ & 0x00000002) == 0x00000002);
2667 }
2668 /**
2669 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
2670 */
2671 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto getStatus() {
2672 return status_;
2673 }
2674 /**
2675 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
2676 */
2677 public Builder setStatus(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto value) {
2678 if (value == null) {
2679 throw new NullPointerException();
2680 }
2681 bitField0_ |= 0x00000002;
2682 status_ = value;
2683 onChanged();
2684 return this;
2685 }
2686 /**
2687 * <code>required .hadoop.common.RpcResponseHeaderProto.RpcStatusProto status = 2;</code>
2688 */
2689 public Builder clearStatus() {
2690 bitField0_ = (bitField0_ & ~0x00000002);
2691 status_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcStatusProto.SUCCESS;
2692 onChanged();
2693 return this;
2694 }
2695
2696 // optional uint32 serverIpcVersionNum = 3;
2697 private int serverIpcVersionNum_ ;
2698 /**
2699 * <code>optional uint32 serverIpcVersionNum = 3;</code>
2700 *
2701 * <pre>
2702 * Sent if success or fail
2703 * </pre>
2704 */
2705 public boolean hasServerIpcVersionNum() {
2706 return ((bitField0_ & 0x00000004) == 0x00000004);
2707 }
2708 /**
2709 * <code>optional uint32 serverIpcVersionNum = 3;</code>
2710 *
2711 * <pre>
2712 * Sent if success or fail
2713 * </pre>
2714 */
2715 public int getServerIpcVersionNum() {
2716 return serverIpcVersionNum_;
2717 }
2718 /**
2719 * <code>optional uint32 serverIpcVersionNum = 3;</code>
2720 *
2721 * <pre>
2722 * Sent if success or fail
2723 * </pre>
2724 */
2725 public Builder setServerIpcVersionNum(int value) {
2726 bitField0_ |= 0x00000004;
2727 serverIpcVersionNum_ = value;
2728 onChanged();
2729 return this;
2730 }
2731 /**
2732 * <code>optional uint32 serverIpcVersionNum = 3;</code>
2733 *
2734 * <pre>
2735 * Sent if success or fail
2736 * </pre>
2737 */
2738 public Builder clearServerIpcVersionNum() {
2739 bitField0_ = (bitField0_ & ~0x00000004);
2740 serverIpcVersionNum_ = 0;
2741 onChanged();
2742 return this;
2743 }
2744
2745 // optional string exceptionClassName = 4;
2746 private java.lang.Object exceptionClassName_ = "";
2747 /**
2748 * <code>optional string exceptionClassName = 4;</code>
2749 *
2750 * <pre>
2751 * if request fails
2752 * </pre>
2753 */
2754 public boolean hasExceptionClassName() {
2755 return ((bitField0_ & 0x00000008) == 0x00000008);
2756 }
2757 /**
2758 * <code>optional string exceptionClassName = 4;</code>
2759 *
2760 * <pre>
2761 * if request fails
2762 * </pre>
2763 */
2764 public java.lang.String getExceptionClassName() {
2765 java.lang.Object ref = exceptionClassName_;
2766 if (!(ref instanceof java.lang.String)) {
2767 java.lang.String s = ((com.google.protobuf.ByteString) ref)
2768 .toStringUtf8();
2769 exceptionClassName_ = s;
2770 return s;
2771 } else {
2772 return (java.lang.String) ref;
2773 }
2774 }
2775 /**
2776 * <code>optional string exceptionClassName = 4;</code>
2777 *
2778 * <pre>
2779 * if request fails
2780 * </pre>
2781 */
2782 public com.google.protobuf.ByteString
2783 getExceptionClassNameBytes() {
2784 java.lang.Object ref = exceptionClassName_;
2785 if (ref instanceof String) {
2786 com.google.protobuf.ByteString b =
2787 com.google.protobuf.ByteString.copyFromUtf8(
2788 (java.lang.String) ref);
2789 exceptionClassName_ = b;
2790 return b;
2791 } else {
2792 return (com.google.protobuf.ByteString) ref;
2793 }
2794 }
2795 /**
2796 * <code>optional string exceptionClassName = 4;</code>
2797 *
2798 * <pre>
2799 * if request fails
2800 * </pre>
2801 */
2802 public Builder setExceptionClassName(
2803 java.lang.String value) {
2804 if (value == null) {
2805 throw new NullPointerException();
2806 }
2807 bitField0_ |= 0x00000008;
2808 exceptionClassName_ = value;
2809 onChanged();
2810 return this;
2811 }
2812 /**
2813 * <code>optional string exceptionClassName = 4;</code>
2814 *
2815 * <pre>
2816 * if request fails
2817 * </pre>
2818 */
2819 public Builder clearExceptionClassName() {
2820 bitField0_ = (bitField0_ & ~0x00000008);
2821 exceptionClassName_ = getDefaultInstance().getExceptionClassName();
2822 onChanged();
2823 return this;
2824 }
2825 /**
2826 * <code>optional string exceptionClassName = 4;</code>
2827 *
2828 * <pre>
2829 * if request fails
2830 * </pre>
2831 */
2832 public Builder setExceptionClassNameBytes(
2833 com.google.protobuf.ByteString value) {
2834 if (value == null) {
2835 throw new NullPointerException();
2836 }
2837 bitField0_ |= 0x00000008;
2838 exceptionClassName_ = value;
2839 onChanged();
2840 return this;
2841 }
2842
2843 // optional string errorMsg = 5;
2844 private java.lang.Object errorMsg_ = "";
2845 /**
2846 * <code>optional string errorMsg = 5;</code>
2847 *
2848 * <pre>
2849 * if request fails, often contains strack trace
2850 * </pre>
2851 */
2852 public boolean hasErrorMsg() {
2853 return ((bitField0_ & 0x00000010) == 0x00000010);
2854 }
2855 /**
2856 * <code>optional string errorMsg = 5;</code>
2857 *
2858 * <pre>
2859 * if request fails, often contains strack trace
2860 * </pre>
2861 */
2862 public java.lang.String getErrorMsg() {
2863 java.lang.Object ref = errorMsg_;
2864 if (!(ref instanceof java.lang.String)) {
2865 java.lang.String s = ((com.google.protobuf.ByteString) ref)
2866 .toStringUtf8();
2867 errorMsg_ = s;
2868 return s;
2869 } else {
2870 return (java.lang.String) ref;
2871 }
2872 }
2873 /**
2874 * <code>optional string errorMsg = 5;</code>
2875 *
2876 * <pre>
2877 * if request fails, often contains strack trace
2878 * </pre>
2879 */
2880 public com.google.protobuf.ByteString
2881 getErrorMsgBytes() {
2882 java.lang.Object ref = errorMsg_;
2883 if (ref instanceof String) {
2884 com.google.protobuf.ByteString b =
2885 com.google.protobuf.ByteString.copyFromUtf8(
2886 (java.lang.String) ref);
2887 errorMsg_ = b;
2888 return b;
2889 } else {
2890 return (com.google.protobuf.ByteString) ref;
2891 }
2892 }
2893 /**
2894 * <code>optional string errorMsg = 5;</code>
2895 *
2896 * <pre>
2897 * if request fails, often contains strack trace
2898 * </pre>
2899 */
2900 public Builder setErrorMsg(
2901 java.lang.String value) {
2902 if (value == null) {
2903 throw new NullPointerException();
2904 }
2905 bitField0_ |= 0x00000010;
2906 errorMsg_ = value;
2907 onChanged();
2908 return this;
2909 }
2910 /**
2911 * <code>optional string errorMsg = 5;</code>
2912 *
2913 * <pre>
2914 * if request fails, often contains strack trace
2915 * </pre>
2916 */
2917 public Builder clearErrorMsg() {
2918 bitField0_ = (bitField0_ & ~0x00000010);
2919 errorMsg_ = getDefaultInstance().getErrorMsg();
2920 onChanged();
2921 return this;
2922 }
2923 /**
2924 * <code>optional string errorMsg = 5;</code>
2925 *
2926 * <pre>
2927 * if request fails, often contains strack trace
2928 * </pre>
2929 */
2930 public Builder setErrorMsgBytes(
2931 com.google.protobuf.ByteString value) {
2932 if (value == null) {
2933 throw new NullPointerException();
2934 }
2935 bitField0_ |= 0x00000010;
2936 errorMsg_ = value;
2937 onChanged();
2938 return this;
2939 }
2940
2941 // optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;
2942 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto.ERROR_APPLICATION;
2943 /**
2944 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
2945 *
2946 * <pre>
2947 * in case of error
2948 * </pre>
2949 */
2950 public boolean hasErrorDetail() {
2951 return ((bitField0_ & 0x00000020) == 0x00000020);
2952 }
2953 /**
2954 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
2955 *
2956 * <pre>
2957 * in case of error
2958 * </pre>
2959 */
2960 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto getErrorDetail() {
2961 return errorDetail_;
2962 }
2963 /**
2964 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
2965 *
2966 * <pre>
2967 * in case of error
2968 * </pre>
2969 */
2970 public Builder setErrorDetail(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto value) {
2971 if (value == null) {
2972 throw new NullPointerException();
2973 }
2974 bitField0_ |= 0x00000020;
2975 errorDetail_ = value;
2976 onChanged();
2977 return this;
2978 }
2979 /**
2980 * <code>optional .hadoop.common.RpcResponseHeaderProto.RpcErrorCodeProto errorDetail = 6;</code>
2981 *
2982 * <pre>
2983 * in case of error
2984 * </pre>
2985 */
2986 public Builder clearErrorDetail() {
2987 bitField0_ = (bitField0_ & ~0x00000020);
2988 errorDetail_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcResponseHeaderProto.RpcErrorCodeProto.ERROR_APPLICATION;
2989 onChanged();
2990 return this;
2991 }
2992
2993 // optional bytes clientId = 7;
2994 private com.google.protobuf.ByteString clientId_ = com.google.protobuf.ByteString.EMPTY;
2995 /**
2996 * <code>optional bytes clientId = 7;</code>
2997 *
2998 * <pre>
2999 * Globally unique client ID
3000 * </pre>
3001 */
3002 public boolean hasClientId() {
3003 return ((bitField0_ & 0x00000040) == 0x00000040);
3004 }
3005 /**
3006 * <code>optional bytes clientId = 7;</code>
3007 *
3008 * <pre>
3009 * Globally unique client ID
3010 * </pre>
3011 */
3012 public com.google.protobuf.ByteString getClientId() {
3013 return clientId_;
3014 }
3015 /**
3016 * <code>optional bytes clientId = 7;</code>
3017 *
3018 * <pre>
3019 * Globally unique client ID
3020 * </pre>
3021 */
3022 public Builder setClientId(com.google.protobuf.ByteString value) {
3023 if (value == null) {
3024 throw new NullPointerException();
3025 }
3026 bitField0_ |= 0x00000040;
3027 clientId_ = value;
3028 onChanged();
3029 return this;
3030 }
3031 /**
3032 * <code>optional bytes clientId = 7;</code>
3033 *
3034 * <pre>
3035 * Globally unique client ID
3036 * </pre>
3037 */
3038 public Builder clearClientId() {
3039 bitField0_ = (bitField0_ & ~0x00000040);
3040 clientId_ = getDefaultInstance().getClientId();
3041 onChanged();
3042 return this;
3043 }
3044
3045 // optional sint32 retryCount = 8 [default = -1];
3046 private int retryCount_ = -1;
3047 /**
3048 * <code>optional sint32 retryCount = 8 [default = -1];</code>
3049 */
3050 public boolean hasRetryCount() {
3051 return ((bitField0_ & 0x00000080) == 0x00000080);
3052 }
3053 /**
3054 * <code>optional sint32 retryCount = 8 [default = -1];</code>
3055 */
3056 public int getRetryCount() {
3057 return retryCount_;
3058 }
3059 /**
3060 * <code>optional sint32 retryCount = 8 [default = -1];</code>
3061 */
3062 public Builder setRetryCount(int value) {
3063 bitField0_ |= 0x00000080;
3064 retryCount_ = value;
3065 onChanged();
3066 return this;
3067 }
3068 /**
3069 * <code>optional sint32 retryCount = 8 [default = -1];</code>
3070 */
3071 public Builder clearRetryCount() {
3072 bitField0_ = (bitField0_ & ~0x00000080);
3073 retryCount_ = -1;
3074 onChanged();
3075 return this;
3076 }
3077
3078 // @@protoc_insertion_point(builder_scope:hadoop.common.RpcResponseHeaderProto)
3079 }
3080
3081 static {
3082 defaultInstance = new RpcResponseHeaderProto(true);
3083 defaultInstance.initFields();
3084 }
3085
3086 // @@protoc_insertion_point(class_scope:hadoop.common.RpcResponseHeaderProto)
3087 }
3088
3089 public interface RpcSaslProtoOrBuilder
3090 extends com.google.protobuf.MessageOrBuilder {
3091
3092 // optional uint32 version = 1;
3093 /**
3094 * <code>optional uint32 version = 1;</code>
3095 */
3096 boolean hasVersion();
3097 /**
3098 * <code>optional uint32 version = 1;</code>
3099 */
3100 int getVersion();
3101
3102 // required .hadoop.common.RpcSaslProto.SaslState state = 2;
3103 /**
3104 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
3105 */
3106 boolean hasState();
3107 /**
3108 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
3109 */
3110 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState getState();
3111
3112 // optional bytes token = 3;
3113 /**
3114 * <code>optional bytes token = 3;</code>
3115 */
3116 boolean hasToken();
3117 /**
3118 * <code>optional bytes token = 3;</code>
3119 */
3120 com.google.protobuf.ByteString getToken();
3121
3122 // repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;
3123 /**
3124 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
3125 */
3126 java.util.List<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth>
3127 getAuthsList();
3128 /**
3129 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
3130 */
3131 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth getAuths(int index);
3132 /**
3133 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
3134 */
3135 int getAuthsCount();
3136 /**
3137 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
3138 */
3139 java.util.List<? extends org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder>
3140 getAuthsOrBuilderList();
3141 /**
3142 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
3143 */
3144 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder getAuthsOrBuilder(
3145 int index);
3146 }
3147 /**
3148 * Protobuf type {@code hadoop.common.RpcSaslProto}
3149 */
3150 public static final class RpcSaslProto extends
3151 com.google.protobuf.GeneratedMessage
3152 implements RpcSaslProtoOrBuilder {
3153 // Use RpcSaslProto.newBuilder() to construct.
3154 private RpcSaslProto(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3155 super(builder);
3156 this.unknownFields = builder.getUnknownFields();
3157 }
3158 private RpcSaslProto(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3159
3160 private static final RpcSaslProto defaultInstance;
3161 public static RpcSaslProto getDefaultInstance() {
3162 return defaultInstance;
3163 }
3164
3165 public RpcSaslProto getDefaultInstanceForType() {
3166 return defaultInstance;
3167 }
3168
3169 private final com.google.protobuf.UnknownFieldSet unknownFields;
3170 @java.lang.Override
3171 public final com.google.protobuf.UnknownFieldSet
3172 getUnknownFields() {
3173 return this.unknownFields;
3174 }
3175 private RpcSaslProto(
3176 com.google.protobuf.CodedInputStream input,
3177 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3178 throws com.google.protobuf.InvalidProtocolBufferException {
3179 initFields();
3180 int mutable_bitField0_ = 0;
3181 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3182 com.google.protobuf.UnknownFieldSet.newBuilder();
3183 try {
3184 boolean done = false;
3185 while (!done) {
3186 int tag = input.readTag();
3187 switch (tag) {
3188 case 0:
3189 done = true;
3190 break;
3191 default: {
3192 if (!parseUnknownField(input, unknownFields,
3193 extensionRegistry, tag)) {
3194 done = true;
3195 }
3196 break;
3197 }
3198 case 8: {
3199 bitField0_ |= 0x00000001;
3200 version_ = input.readUInt32();
3201 break;
3202 }
3203 case 16: {
3204 int rawValue = input.readEnum();
3205 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState value = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState.valueOf(rawValue);
3206 if (value == null) {
3207 unknownFields.mergeVarintField(2, rawValue);
3208 } else {
3209 bitField0_ |= 0x00000002;
3210 state_ = value;
3211 }
3212 break;
3213 }
3214 case 26: {
3215 bitField0_ |= 0x00000004;
3216 token_ = input.readBytes();
3217 break;
3218 }
3219 case 34: {
3220 if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
3221 auths_ = new java.util.ArrayList<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth>();
3222 mutable_bitField0_ |= 0x00000008;
3223 }
3224 auths_.add(input.readMessage(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.PARSER, extensionRegistry));
3225 break;
3226 }
3227 }
3228 }
3229 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3230 throw e.setUnfinishedMessage(this);
3231 } catch (java.io.IOException e) {
3232 throw new com.google.protobuf.InvalidProtocolBufferException(
3233 e.getMessage()).setUnfinishedMessage(this);
3234 } finally {
3235 if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
3236 auths_ = java.util.Collections.unmodifiableList(auths_);
3237 }
3238 this.unknownFields = unknownFields.build();
3239 makeExtensionsImmutable();
3240 }
3241 }
3242 public static final com.google.protobuf.Descriptors.Descriptor
3243 getDescriptor() {
3244 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_descriptor;
3245 }
3246
3247 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3248 internalGetFieldAccessorTable() {
3249 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_fieldAccessorTable
3250 .ensureFieldAccessorsInitialized(
3251 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.Builder.class);
3252 }
3253
3254 public static com.google.protobuf.Parser<RpcSaslProto> PARSER =
3255 new com.google.protobuf.AbstractParser<RpcSaslProto>() {
3256 public RpcSaslProto parsePartialFrom(
3257 com.google.protobuf.CodedInputStream input,
3258 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3259 throws com.google.protobuf.InvalidProtocolBufferException {
3260 return new RpcSaslProto(input, extensionRegistry);
3261 }
3262 };
3263
3264 @java.lang.Override
3265 public com.google.protobuf.Parser<RpcSaslProto> getParserForType() {
3266 return PARSER;
3267 }
3268
3269 /**
3270 * Protobuf enum {@code hadoop.common.RpcSaslProto.SaslState}
3271 */
3272 public enum SaslState
3273 implements com.google.protobuf.ProtocolMessageEnum {
3274 /**
3275 * <code>SUCCESS = 0;</code>
3276 */
3277 SUCCESS(0, 0),
3278 /**
3279 * <code>NEGOTIATE = 1;</code>
3280 */
3281 NEGOTIATE(1, 1),
3282 /**
3283 * <code>INITIATE = 2;</code>
3284 */
3285 INITIATE(2, 2),
3286 /**
3287 * <code>CHALLENGE = 3;</code>
3288 */
3289 CHALLENGE(3, 3),
3290 /**
3291 * <code>RESPONSE = 4;</code>
3292 */
3293 RESPONSE(4, 4),
3294 /**
3295 * <code>WRAP = 5;</code>
3296 */
3297 WRAP(5, 5),
3298 ;
3299
3300 /**
3301 * <code>SUCCESS = 0;</code>
3302 */
3303 public static final int SUCCESS_VALUE = 0;
3304 /**
3305 * <code>NEGOTIATE = 1;</code>
3306 */
3307 public static final int NEGOTIATE_VALUE = 1;
3308 /**
3309 * <code>INITIATE = 2;</code>
3310 */
3311 public static final int INITIATE_VALUE = 2;
3312 /**
3313 * <code>CHALLENGE = 3;</code>
3314 */
3315 public static final int CHALLENGE_VALUE = 3;
3316 /**
3317 * <code>RESPONSE = 4;</code>
3318 */
3319 public static final int RESPONSE_VALUE = 4;
3320 /**
3321 * <code>WRAP = 5;</code>
3322 */
3323 public static final int WRAP_VALUE = 5;
3324
3325
3326 public final int getNumber() { return value; }
3327
3328 public static SaslState valueOf(int value) {
3329 switch (value) {
3330 case 0: return SUCCESS;
3331 case 1: return NEGOTIATE;
3332 case 2: return INITIATE;
3333 case 3: return CHALLENGE;
3334 case 4: return RESPONSE;
3335 case 5: return WRAP;
3336 default: return null;
3337 }
3338 }
3339
3340 public static com.google.protobuf.Internal.EnumLiteMap<SaslState>
3341 internalGetValueMap() {
3342 return internalValueMap;
3343 }
3344 private static com.google.protobuf.Internal.EnumLiteMap<SaslState>
3345 internalValueMap =
3346 new com.google.protobuf.Internal.EnumLiteMap<SaslState>() {
3347 public SaslState findValueByNumber(int number) {
3348 return SaslState.valueOf(number);
3349 }
3350 };
3351
3352 public final com.google.protobuf.Descriptors.EnumValueDescriptor
3353 getValueDescriptor() {
3354 return getDescriptor().getValues().get(index);
3355 }
3356 public final com.google.protobuf.Descriptors.EnumDescriptor
3357 getDescriptorForType() {
3358 return getDescriptor();
3359 }
3360 public static final com.google.protobuf.Descriptors.EnumDescriptor
3361 getDescriptor() {
3362 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.getDescriptor().getEnumTypes().get(0);
3363 }
3364
3365 private static final SaslState[] VALUES = values();
3366
3367 public static SaslState valueOf(
3368 com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
3369 if (desc.getType() != getDescriptor()) {
3370 throw new java.lang.IllegalArgumentException(
3371 "EnumValueDescriptor is not for this type.");
3372 }
3373 return VALUES[desc.getIndex()];
3374 }
3375
3376 private final int index;
3377 private final int value;
3378
3379 private SaslState(int index, int value) {
3380 this.index = index;
3381 this.value = value;
3382 }
3383
3384 // @@protoc_insertion_point(enum_scope:hadoop.common.RpcSaslProto.SaslState)
3385 }
3386
3387 public interface SaslAuthOrBuilder
3388 extends com.google.protobuf.MessageOrBuilder {
3389
3390 // required string method = 1;
3391 /**
3392 * <code>required string method = 1;</code>
3393 */
3394 boolean hasMethod();
3395 /**
3396 * <code>required string method = 1;</code>
3397 */
3398 java.lang.String getMethod();
3399 /**
3400 * <code>required string method = 1;</code>
3401 */
3402 com.google.protobuf.ByteString
3403 getMethodBytes();
3404
3405 // required string mechanism = 2;
3406 /**
3407 * <code>required string mechanism = 2;</code>
3408 */
3409 boolean hasMechanism();
3410 /**
3411 * <code>required string mechanism = 2;</code>
3412 */
3413 java.lang.String getMechanism();
3414 /**
3415 * <code>required string mechanism = 2;</code>
3416 */
3417 com.google.protobuf.ByteString
3418 getMechanismBytes();
3419
3420 // optional string protocol = 3;
3421 /**
3422 * <code>optional string protocol = 3;</code>
3423 */
3424 boolean hasProtocol();
3425 /**
3426 * <code>optional string protocol = 3;</code>
3427 */
3428 java.lang.String getProtocol();
3429 /**
3430 * <code>optional string protocol = 3;</code>
3431 */
3432 com.google.protobuf.ByteString
3433 getProtocolBytes();
3434
3435 // optional string serverId = 4;
3436 /**
3437 * <code>optional string serverId = 4;</code>
3438 */
3439 boolean hasServerId();
3440 /**
3441 * <code>optional string serverId = 4;</code>
3442 */
3443 java.lang.String getServerId();
3444 /**
3445 * <code>optional string serverId = 4;</code>
3446 */
3447 com.google.protobuf.ByteString
3448 getServerIdBytes();
3449
3450 // optional bytes challenge = 5;
3451 /**
3452 * <code>optional bytes challenge = 5;</code>
3453 */
3454 boolean hasChallenge();
3455 /**
3456 * <code>optional bytes challenge = 5;</code>
3457 */
3458 com.google.protobuf.ByteString getChallenge();
3459 }
3460 /**
3461 * Protobuf type {@code hadoop.common.RpcSaslProto.SaslAuth}
3462 */
3463 public static final class SaslAuth extends
3464 com.google.protobuf.GeneratedMessage
3465 implements SaslAuthOrBuilder {
3466 // Use SaslAuth.newBuilder() to construct.
3467 private SaslAuth(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
3468 super(builder);
3469 this.unknownFields = builder.getUnknownFields();
3470 }
3471 private SaslAuth(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
3472
3473 private static final SaslAuth defaultInstance;
3474 public static SaslAuth getDefaultInstance() {
3475 return defaultInstance;
3476 }
3477
3478 public SaslAuth getDefaultInstanceForType() {
3479 return defaultInstance;
3480 }
3481
3482 private final com.google.protobuf.UnknownFieldSet unknownFields;
3483 @java.lang.Override
3484 public final com.google.protobuf.UnknownFieldSet
3485 getUnknownFields() {
3486 return this.unknownFields;
3487 }
3488 private SaslAuth(
3489 com.google.protobuf.CodedInputStream input,
3490 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3491 throws com.google.protobuf.InvalidProtocolBufferException {
3492 initFields();
3493 int mutable_bitField0_ = 0;
3494 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
3495 com.google.protobuf.UnknownFieldSet.newBuilder();
3496 try {
3497 boolean done = false;
3498 while (!done) {
3499 int tag = input.readTag();
3500 switch (tag) {
3501 case 0:
3502 done = true;
3503 break;
3504 default: {
3505 if (!parseUnknownField(input, unknownFields,
3506 extensionRegistry, tag)) {
3507 done = true;
3508 }
3509 break;
3510 }
3511 case 10: {
3512 bitField0_ |= 0x00000001;
3513 method_ = input.readBytes();
3514 break;
3515 }
3516 case 18: {
3517 bitField0_ |= 0x00000002;
3518 mechanism_ = input.readBytes();
3519 break;
3520 }
3521 case 26: {
3522 bitField0_ |= 0x00000004;
3523 protocol_ = input.readBytes();
3524 break;
3525 }
3526 case 34: {
3527 bitField0_ |= 0x00000008;
3528 serverId_ = input.readBytes();
3529 break;
3530 }
3531 case 42: {
3532 bitField0_ |= 0x00000010;
3533 challenge_ = input.readBytes();
3534 break;
3535 }
3536 }
3537 }
3538 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
3539 throw e.setUnfinishedMessage(this);
3540 } catch (java.io.IOException e) {
3541 throw new com.google.protobuf.InvalidProtocolBufferException(
3542 e.getMessage()).setUnfinishedMessage(this);
3543 } finally {
3544 this.unknownFields = unknownFields.build();
3545 makeExtensionsImmutable();
3546 }
3547 }
3548 public static final com.google.protobuf.Descriptors.Descriptor
3549 getDescriptor() {
3550 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_SaslAuth_descriptor;
3551 }
3552
3553 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3554 internalGetFieldAccessorTable() {
3555 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_SaslAuth_fieldAccessorTable
3556 .ensureFieldAccessorsInitialized(
3557 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder.class);
3558 }
3559
3560 public static com.google.protobuf.Parser<SaslAuth> PARSER =
3561 new com.google.protobuf.AbstractParser<SaslAuth>() {
3562 public SaslAuth parsePartialFrom(
3563 com.google.protobuf.CodedInputStream input,
3564 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3565 throws com.google.protobuf.InvalidProtocolBufferException {
3566 return new SaslAuth(input, extensionRegistry);
3567 }
3568 };
3569
3570 @java.lang.Override
3571 public com.google.protobuf.Parser<SaslAuth> getParserForType() {
3572 return PARSER;
3573 }
3574
3575 private int bitField0_;
3576 // required string method = 1;
3577 public static final int METHOD_FIELD_NUMBER = 1;
3578 private java.lang.Object method_;
3579 /**
3580 * <code>required string method = 1;</code>
3581 */
3582 public boolean hasMethod() {
3583 return ((bitField0_ & 0x00000001) == 0x00000001);
3584 }
3585 /**
3586 * <code>required string method = 1;</code>
3587 */
3588 public java.lang.String getMethod() {
3589 java.lang.Object ref = method_;
3590 if (ref instanceof java.lang.String) {
3591 return (java.lang.String) ref;
3592 } else {
3593 com.google.protobuf.ByteString bs =
3594 (com.google.protobuf.ByteString) ref;
3595 java.lang.String s = bs.toStringUtf8();
3596 if (bs.isValidUtf8()) {
3597 method_ = s;
3598 }
3599 return s;
3600 }
3601 }
3602 /**
3603 * <code>required string method = 1;</code>
3604 */
3605 public com.google.protobuf.ByteString
3606 getMethodBytes() {
3607 java.lang.Object ref = method_;
3608 if (ref instanceof java.lang.String) {
3609 com.google.protobuf.ByteString b =
3610 com.google.protobuf.ByteString.copyFromUtf8(
3611 (java.lang.String) ref);
3612 method_ = b;
3613 return b;
3614 } else {
3615 return (com.google.protobuf.ByteString) ref;
3616 }
3617 }
3618
3619 // required string mechanism = 2;
3620 public static final int MECHANISM_FIELD_NUMBER = 2;
3621 private java.lang.Object mechanism_;
3622 /**
3623 * <code>required string mechanism = 2;</code>
3624 */
3625 public boolean hasMechanism() {
3626 return ((bitField0_ & 0x00000002) == 0x00000002);
3627 }
3628 /**
3629 * <code>required string mechanism = 2;</code>
3630 */
3631 public java.lang.String getMechanism() {
3632 java.lang.Object ref = mechanism_;
3633 if (ref instanceof java.lang.String) {
3634 return (java.lang.String) ref;
3635 } else {
3636 com.google.protobuf.ByteString bs =
3637 (com.google.protobuf.ByteString) ref;
3638 java.lang.String s = bs.toStringUtf8();
3639 if (bs.isValidUtf8()) {
3640 mechanism_ = s;
3641 }
3642 return s;
3643 }
3644 }
3645 /**
3646 * <code>required string mechanism = 2;</code>
3647 */
3648 public com.google.protobuf.ByteString
3649 getMechanismBytes() {
3650 java.lang.Object ref = mechanism_;
3651 if (ref instanceof java.lang.String) {
3652 com.google.protobuf.ByteString b =
3653 com.google.protobuf.ByteString.copyFromUtf8(
3654 (java.lang.String) ref);
3655 mechanism_ = b;
3656 return b;
3657 } else {
3658 return (com.google.protobuf.ByteString) ref;
3659 }
3660 }
3661
3662 // optional string protocol = 3;
3663 public static final int PROTOCOL_FIELD_NUMBER = 3;
3664 private java.lang.Object protocol_;
3665 /**
3666 * <code>optional string protocol = 3;</code>
3667 */
3668 public boolean hasProtocol() {
3669 return ((bitField0_ & 0x00000004) == 0x00000004);
3670 }
3671 /**
3672 * <code>optional string protocol = 3;</code>
3673 */
3674 public java.lang.String getProtocol() {
3675 java.lang.Object ref = protocol_;
3676 if (ref instanceof java.lang.String) {
3677 return (java.lang.String) ref;
3678 } else {
3679 com.google.protobuf.ByteString bs =
3680 (com.google.protobuf.ByteString) ref;
3681 java.lang.String s = bs.toStringUtf8();
3682 if (bs.isValidUtf8()) {
3683 protocol_ = s;
3684 }
3685 return s;
3686 }
3687 }
3688 /**
3689 * <code>optional string protocol = 3;</code>
3690 */
3691 public com.google.protobuf.ByteString
3692 getProtocolBytes() {
3693 java.lang.Object ref = protocol_;
3694 if (ref instanceof java.lang.String) {
3695 com.google.protobuf.ByteString b =
3696 com.google.protobuf.ByteString.copyFromUtf8(
3697 (java.lang.String) ref);
3698 protocol_ = b;
3699 return b;
3700 } else {
3701 return (com.google.protobuf.ByteString) ref;
3702 }
3703 }
3704
3705 // optional string serverId = 4;
3706 public static final int SERVERID_FIELD_NUMBER = 4;
3707 private java.lang.Object serverId_;
3708 /**
3709 * <code>optional string serverId = 4;</code>
3710 */
3711 public boolean hasServerId() {
3712 return ((bitField0_ & 0x00000008) == 0x00000008);
3713 }
3714 /**
3715 * <code>optional string serverId = 4;</code>
3716 */
3717 public java.lang.String getServerId() {
3718 java.lang.Object ref = serverId_;
3719 if (ref instanceof java.lang.String) {
3720 return (java.lang.String) ref;
3721 } else {
3722 com.google.protobuf.ByteString bs =
3723 (com.google.protobuf.ByteString) ref;
3724 java.lang.String s = bs.toStringUtf8();
3725 if (bs.isValidUtf8()) {
3726 serverId_ = s;
3727 }
3728 return s;
3729 }
3730 }
3731 /**
3732 * <code>optional string serverId = 4;</code>
3733 */
3734 public com.google.protobuf.ByteString
3735 getServerIdBytes() {
3736 java.lang.Object ref = serverId_;
3737 if (ref instanceof java.lang.String) {
3738 com.google.protobuf.ByteString b =
3739 com.google.protobuf.ByteString.copyFromUtf8(
3740 (java.lang.String) ref);
3741 serverId_ = b;
3742 return b;
3743 } else {
3744 return (com.google.protobuf.ByteString) ref;
3745 }
3746 }
3747
3748 // optional bytes challenge = 5;
3749 public static final int CHALLENGE_FIELD_NUMBER = 5;
3750 private com.google.protobuf.ByteString challenge_;
3751 /**
3752 * <code>optional bytes challenge = 5;</code>
3753 */
3754 public boolean hasChallenge() {
3755 return ((bitField0_ & 0x00000010) == 0x00000010);
3756 }
3757 /**
3758 * <code>optional bytes challenge = 5;</code>
3759 */
3760 public com.google.protobuf.ByteString getChallenge() {
3761 return challenge_;
3762 }
3763
3764 private void initFields() {
3765 method_ = "";
3766 mechanism_ = "";
3767 protocol_ = "";
3768 serverId_ = "";
3769 challenge_ = com.google.protobuf.ByteString.EMPTY;
3770 }
3771 private byte memoizedIsInitialized = -1;
3772 public final boolean isInitialized() {
3773 byte isInitialized = memoizedIsInitialized;
3774 if (isInitialized != -1) return isInitialized == 1;
3775
3776 if (!hasMethod()) {
3777 memoizedIsInitialized = 0;
3778 return false;
3779 }
3780 if (!hasMechanism()) {
3781 memoizedIsInitialized = 0;
3782 return false;
3783 }
3784 memoizedIsInitialized = 1;
3785 return true;
3786 }
3787
3788 public void writeTo(com.google.protobuf.CodedOutputStream output)
3789 throws java.io.IOException {
3790 getSerializedSize();
3791 if (((bitField0_ & 0x00000001) == 0x00000001)) {
3792 output.writeBytes(1, getMethodBytes());
3793 }
3794 if (((bitField0_ & 0x00000002) == 0x00000002)) {
3795 output.writeBytes(2, getMechanismBytes());
3796 }
3797 if (((bitField0_ & 0x00000004) == 0x00000004)) {
3798 output.writeBytes(3, getProtocolBytes());
3799 }
3800 if (((bitField0_ & 0x00000008) == 0x00000008)) {
3801 output.writeBytes(4, getServerIdBytes());
3802 }
3803 if (((bitField0_ & 0x00000010) == 0x00000010)) {
3804 output.writeBytes(5, challenge_);
3805 }
3806 getUnknownFields().writeTo(output);
3807 }
3808
3809 private int memoizedSerializedSize = -1;
3810 public int getSerializedSize() {
3811 int size = memoizedSerializedSize;
3812 if (size != -1) return size;
3813
3814 size = 0;
3815 if (((bitField0_ & 0x00000001) == 0x00000001)) {
3816 size += com.google.protobuf.CodedOutputStream
3817 .computeBytesSize(1, getMethodBytes());
3818 }
3819 if (((bitField0_ & 0x00000002) == 0x00000002)) {
3820 size += com.google.protobuf.CodedOutputStream
3821 .computeBytesSize(2, getMechanismBytes());
3822 }
3823 if (((bitField0_ & 0x00000004) == 0x00000004)) {
3824 size += com.google.protobuf.CodedOutputStream
3825 .computeBytesSize(3, getProtocolBytes());
3826 }
3827 if (((bitField0_ & 0x00000008) == 0x00000008)) {
3828 size += com.google.protobuf.CodedOutputStream
3829 .computeBytesSize(4, getServerIdBytes());
3830 }
3831 if (((bitField0_ & 0x00000010) == 0x00000010)) {
3832 size += com.google.protobuf.CodedOutputStream
3833 .computeBytesSize(5, challenge_);
3834 }
3835 size += getUnknownFields().getSerializedSize();
3836 memoizedSerializedSize = size;
3837 return size;
3838 }
3839
3840 private static final long serialVersionUID = 0L;
3841 @java.lang.Override
3842 protected java.lang.Object writeReplace()
3843 throws java.io.ObjectStreamException {
3844 return super.writeReplace();
3845 }
3846
3847 @java.lang.Override
3848 public boolean equals(final java.lang.Object obj) {
3849 if (obj == this) {
3850 return true;
3851 }
3852 if (!(obj instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth)) {
3853 return super.equals(obj);
3854 }
3855 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth other = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth) obj;
3856
3857 boolean result = true;
3858 result = result && (hasMethod() == other.hasMethod());
3859 if (hasMethod()) {
3860 result = result && getMethod()
3861 .equals(other.getMethod());
3862 }
3863 result = result && (hasMechanism() == other.hasMechanism());
3864 if (hasMechanism()) {
3865 result = result && getMechanism()
3866 .equals(other.getMechanism());
3867 }
3868 result = result && (hasProtocol() == other.hasProtocol());
3869 if (hasProtocol()) {
3870 result = result && getProtocol()
3871 .equals(other.getProtocol());
3872 }
3873 result = result && (hasServerId() == other.hasServerId());
3874 if (hasServerId()) {
3875 result = result && getServerId()
3876 .equals(other.getServerId());
3877 }
3878 result = result && (hasChallenge() == other.hasChallenge());
3879 if (hasChallenge()) {
3880 result = result && getChallenge()
3881 .equals(other.getChallenge());
3882 }
3883 result = result &&
3884 getUnknownFields().equals(other.getUnknownFields());
3885 return result;
3886 }
3887
3888 private int memoizedHashCode = 0;
3889 @java.lang.Override
3890 public int hashCode() {
3891 if (memoizedHashCode != 0) {
3892 return memoizedHashCode;
3893 }
3894 int hash = 41;
3895 hash = (19 * hash) + getDescriptorForType().hashCode();
3896 if (hasMethod()) {
3897 hash = (37 * hash) + METHOD_FIELD_NUMBER;
3898 hash = (53 * hash) + getMethod().hashCode();
3899 }
3900 if (hasMechanism()) {
3901 hash = (37 * hash) + MECHANISM_FIELD_NUMBER;
3902 hash = (53 * hash) + getMechanism().hashCode();
3903 }
3904 if (hasProtocol()) {
3905 hash = (37 * hash) + PROTOCOL_FIELD_NUMBER;
3906 hash = (53 * hash) + getProtocol().hashCode();
3907 }
3908 if (hasServerId()) {
3909 hash = (37 * hash) + SERVERID_FIELD_NUMBER;
3910 hash = (53 * hash) + getServerId().hashCode();
3911 }
3912 if (hasChallenge()) {
3913 hash = (37 * hash) + CHALLENGE_FIELD_NUMBER;
3914 hash = (53 * hash) + getChallenge().hashCode();
3915 }
3916 hash = (29 * hash) + getUnknownFields().hashCode();
3917 memoizedHashCode = hash;
3918 return hash;
3919 }
3920
3921 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(
3922 com.google.protobuf.ByteString data)
3923 throws com.google.protobuf.InvalidProtocolBufferException {
3924 return PARSER.parseFrom(data);
3925 }
3926 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(
3927 com.google.protobuf.ByteString data,
3928 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3929 throws com.google.protobuf.InvalidProtocolBufferException {
3930 return PARSER.parseFrom(data, extensionRegistry);
3931 }
3932 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(byte[] data)
3933 throws com.google.protobuf.InvalidProtocolBufferException {
3934 return PARSER.parseFrom(data);
3935 }
3936 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(
3937 byte[] data,
3938 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3939 throws com.google.protobuf.InvalidProtocolBufferException {
3940 return PARSER.parseFrom(data, extensionRegistry);
3941 }
3942 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(java.io.InputStream input)
3943 throws java.io.IOException {
3944 return PARSER.parseFrom(input);
3945 }
3946 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(
3947 java.io.InputStream input,
3948 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3949 throws java.io.IOException {
3950 return PARSER.parseFrom(input, extensionRegistry);
3951 }
3952 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseDelimitedFrom(java.io.InputStream input)
3953 throws java.io.IOException {
3954 return PARSER.parseDelimitedFrom(input);
3955 }
3956 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseDelimitedFrom(
3957 java.io.InputStream input,
3958 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3959 throws java.io.IOException {
3960 return PARSER.parseDelimitedFrom(input, extensionRegistry);
3961 }
3962 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(
3963 com.google.protobuf.CodedInputStream input)
3964 throws java.io.IOException {
3965 return PARSER.parseFrom(input);
3966 }
3967 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parseFrom(
3968 com.google.protobuf.CodedInputStream input,
3969 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
3970 throws java.io.IOException {
3971 return PARSER.parseFrom(input, extensionRegistry);
3972 }
3973
3974 public static Builder newBuilder() { return Builder.create(); }
3975 public Builder newBuilderForType() { return newBuilder(); }
3976 public static Builder newBuilder(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth prototype) {
3977 return newBuilder().mergeFrom(prototype);
3978 }
3979 public Builder toBuilder() { return newBuilder(this); }
3980
3981 @java.lang.Override
3982 protected Builder newBuilderForType(
3983 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
3984 Builder builder = new Builder(parent);
3985 return builder;
3986 }
3987 /**
3988 * Protobuf type {@code hadoop.common.RpcSaslProto.SaslAuth}
3989 */
3990 public static final class Builder extends
3991 com.google.protobuf.GeneratedMessage.Builder<Builder>
3992 implements org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder {
3993 public static final com.google.protobuf.Descriptors.Descriptor
3994 getDescriptor() {
3995 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_SaslAuth_descriptor;
3996 }
3997
3998 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
3999 internalGetFieldAccessorTable() {
4000 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_SaslAuth_fieldAccessorTable
4001 .ensureFieldAccessorsInitialized(
4002 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder.class);
4003 }
4004
4005 // Construct using org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.newBuilder()
4006 private Builder() {
4007 maybeForceBuilderInitialization();
4008 }
4009
4010 private Builder(
4011 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4012 super(parent);
4013 maybeForceBuilderInitialization();
4014 }
4015 private void maybeForceBuilderInitialization() {
4016 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4017 }
4018 }
4019 private static Builder create() {
4020 return new Builder();
4021 }
4022
4023 public Builder clear() {
4024 super.clear();
4025 method_ = "";
4026 bitField0_ = (bitField0_ & ~0x00000001);
4027 mechanism_ = "";
4028 bitField0_ = (bitField0_ & ~0x00000002);
4029 protocol_ = "";
4030 bitField0_ = (bitField0_ & ~0x00000004);
4031 serverId_ = "";
4032 bitField0_ = (bitField0_ & ~0x00000008);
4033 challenge_ = com.google.protobuf.ByteString.EMPTY;
4034 bitField0_ = (bitField0_ & ~0x00000010);
4035 return this;
4036 }
4037
4038 public Builder clone() {
4039 return create().mergeFrom(buildPartial());
4040 }
4041
4042 public com.google.protobuf.Descriptors.Descriptor
4043 getDescriptorForType() {
4044 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_SaslAuth_descriptor;
4045 }
4046
4047 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth getDefaultInstanceForType() {
4048 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.getDefaultInstance();
4049 }
4050
4051 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth build() {
4052 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth result = buildPartial();
4053 if (!result.isInitialized()) {
4054 throw newUninitializedMessageException(result);
4055 }
4056 return result;
4057 }
4058
4059 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth buildPartial() {
4060 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth result = new org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth(this);
4061 int from_bitField0_ = bitField0_;
4062 int to_bitField0_ = 0;
4063 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4064 to_bitField0_ |= 0x00000001;
4065 }
4066 result.method_ = method_;
4067 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4068 to_bitField0_ |= 0x00000002;
4069 }
4070 result.mechanism_ = mechanism_;
4071 if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4072 to_bitField0_ |= 0x00000004;
4073 }
4074 result.protocol_ = protocol_;
4075 if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
4076 to_bitField0_ |= 0x00000008;
4077 }
4078 result.serverId_ = serverId_;
4079 if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
4080 to_bitField0_ |= 0x00000010;
4081 }
4082 result.challenge_ = challenge_;
4083 result.bitField0_ = to_bitField0_;
4084 onBuilt();
4085 return result;
4086 }
4087
4088 public Builder mergeFrom(com.google.protobuf.Message other) {
4089 if (other instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth) {
4090 return mergeFrom((org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth)other);
4091 } else {
4092 super.mergeFrom(other);
4093 return this;
4094 }
4095 }
4096
4097 public Builder mergeFrom(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth other) {
4098 if (other == org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.getDefaultInstance()) return this;
4099 if (other.hasMethod()) {
4100 bitField0_ |= 0x00000001;
4101 method_ = other.method_;
4102 onChanged();
4103 }
4104 if (other.hasMechanism()) {
4105 bitField0_ |= 0x00000002;
4106 mechanism_ = other.mechanism_;
4107 onChanged();
4108 }
4109 if (other.hasProtocol()) {
4110 bitField0_ |= 0x00000004;
4111 protocol_ = other.protocol_;
4112 onChanged();
4113 }
4114 if (other.hasServerId()) {
4115 bitField0_ |= 0x00000008;
4116 serverId_ = other.serverId_;
4117 onChanged();
4118 }
4119 if (other.hasChallenge()) {
4120 setChallenge(other.getChallenge());
4121 }
4122 this.mergeUnknownFields(other.getUnknownFields());
4123 return this;
4124 }
4125
4126 public final boolean isInitialized() {
4127 if (!hasMethod()) {
4128
4129 return false;
4130 }
4131 if (!hasMechanism()) {
4132
4133 return false;
4134 }
4135 return true;
4136 }
4137
4138 public Builder mergeFrom(
4139 com.google.protobuf.CodedInputStream input,
4140 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4141 throws java.io.IOException {
4142 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth parsedMessage = null;
4143 try {
4144 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4145 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4146 parsedMessage = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth) e.getUnfinishedMessage();
4147 throw e;
4148 } finally {
4149 if (parsedMessage != null) {
4150 mergeFrom(parsedMessage);
4151 }
4152 }
4153 return this;
4154 }
4155 private int bitField0_;
4156
4157 // required string method = 1;
4158 private java.lang.Object method_ = "";
4159 /**
4160 * <code>required string method = 1;</code>
4161 */
4162 public boolean hasMethod() {
4163 return ((bitField0_ & 0x00000001) == 0x00000001);
4164 }
4165 /**
4166 * <code>required string method = 1;</code>
4167 */
4168 public java.lang.String getMethod() {
4169 java.lang.Object ref = method_;
4170 if (!(ref instanceof java.lang.String)) {
4171 java.lang.String s = ((com.google.protobuf.ByteString) ref)
4172 .toStringUtf8();
4173 method_ = s;
4174 return s;
4175 } else {
4176 return (java.lang.String) ref;
4177 }
4178 }
4179 /**
4180 * <code>required string method = 1;</code>
4181 */
4182 public com.google.protobuf.ByteString
4183 getMethodBytes() {
4184 java.lang.Object ref = method_;
4185 if (ref instanceof String) {
4186 com.google.protobuf.ByteString b =
4187 com.google.protobuf.ByteString.copyFromUtf8(
4188 (java.lang.String) ref);
4189 method_ = b;
4190 return b;
4191 } else {
4192 return (com.google.protobuf.ByteString) ref;
4193 }
4194 }
4195 /**
4196 * <code>required string method = 1;</code>
4197 */
4198 public Builder setMethod(
4199 java.lang.String value) {
4200 if (value == null) {
4201 throw new NullPointerException();
4202 }
4203 bitField0_ |= 0x00000001;
4204 method_ = value;
4205 onChanged();
4206 return this;
4207 }
4208 /**
4209 * <code>required string method = 1;</code>
4210 */
4211 public Builder clearMethod() {
4212 bitField0_ = (bitField0_ & ~0x00000001);
4213 method_ = getDefaultInstance().getMethod();
4214 onChanged();
4215 return this;
4216 }
4217 /**
4218 * <code>required string method = 1;</code>
4219 */
4220 public Builder setMethodBytes(
4221 com.google.protobuf.ByteString value) {
4222 if (value == null) {
4223 throw new NullPointerException();
4224 }
4225 bitField0_ |= 0x00000001;
4226 method_ = value;
4227 onChanged();
4228 return this;
4229 }
4230
4231 // required string mechanism = 2;
4232 private java.lang.Object mechanism_ = "";
4233 /**
4234 * <code>required string mechanism = 2;</code>
4235 */
4236 public boolean hasMechanism() {
4237 return ((bitField0_ & 0x00000002) == 0x00000002);
4238 }
4239 /**
4240 * <code>required string mechanism = 2;</code>
4241 */
4242 public java.lang.String getMechanism() {
4243 java.lang.Object ref = mechanism_;
4244 if (!(ref instanceof java.lang.String)) {
4245 java.lang.String s = ((com.google.protobuf.ByteString) ref)
4246 .toStringUtf8();
4247 mechanism_ = s;
4248 return s;
4249 } else {
4250 return (java.lang.String) ref;
4251 }
4252 }
4253 /**
4254 * <code>required string mechanism = 2;</code>
4255 */
4256 public com.google.protobuf.ByteString
4257 getMechanismBytes() {
4258 java.lang.Object ref = mechanism_;
4259 if (ref instanceof String) {
4260 com.google.protobuf.ByteString b =
4261 com.google.protobuf.ByteString.copyFromUtf8(
4262 (java.lang.String) ref);
4263 mechanism_ = b;
4264 return b;
4265 } else {
4266 return (com.google.protobuf.ByteString) ref;
4267 }
4268 }
4269 /**
4270 * <code>required string mechanism = 2;</code>
4271 */
4272 public Builder setMechanism(
4273 java.lang.String value) {
4274 if (value == null) {
4275 throw new NullPointerException();
4276 }
4277 bitField0_ |= 0x00000002;
4278 mechanism_ = value;
4279 onChanged();
4280 return this;
4281 }
4282 /**
4283 * <code>required string mechanism = 2;</code>
4284 */
4285 public Builder clearMechanism() {
4286 bitField0_ = (bitField0_ & ~0x00000002);
4287 mechanism_ = getDefaultInstance().getMechanism();
4288 onChanged();
4289 return this;
4290 }
4291 /**
4292 * <code>required string mechanism = 2;</code>
4293 */
4294 public Builder setMechanismBytes(
4295 com.google.protobuf.ByteString value) {
4296 if (value == null) {
4297 throw new NullPointerException();
4298 }
4299 bitField0_ |= 0x00000002;
4300 mechanism_ = value;
4301 onChanged();
4302 return this;
4303 }
4304
4305 // optional string protocol = 3;
4306 private java.lang.Object protocol_ = "";
4307 /**
4308 * <code>optional string protocol = 3;</code>
4309 */
4310 public boolean hasProtocol() {
4311 return ((bitField0_ & 0x00000004) == 0x00000004);
4312 }
4313 /**
4314 * <code>optional string protocol = 3;</code>
4315 */
4316 public java.lang.String getProtocol() {
4317 java.lang.Object ref = protocol_;
4318 if (!(ref instanceof java.lang.String)) {
4319 java.lang.String s = ((com.google.protobuf.ByteString) ref)
4320 .toStringUtf8();
4321 protocol_ = s;
4322 return s;
4323 } else {
4324 return (java.lang.String) ref;
4325 }
4326 }
4327 /**
4328 * <code>optional string protocol = 3;</code>
4329 */
4330 public com.google.protobuf.ByteString
4331 getProtocolBytes() {
4332 java.lang.Object ref = protocol_;
4333 if (ref instanceof String) {
4334 com.google.protobuf.ByteString b =
4335 com.google.protobuf.ByteString.copyFromUtf8(
4336 (java.lang.String) ref);
4337 protocol_ = b;
4338 return b;
4339 } else {
4340 return (com.google.protobuf.ByteString) ref;
4341 }
4342 }
4343 /**
4344 * <code>optional string protocol = 3;</code>
4345 */
4346 public Builder setProtocol(
4347 java.lang.String value) {
4348 if (value == null) {
4349 throw new NullPointerException();
4350 }
4351 bitField0_ |= 0x00000004;
4352 protocol_ = value;
4353 onChanged();
4354 return this;
4355 }
4356 /**
4357 * <code>optional string protocol = 3;</code>
4358 */
4359 public Builder clearProtocol() {
4360 bitField0_ = (bitField0_ & ~0x00000004);
4361 protocol_ = getDefaultInstance().getProtocol();
4362 onChanged();
4363 return this;
4364 }
4365 /**
4366 * <code>optional string protocol = 3;</code>
4367 */
4368 public Builder setProtocolBytes(
4369 com.google.protobuf.ByteString value) {
4370 if (value == null) {
4371 throw new NullPointerException();
4372 }
4373 bitField0_ |= 0x00000004;
4374 protocol_ = value;
4375 onChanged();
4376 return this;
4377 }
4378
4379 // optional string serverId = 4;
4380 private java.lang.Object serverId_ = "";
4381 /**
4382 * <code>optional string serverId = 4;</code>
4383 */
4384 public boolean hasServerId() {
4385 return ((bitField0_ & 0x00000008) == 0x00000008);
4386 }
4387 /**
4388 * <code>optional string serverId = 4;</code>
4389 */
4390 public java.lang.String getServerId() {
4391 java.lang.Object ref = serverId_;
4392 if (!(ref instanceof java.lang.String)) {
4393 java.lang.String s = ((com.google.protobuf.ByteString) ref)
4394 .toStringUtf8();
4395 serverId_ = s;
4396 return s;
4397 } else {
4398 return (java.lang.String) ref;
4399 }
4400 }
4401 /**
4402 * <code>optional string serverId = 4;</code>
4403 */
4404 public com.google.protobuf.ByteString
4405 getServerIdBytes() {
4406 java.lang.Object ref = serverId_;
4407 if (ref instanceof String) {
4408 com.google.protobuf.ByteString b =
4409 com.google.protobuf.ByteString.copyFromUtf8(
4410 (java.lang.String) ref);
4411 serverId_ = b;
4412 return b;
4413 } else {
4414 return (com.google.protobuf.ByteString) ref;
4415 }
4416 }
4417 /**
4418 * <code>optional string serverId = 4;</code>
4419 */
4420 public Builder setServerId(
4421 java.lang.String value) {
4422 if (value == null) {
4423 throw new NullPointerException();
4424 }
4425 bitField0_ |= 0x00000008;
4426 serverId_ = value;
4427 onChanged();
4428 return this;
4429 }
4430 /**
4431 * <code>optional string serverId = 4;</code>
4432 */
4433 public Builder clearServerId() {
4434 bitField0_ = (bitField0_ & ~0x00000008);
4435 serverId_ = getDefaultInstance().getServerId();
4436 onChanged();
4437 return this;
4438 }
4439 /**
4440 * <code>optional string serverId = 4;</code>
4441 */
4442 public Builder setServerIdBytes(
4443 com.google.protobuf.ByteString value) {
4444 if (value == null) {
4445 throw new NullPointerException();
4446 }
4447 bitField0_ |= 0x00000008;
4448 serverId_ = value;
4449 onChanged();
4450 return this;
4451 }
4452
4453 // optional bytes challenge = 5;
4454 private com.google.protobuf.ByteString challenge_ = com.google.protobuf.ByteString.EMPTY;
4455 /**
4456 * <code>optional bytes challenge = 5;</code>
4457 */
4458 public boolean hasChallenge() {
4459 return ((bitField0_ & 0x00000010) == 0x00000010);
4460 }
4461 /**
4462 * <code>optional bytes challenge = 5;</code>
4463 */
4464 public com.google.protobuf.ByteString getChallenge() {
4465 return challenge_;
4466 }
4467 /**
4468 * <code>optional bytes challenge = 5;</code>
4469 */
4470 public Builder setChallenge(com.google.protobuf.ByteString value) {
4471 if (value == null) {
4472 throw new NullPointerException();
4473 }
4474 bitField0_ |= 0x00000010;
4475 challenge_ = value;
4476 onChanged();
4477 return this;
4478 }
4479 /**
4480 * <code>optional bytes challenge = 5;</code>
4481 */
4482 public Builder clearChallenge() {
4483 bitField0_ = (bitField0_ & ~0x00000010);
4484 challenge_ = getDefaultInstance().getChallenge();
4485 onChanged();
4486 return this;
4487 }
4488
4489 // @@protoc_insertion_point(builder_scope:hadoop.common.RpcSaslProto.SaslAuth)
4490 }
4491
4492 static {
4493 defaultInstance = new SaslAuth(true);
4494 defaultInstance.initFields();
4495 }
4496
4497 // @@protoc_insertion_point(class_scope:hadoop.common.RpcSaslProto.SaslAuth)
4498 }
4499
4500 private int bitField0_;
4501 // optional uint32 version = 1;
4502 public static final int VERSION_FIELD_NUMBER = 1;
4503 private int version_;
4504 /**
4505 * <code>optional uint32 version = 1;</code>
4506 */
4507 public boolean hasVersion() {
4508 return ((bitField0_ & 0x00000001) == 0x00000001);
4509 }
4510 /**
4511 * <code>optional uint32 version = 1;</code>
4512 */
4513 public int getVersion() {
4514 return version_;
4515 }
4516
4517 // required .hadoop.common.RpcSaslProto.SaslState state = 2;
4518 public static final int STATE_FIELD_NUMBER = 2;
4519 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState state_;
4520 /**
4521 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
4522 */
4523 public boolean hasState() {
4524 return ((bitField0_ & 0x00000002) == 0x00000002);
4525 }
4526 /**
4527 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
4528 */
4529 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState getState() {
4530 return state_;
4531 }
4532
4533 // optional bytes token = 3;
4534 public static final int TOKEN_FIELD_NUMBER = 3;
4535 private com.google.protobuf.ByteString token_;
4536 /**
4537 * <code>optional bytes token = 3;</code>
4538 */
4539 public boolean hasToken() {
4540 return ((bitField0_ & 0x00000004) == 0x00000004);
4541 }
4542 /**
4543 * <code>optional bytes token = 3;</code>
4544 */
4545 public com.google.protobuf.ByteString getToken() {
4546 return token_;
4547 }
4548
4549 // repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;
4550 public static final int AUTHS_FIELD_NUMBER = 4;
4551 private java.util.List<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth> auths_;
4552 /**
4553 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
4554 */
4555 public java.util.List<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth> getAuthsList() {
4556 return auths_;
4557 }
4558 /**
4559 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
4560 */
4561 public java.util.List<? extends org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder>
4562 getAuthsOrBuilderList() {
4563 return auths_;
4564 }
4565 /**
4566 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
4567 */
4568 public int getAuthsCount() {
4569 return auths_.size();
4570 }
4571 /**
4572 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
4573 */
4574 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth getAuths(int index) {
4575 return auths_.get(index);
4576 }
4577 /**
4578 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
4579 */
4580 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder getAuthsOrBuilder(
4581 int index) {
4582 return auths_.get(index);
4583 }
4584
4585 private void initFields() {
4586 version_ = 0;
4587 state_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState.SUCCESS;
4588 token_ = com.google.protobuf.ByteString.EMPTY;
4589 auths_ = java.util.Collections.emptyList();
4590 }
4591 private byte memoizedIsInitialized = -1;
4592 public final boolean isInitialized() {
4593 byte isInitialized = memoizedIsInitialized;
4594 if (isInitialized != -1) return isInitialized == 1;
4595
4596 if (!hasState()) {
4597 memoizedIsInitialized = 0;
4598 return false;
4599 }
4600 for (int i = 0; i < getAuthsCount(); i++) {
4601 if (!getAuths(i).isInitialized()) {
4602 memoizedIsInitialized = 0;
4603 return false;
4604 }
4605 }
4606 memoizedIsInitialized = 1;
4607 return true;
4608 }
4609
4610 public void writeTo(com.google.protobuf.CodedOutputStream output)
4611 throws java.io.IOException {
4612 getSerializedSize();
4613 if (((bitField0_ & 0x00000001) == 0x00000001)) {
4614 output.writeUInt32(1, version_);
4615 }
4616 if (((bitField0_ & 0x00000002) == 0x00000002)) {
4617 output.writeEnum(2, state_.getNumber());
4618 }
4619 if (((bitField0_ & 0x00000004) == 0x00000004)) {
4620 output.writeBytes(3, token_);
4621 }
4622 for (int i = 0; i < auths_.size(); i++) {
4623 output.writeMessage(4, auths_.get(i));
4624 }
4625 getUnknownFields().writeTo(output);
4626 }
4627
4628 private int memoizedSerializedSize = -1;
4629 public int getSerializedSize() {
4630 int size = memoizedSerializedSize;
4631 if (size != -1) return size;
4632
4633 size = 0;
4634 if (((bitField0_ & 0x00000001) == 0x00000001)) {
4635 size += com.google.protobuf.CodedOutputStream
4636 .computeUInt32Size(1, version_);
4637 }
4638 if (((bitField0_ & 0x00000002) == 0x00000002)) {
4639 size += com.google.protobuf.CodedOutputStream
4640 .computeEnumSize(2, state_.getNumber());
4641 }
4642 if (((bitField0_ & 0x00000004) == 0x00000004)) {
4643 size += com.google.protobuf.CodedOutputStream
4644 .computeBytesSize(3, token_);
4645 }
4646 for (int i = 0; i < auths_.size(); i++) {
4647 size += com.google.protobuf.CodedOutputStream
4648 .computeMessageSize(4, auths_.get(i));
4649 }
4650 size += getUnknownFields().getSerializedSize();
4651 memoizedSerializedSize = size;
4652 return size;
4653 }
4654
4655 private static final long serialVersionUID = 0L;
4656 @java.lang.Override
4657 protected java.lang.Object writeReplace()
4658 throws java.io.ObjectStreamException {
4659 return super.writeReplace();
4660 }
4661
4662 @java.lang.Override
4663 public boolean equals(final java.lang.Object obj) {
4664 if (obj == this) {
4665 return true;
4666 }
4667 if (!(obj instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto)) {
4668 return super.equals(obj);
4669 }
4670 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto other = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto) obj;
4671
4672 boolean result = true;
4673 result = result && (hasVersion() == other.hasVersion());
4674 if (hasVersion()) {
4675 result = result && (getVersion()
4676 == other.getVersion());
4677 }
4678 result = result && (hasState() == other.hasState());
4679 if (hasState()) {
4680 result = result &&
4681 (getState() == other.getState());
4682 }
4683 result = result && (hasToken() == other.hasToken());
4684 if (hasToken()) {
4685 result = result && getToken()
4686 .equals(other.getToken());
4687 }
4688 result = result && getAuthsList()
4689 .equals(other.getAuthsList());
4690 result = result &&
4691 getUnknownFields().equals(other.getUnknownFields());
4692 return result;
4693 }
4694
4695 private int memoizedHashCode = 0;
4696 @java.lang.Override
4697 public int hashCode() {
4698 if (memoizedHashCode != 0) {
4699 return memoizedHashCode;
4700 }
4701 int hash = 41;
4702 hash = (19 * hash) + getDescriptorForType().hashCode();
4703 if (hasVersion()) {
4704 hash = (37 * hash) + VERSION_FIELD_NUMBER;
4705 hash = (53 * hash) + getVersion();
4706 }
4707 if (hasState()) {
4708 hash = (37 * hash) + STATE_FIELD_NUMBER;
4709 hash = (53 * hash) + hashEnum(getState());
4710 }
4711 if (hasToken()) {
4712 hash = (37 * hash) + TOKEN_FIELD_NUMBER;
4713 hash = (53 * hash) + getToken().hashCode();
4714 }
4715 if (getAuthsCount() > 0) {
4716 hash = (37 * hash) + AUTHS_FIELD_NUMBER;
4717 hash = (53 * hash) + getAuthsList().hashCode();
4718 }
4719 hash = (29 * hash) + getUnknownFields().hashCode();
4720 memoizedHashCode = hash;
4721 return hash;
4722 }
4723
4724 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(
4725 com.google.protobuf.ByteString data)
4726 throws com.google.protobuf.InvalidProtocolBufferException {
4727 return PARSER.parseFrom(data);
4728 }
4729 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(
4730 com.google.protobuf.ByteString data,
4731 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4732 throws com.google.protobuf.InvalidProtocolBufferException {
4733 return PARSER.parseFrom(data, extensionRegistry);
4734 }
4735 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(byte[] data)
4736 throws com.google.protobuf.InvalidProtocolBufferException {
4737 return PARSER.parseFrom(data);
4738 }
4739 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(
4740 byte[] data,
4741 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4742 throws com.google.protobuf.InvalidProtocolBufferException {
4743 return PARSER.parseFrom(data, extensionRegistry);
4744 }
4745 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(java.io.InputStream input)
4746 throws java.io.IOException {
4747 return PARSER.parseFrom(input);
4748 }
4749 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(
4750 java.io.InputStream input,
4751 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4752 throws java.io.IOException {
4753 return PARSER.parseFrom(input, extensionRegistry);
4754 }
4755 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseDelimitedFrom(java.io.InputStream input)
4756 throws java.io.IOException {
4757 return PARSER.parseDelimitedFrom(input);
4758 }
4759 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseDelimitedFrom(
4760 java.io.InputStream input,
4761 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4762 throws java.io.IOException {
4763 return PARSER.parseDelimitedFrom(input, extensionRegistry);
4764 }
4765 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(
4766 com.google.protobuf.CodedInputStream input)
4767 throws java.io.IOException {
4768 return PARSER.parseFrom(input);
4769 }
4770 public static org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parseFrom(
4771 com.google.protobuf.CodedInputStream input,
4772 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4773 throws java.io.IOException {
4774 return PARSER.parseFrom(input, extensionRegistry);
4775 }
4776
4777 public static Builder newBuilder() { return Builder.create(); }
4778 public Builder newBuilderForType() { return newBuilder(); }
4779 public static Builder newBuilder(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto prototype) {
4780 return newBuilder().mergeFrom(prototype);
4781 }
4782 public Builder toBuilder() { return newBuilder(this); }
4783
4784 @java.lang.Override
4785 protected Builder newBuilderForType(
4786 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4787 Builder builder = new Builder(parent);
4788 return builder;
4789 }
4790 /**
4791 * Protobuf type {@code hadoop.common.RpcSaslProto}
4792 */
4793 public static final class Builder extends
4794 com.google.protobuf.GeneratedMessage.Builder<Builder>
4795 implements org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProtoOrBuilder {
4796 public static final com.google.protobuf.Descriptors.Descriptor
4797 getDescriptor() {
4798 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_descriptor;
4799 }
4800
4801 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
4802 internalGetFieldAccessorTable() {
4803 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_fieldAccessorTable
4804 .ensureFieldAccessorsInitialized(
4805 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.class, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.Builder.class);
4806 }
4807
4808 // Construct using org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.newBuilder()
4809 private Builder() {
4810 maybeForceBuilderInitialization();
4811 }
4812
4813 private Builder(
4814 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
4815 super(parent);
4816 maybeForceBuilderInitialization();
4817 }
4818 private void maybeForceBuilderInitialization() {
4819 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
4820 getAuthsFieldBuilder();
4821 }
4822 }
4823 private static Builder create() {
4824 return new Builder();
4825 }
4826
4827 public Builder clear() {
4828 super.clear();
4829 version_ = 0;
4830 bitField0_ = (bitField0_ & ~0x00000001);
4831 state_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState.SUCCESS;
4832 bitField0_ = (bitField0_ & ~0x00000002);
4833 token_ = com.google.protobuf.ByteString.EMPTY;
4834 bitField0_ = (bitField0_ & ~0x00000004);
4835 if (authsBuilder_ == null) {
4836 auths_ = java.util.Collections.emptyList();
4837 bitField0_ = (bitField0_ & ~0x00000008);
4838 } else {
4839 authsBuilder_.clear();
4840 }
4841 return this;
4842 }
4843
4844 public Builder clone() {
4845 return create().mergeFrom(buildPartial());
4846 }
4847
4848 public com.google.protobuf.Descriptors.Descriptor
4849 getDescriptorForType() {
4850 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.internal_static_hadoop_common_RpcSaslProto_descriptor;
4851 }
4852
4853 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto getDefaultInstanceForType() {
4854 return org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.getDefaultInstance();
4855 }
4856
4857 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto build() {
4858 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto result = buildPartial();
4859 if (!result.isInitialized()) {
4860 throw newUninitializedMessageException(result);
4861 }
4862 return result;
4863 }
4864
4865 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto buildPartial() {
4866 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto result = new org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto(this);
4867 int from_bitField0_ = bitField0_;
4868 int to_bitField0_ = 0;
4869 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
4870 to_bitField0_ |= 0x00000001;
4871 }
4872 result.version_ = version_;
4873 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
4874 to_bitField0_ |= 0x00000002;
4875 }
4876 result.state_ = state_;
4877 if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
4878 to_bitField0_ |= 0x00000004;
4879 }
4880 result.token_ = token_;
4881 if (authsBuilder_ == null) {
4882 if (((bitField0_ & 0x00000008) == 0x00000008)) {
4883 auths_ = java.util.Collections.unmodifiableList(auths_);
4884 bitField0_ = (bitField0_ & ~0x00000008);
4885 }
4886 result.auths_ = auths_;
4887 } else {
4888 result.auths_ = authsBuilder_.build();
4889 }
4890 result.bitField0_ = to_bitField0_;
4891 onBuilt();
4892 return result;
4893 }
4894
4895 public Builder mergeFrom(com.google.protobuf.Message other) {
4896 if (other instanceof org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto) {
4897 return mergeFrom((org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto)other);
4898 } else {
4899 super.mergeFrom(other);
4900 return this;
4901 }
4902 }
4903
4904 public Builder mergeFrom(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto other) {
4905 if (other == org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.getDefaultInstance()) return this;
4906 if (other.hasVersion()) {
4907 setVersion(other.getVersion());
4908 }
4909 if (other.hasState()) {
4910 setState(other.getState());
4911 }
4912 if (other.hasToken()) {
4913 setToken(other.getToken());
4914 }
4915 if (authsBuilder_ == null) {
4916 if (!other.auths_.isEmpty()) {
4917 if (auths_.isEmpty()) {
4918 auths_ = other.auths_;
4919 bitField0_ = (bitField0_ & ~0x00000008);
4920 } else {
4921 ensureAuthsIsMutable();
4922 auths_.addAll(other.auths_);
4923 }
4924 onChanged();
4925 }
4926 } else {
4927 if (!other.auths_.isEmpty()) {
4928 if (authsBuilder_.isEmpty()) {
4929 authsBuilder_.dispose();
4930 authsBuilder_ = null;
4931 auths_ = other.auths_;
4932 bitField0_ = (bitField0_ & ~0x00000008);
4933 authsBuilder_ =
4934 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
4935 getAuthsFieldBuilder() : null;
4936 } else {
4937 authsBuilder_.addAllMessages(other.auths_);
4938 }
4939 }
4940 }
4941 this.mergeUnknownFields(other.getUnknownFields());
4942 return this;
4943 }
4944
4945 public final boolean isInitialized() {
4946 if (!hasState()) {
4947
4948 return false;
4949 }
4950 for (int i = 0; i < getAuthsCount(); i++) {
4951 if (!getAuths(i).isInitialized()) {
4952
4953 return false;
4954 }
4955 }
4956 return true;
4957 }
4958
4959 public Builder mergeFrom(
4960 com.google.protobuf.CodedInputStream input,
4961 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4962 throws java.io.IOException {
4963 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto parsedMessage = null;
4964 try {
4965 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
4966 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
4967 parsedMessage = (org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto) e.getUnfinishedMessage();
4968 throw e;
4969 } finally {
4970 if (parsedMessage != null) {
4971 mergeFrom(parsedMessage);
4972 }
4973 }
4974 return this;
4975 }
4976 private int bitField0_;
4977
4978 // optional uint32 version = 1;
4979 private int version_ ;
4980 /**
4981 * <code>optional uint32 version = 1;</code>
4982 */
4983 public boolean hasVersion() {
4984 return ((bitField0_ & 0x00000001) == 0x00000001);
4985 }
4986 /**
4987 * <code>optional uint32 version = 1;</code>
4988 */
4989 public int getVersion() {
4990 return version_;
4991 }
4992 /**
4993 * <code>optional uint32 version = 1;</code>
4994 */
4995 public Builder setVersion(int value) {
4996 bitField0_ |= 0x00000001;
4997 version_ = value;
4998 onChanged();
4999 return this;
5000 }
5001 /**
5002 * <code>optional uint32 version = 1;</code>
5003 */
5004 public Builder clearVersion() {
5005 bitField0_ = (bitField0_ & ~0x00000001);
5006 version_ = 0;
5007 onChanged();
5008 return this;
5009 }
5010
5011 // required .hadoop.common.RpcSaslProto.SaslState state = 2;
5012 private org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState state_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState.SUCCESS;
5013 /**
5014 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
5015 */
5016 public boolean hasState() {
5017 return ((bitField0_ & 0x00000002) == 0x00000002);
5018 }
5019 /**
5020 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
5021 */
5022 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState getState() {
5023 return state_;
5024 }
5025 /**
5026 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
5027 */
5028 public Builder setState(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState value) {
5029 if (value == null) {
5030 throw new NullPointerException();
5031 }
5032 bitField0_ |= 0x00000002;
5033 state_ = value;
5034 onChanged();
5035 return this;
5036 }
5037 /**
5038 * <code>required .hadoop.common.RpcSaslProto.SaslState state = 2;</code>
5039 */
5040 public Builder clearState() {
5041 bitField0_ = (bitField0_ & ~0x00000002);
5042 state_ = org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslState.SUCCESS;
5043 onChanged();
5044 return this;
5045 }
5046
5047 // optional bytes token = 3;
5048 private com.google.protobuf.ByteString token_ = com.google.protobuf.ByteString.EMPTY;
5049 /**
5050 * <code>optional bytes token = 3;</code>
5051 */
5052 public boolean hasToken() {
5053 return ((bitField0_ & 0x00000004) == 0x00000004);
5054 }
5055 /**
5056 * <code>optional bytes token = 3;</code>
5057 */
5058 public com.google.protobuf.ByteString getToken() {
5059 return token_;
5060 }
5061 /**
5062 * <code>optional bytes token = 3;</code>
5063 */
5064 public Builder setToken(com.google.protobuf.ByteString value) {
5065 if (value == null) {
5066 throw new NullPointerException();
5067 }
5068 bitField0_ |= 0x00000004;
5069 token_ = value;
5070 onChanged();
5071 return this;
5072 }
5073 /**
5074 * <code>optional bytes token = 3;</code>
5075 */
5076 public Builder clearToken() {
5077 bitField0_ = (bitField0_ & ~0x00000004);
5078 token_ = getDefaultInstance().getToken();
5079 onChanged();
5080 return this;
5081 }
5082
5083 // repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;
5084 private java.util.List<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth> auths_ =
5085 java.util.Collections.emptyList();
5086 private void ensureAuthsIsMutable() {
5087 if (!((bitField0_ & 0x00000008) == 0x00000008)) {
5088 auths_ = new java.util.ArrayList<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth>(auths_);
5089 bitField0_ |= 0x00000008;
5090 }
5091 }
5092
5093 private com.google.protobuf.RepeatedFieldBuilder<
5094 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder> authsBuilder_;
5095
5096 /**
5097 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5098 */
5099 public java.util.List<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth> getAuthsList() {
5100 if (authsBuilder_ == null) {
5101 return java.util.Collections.unmodifiableList(auths_);
5102 } else {
5103 return authsBuilder_.getMessageList();
5104 }
5105 }
5106 /**
5107 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5108 */
5109 public int getAuthsCount() {
5110 if (authsBuilder_ == null) {
5111 return auths_.size();
5112 } else {
5113 return authsBuilder_.getCount();
5114 }
5115 }
5116 /**
5117 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5118 */
5119 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth getAuths(int index) {
5120 if (authsBuilder_ == null) {
5121 return auths_.get(index);
5122 } else {
5123 return authsBuilder_.getMessage(index);
5124 }
5125 }
5126 /**
5127 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5128 */
5129 public Builder setAuths(
5130 int index, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth value) {
5131 if (authsBuilder_ == null) {
5132 if (value == null) {
5133 throw new NullPointerException();
5134 }
5135 ensureAuthsIsMutable();
5136 auths_.set(index, value);
5137 onChanged();
5138 } else {
5139 authsBuilder_.setMessage(index, value);
5140 }
5141 return this;
5142 }
5143 /**
5144 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5145 */
5146 public Builder setAuths(
5147 int index, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder builderForValue) {
5148 if (authsBuilder_ == null) {
5149 ensureAuthsIsMutable();
5150 auths_.set(index, builderForValue.build());
5151 onChanged();
5152 } else {
5153 authsBuilder_.setMessage(index, builderForValue.build());
5154 }
5155 return this;
5156 }
5157 /**
5158 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5159 */
5160 public Builder addAuths(org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth value) {
5161 if (authsBuilder_ == null) {
5162 if (value == null) {
5163 throw new NullPointerException();
5164 }
5165 ensureAuthsIsMutable();
5166 auths_.add(value);
5167 onChanged();
5168 } else {
5169 authsBuilder_.addMessage(value);
5170 }
5171 return this;
5172 }
5173 /**
5174 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5175 */
5176 public Builder addAuths(
5177 int index, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth value) {
5178 if (authsBuilder_ == null) {
5179 if (value == null) {
5180 throw new NullPointerException();
5181 }
5182 ensureAuthsIsMutable();
5183 auths_.add(index, value);
5184 onChanged();
5185 } else {
5186 authsBuilder_.addMessage(index, value);
5187 }
5188 return this;
5189 }
5190 /**
5191 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5192 */
5193 public Builder addAuths(
5194 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder builderForValue) {
5195 if (authsBuilder_ == null) {
5196 ensureAuthsIsMutable();
5197 auths_.add(builderForValue.build());
5198 onChanged();
5199 } else {
5200 authsBuilder_.addMessage(builderForValue.build());
5201 }
5202 return this;
5203 }
5204 /**
5205 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5206 */
5207 public Builder addAuths(
5208 int index, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder builderForValue) {
5209 if (authsBuilder_ == null) {
5210 ensureAuthsIsMutable();
5211 auths_.add(index, builderForValue.build());
5212 onChanged();
5213 } else {
5214 authsBuilder_.addMessage(index, builderForValue.build());
5215 }
5216 return this;
5217 }
5218 /**
5219 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5220 */
5221 public Builder addAllAuths(
5222 java.lang.Iterable<? extends org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth> values) {
5223 if (authsBuilder_ == null) {
5224 ensureAuthsIsMutable();
5225 super.addAll(values, auths_);
5226 onChanged();
5227 } else {
5228 authsBuilder_.addAllMessages(values);
5229 }
5230 return this;
5231 }
5232 /**
5233 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5234 */
5235 public Builder clearAuths() {
5236 if (authsBuilder_ == null) {
5237 auths_ = java.util.Collections.emptyList();
5238 bitField0_ = (bitField0_ & ~0x00000008);
5239 onChanged();
5240 } else {
5241 authsBuilder_.clear();
5242 }
5243 return this;
5244 }
5245 /**
5246 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5247 */
5248 public Builder removeAuths(int index) {
5249 if (authsBuilder_ == null) {
5250 ensureAuthsIsMutable();
5251 auths_.remove(index);
5252 onChanged();
5253 } else {
5254 authsBuilder_.remove(index);
5255 }
5256 return this;
5257 }
5258 /**
5259 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5260 */
5261 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder getAuthsBuilder(
5262 int index) {
5263 return getAuthsFieldBuilder().getBuilder(index);
5264 }
5265 /**
5266 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5267 */
5268 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder getAuthsOrBuilder(
5269 int index) {
5270 if (authsBuilder_ == null) {
5271 return auths_.get(index); } else {
5272 return authsBuilder_.getMessageOrBuilder(index);
5273 }
5274 }
5275 /**
5276 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5277 */
5278 public java.util.List<? extends org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder>
5279 getAuthsOrBuilderList() {
5280 if (authsBuilder_ != null) {
5281 return authsBuilder_.getMessageOrBuilderList();
5282 } else {
5283 return java.util.Collections.unmodifiableList(auths_);
5284 }
5285 }
5286 /**
5287 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5288 */
5289 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder addAuthsBuilder() {
5290 return getAuthsFieldBuilder().addBuilder(
5291 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.getDefaultInstance());
5292 }
5293 /**
5294 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5295 */
5296 public org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder addAuthsBuilder(
5297 int index) {
5298 return getAuthsFieldBuilder().addBuilder(
5299 index, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.getDefaultInstance());
5300 }
5301 /**
5302 * <code>repeated .hadoop.common.RpcSaslProto.SaslAuth auths = 4;</code>
5303 */
5304 public java.util.List<org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder>
5305 getAuthsBuilderList() {
5306 return getAuthsFieldBuilder().getBuilderList();
5307 }
5308 private com.google.protobuf.RepeatedFieldBuilder<
5309 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder>
5310 getAuthsFieldBuilder() {
5311 if (authsBuilder_ == null) {
5312 authsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
5313 org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuth.Builder, org.apache.hadoop.ipc.protobuf.RpcHeaderProtos.RpcSaslProto.SaslAuthOrBuilder>(
5314 auths_,
5315 ((bitField0_ & 0x00000008) == 0x00000008),
5316 getParentForChildren(),
5317 isClean());
5318 auths_ = null;
5319 }
5320 return authsBuilder_;
5321 }
5322
5323 // @@protoc_insertion_point(builder_scope:hadoop.common.RpcSaslProto)
5324 }
5325
5326 static {
5327 defaultInstance = new RpcSaslProto(true);
5328 defaultInstance.initFields();
5329 }
5330
5331 // @@protoc_insertion_point(class_scope:hadoop.common.RpcSaslProto)
5332 }
5333
5334 private static com.google.protobuf.Descriptors.Descriptor
5335 internal_static_hadoop_common_RpcRequestHeaderProto_descriptor;
5336 private static
5337 com.google.protobuf.GeneratedMessage.FieldAccessorTable
5338 internal_static_hadoop_common_RpcRequestHeaderProto_fieldAccessorTable;
5339 private static com.google.protobuf.Descriptors.Descriptor
5340 internal_static_hadoop_common_RpcResponseHeaderProto_descriptor;
5341 private static
5342 com.google.protobuf.GeneratedMessage.FieldAccessorTable
5343 internal_static_hadoop_common_RpcResponseHeaderProto_fieldAccessorTable;
5344 private static com.google.protobuf.Descriptors.Descriptor
5345 internal_static_hadoop_common_RpcSaslProto_descriptor;
5346 private static
5347 com.google.protobuf.GeneratedMessage.FieldAccessorTable
5348 internal_static_hadoop_common_RpcSaslProto_fieldAccessorTable;
5349 private static com.google.protobuf.Descriptors.Descriptor
5350 internal_static_hadoop_common_RpcSaslProto_SaslAuth_descriptor;
5351 private static
5352 com.google.protobuf.GeneratedMessage.FieldAccessorTable
5353 internal_static_hadoop_common_RpcSaslProto_SaslAuth_fieldAccessorTable;
5354
5355 public static com.google.protobuf.Descriptors.FileDescriptor
5356 getDescriptor() {
5357 return descriptor;
5358 }
5359 private static com.google.protobuf.Descriptors.FileDescriptor
5360 descriptor;
5361 static {
5362 java.lang.String[] descriptorData = {
5363 "\n\017RpcHeader.proto\022\rhadoop.common\"\242\002\n\025Rpc" +
5364 "RequestHeaderProto\022,\n\007rpcKind\030\001 \001(\0162\033.ha" +
5365 "doop.common.RpcKindProto\022B\n\005rpcOp\030\002 \001(\0162" +
5366 "3.hadoop.common.RpcRequestHeaderProto.Op" +
5367 "erationProto\022\016\n\006callId\030\003 \002(\021\022\020\n\010clientId" +
5368 "\030\004 \002(\014\022\026\n\nretryCount\030\005 \001(\021:\002-1\"]\n\016Operat" +
5369 "ionProto\022\024\n\020RPC_FINAL_PACKET\020\000\022\033\n\027RPC_CO" +
5370 "NTINUATION_PACKET\020\001\022\030\n\024RPC_CLOSE_CONNECT" +
5371 "ION\020\002\"\312\005\n\026RpcResponseHeaderProto\022\016\n\006call" +
5372 "Id\030\001 \002(\r\022D\n\006status\030\002 \002(\01624.hadoop.common",
5373 ".RpcResponseHeaderProto.RpcStatusProto\022\033" +
5374 "\n\023serverIpcVersionNum\030\003 \001(\r\022\032\n\022exception" +
5375 "ClassName\030\004 \001(\t\022\020\n\010errorMsg\030\005 \001(\t\022L\n\013err" +
5376 "orDetail\030\006 \001(\01627.hadoop.common.RpcRespon" +
5377 "seHeaderProto.RpcErrorCodeProto\022\020\n\010clien" +
5378 "tId\030\007 \001(\014\022\026\n\nretryCount\030\010 \001(\021:\002-1\"3\n\016Rpc" +
5379 "StatusProto\022\013\n\007SUCCESS\020\000\022\t\n\005ERROR\020\001\022\t\n\005F" +
5380 "ATAL\020\002\"\341\002\n\021RpcErrorCodeProto\022\025\n\021ERROR_AP" +
5381 "PLICATION\020\001\022\030\n\024ERROR_NO_SUCH_METHOD\020\002\022\032\n" +
5382 "\026ERROR_NO_SUCH_PROTOCOL\020\003\022\024\n\020ERROR_RPC_S",
5383 "ERVER\020\004\022\036\n\032ERROR_SERIALIZING_RESPONSE\020\005\022" +
5384 "\036\n\032ERROR_RPC_VERSION_MISMATCH\020\006\022\021\n\rFATAL" +
5385 "_UNKNOWN\020\n\022#\n\037FATAL_UNSUPPORTED_SERIALIZ" +
5386 "ATION\020\013\022\034\n\030FATAL_INVALID_RPC_HEADER\020\014\022\037\n" +
5387 "\033FATAL_DESERIALIZING_REQUEST\020\r\022\032\n\026FATAL_" +
5388 "VERSION_MISMATCH\020\016\022\026\n\022FATAL_UNAUTHORIZED" +
5389 "\020\017\"\335\002\n\014RpcSaslProto\022\017\n\007version\030\001 \001(\r\0224\n\005" +
5390 "state\030\002 \002(\0162%.hadoop.common.RpcSaslProto" +
5391 ".SaslState\022\r\n\005token\030\003 \001(\014\0223\n\005auths\030\004 \003(\013" +
5392 "2$.hadoop.common.RpcSaslProto.SaslAuth\032d",
5393 "\n\010SaslAuth\022\016\n\006method\030\001 \002(\t\022\021\n\tmechanism\030" +
5394 "\002 \002(\t\022\020\n\010protocol\030\003 \001(\t\022\020\n\010serverId\030\004 \001(" +
5395 "\t\022\021\n\tchallenge\030\005 \001(\014\"\\\n\tSaslState\022\013\n\007SUC" +
5396 "CESS\020\000\022\r\n\tNEGOTIATE\020\001\022\014\n\010INITIATE\020\002\022\r\n\tC" +
5397 "HALLENGE\020\003\022\014\n\010RESPONSE\020\004\022\010\n\004WRAP\020\005*J\n\014Rp" +
5398 "cKindProto\022\017\n\013RPC_BUILTIN\020\000\022\020\n\014RPC_WRITA" +
5399 "BLE\020\001\022\027\n\023RPC_PROTOCOL_BUFFER\020\002B4\n\036org.ap" +
5400 "ache.hadoop.ipc.protobufB\017RpcHeaderProto" +
5401 "s\240\001\001"
5402 };
5403 com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
5404 new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
5405 public com.google.protobuf.ExtensionRegistry assignDescriptors(
5406 com.google.protobuf.Descriptors.FileDescriptor root) {
5407 descriptor = root;
5408 internal_static_hadoop_common_RpcRequestHeaderProto_descriptor =
5409 getDescriptor().getMessageTypes().get(0);
5410 internal_static_hadoop_common_RpcRequestHeaderProto_fieldAccessorTable = new
5411 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
5412 internal_static_hadoop_common_RpcRequestHeaderProto_descriptor,
5413 new java.lang.String[] { "RpcKind", "RpcOp", "CallId", "ClientId", "RetryCount", });
5414 internal_static_hadoop_common_RpcResponseHeaderProto_descriptor =
5415 getDescriptor().getMessageTypes().get(1);
5416 internal_static_hadoop_common_RpcResponseHeaderProto_fieldAccessorTable = new
5417 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
5418 internal_static_hadoop_common_RpcResponseHeaderProto_descriptor,
5419 new java.lang.String[] { "CallId", "Status", "ServerIpcVersionNum", "ExceptionClassName", "ErrorMsg", "ErrorDetail", "ClientId", "RetryCount", });
5420 internal_static_hadoop_common_RpcSaslProto_descriptor =
5421 getDescriptor().getMessageTypes().get(2);
5422 internal_static_hadoop_common_RpcSaslProto_fieldAccessorTable = new
5423 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
5424 internal_static_hadoop_common_RpcSaslProto_descriptor,
5425 new java.lang.String[] { "Version", "State", "Token", "Auths", });
5426 internal_static_hadoop_common_RpcSaslProto_SaslAuth_descriptor =
5427 internal_static_hadoop_common_RpcSaslProto_descriptor.getNestedTypes().get(0);
5428 internal_static_hadoop_common_RpcSaslProto_SaslAuth_fieldAccessorTable = new
5429 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
5430 internal_static_hadoop_common_RpcSaslProto_SaslAuth_descriptor,
5431 new java.lang.String[] { "Method", "Mechanism", "Protocol", "ServerId", "Challenge", });
5432 return null;
5433 }
5434 };
5435 com.google.protobuf.Descriptors.FileDescriptor
5436 .internalBuildGeneratedFileFrom(descriptorData,
5437 new com.google.protobuf.Descriptors.FileDescriptor[] {
5438 }, assigner);
5439 }
5440
5441 // @@protoc_insertion_point(outer_class_scope)
5442 }