implements
+ // @@protoc_insertion_point(builder_implements:grpc.binarylog.v1alpha.GrpcLogEntry)
+ io.grpc.binarylog.GrpcLogEntryOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_GrpcLogEntry_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_GrpcLogEntry_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.GrpcLogEntry.class, io.grpc.binarylog.GrpcLogEntry.Builder.class);
+ }
+
+ // Construct using io.grpc.binarylog.GrpcLogEntry.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessageV3
+ .alwaysUseFieldBuilders) {
+ }
+ }
+ public Builder clear() {
+ super.clear();
+ type_ = 0;
+
+ logger_ = 0;
+
+ if (callIdBuilder_ == null) {
+ callId_ = null;
+ } else {
+ callId_ = null;
+ callIdBuilder_ = null;
+ }
+ if (peerBuilder_ == null) {
+ peer_ = null;
+ } else {
+ peer_ = null;
+ peerBuilder_ = null;
+ }
+ payloadCase_ = 0;
+ payload_ = null;
+ return this;
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_GrpcLogEntry_descriptor;
+ }
+
+ public io.grpc.binarylog.GrpcLogEntry getDefaultInstanceForType() {
+ return io.grpc.binarylog.GrpcLogEntry.getDefaultInstance();
+ }
+
+ public io.grpc.binarylog.GrpcLogEntry build() {
+ io.grpc.binarylog.GrpcLogEntry result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public io.grpc.binarylog.GrpcLogEntry buildPartial() {
+ io.grpc.binarylog.GrpcLogEntry result = new io.grpc.binarylog.GrpcLogEntry(this);
+ result.type_ = type_;
+ result.logger_ = logger_;
+ if (callIdBuilder_ == null) {
+ result.callId_ = callId_;
+ } else {
+ result.callId_ = callIdBuilder_.build();
+ }
+ if (payloadCase_ == 4) {
+ if (metadataBuilder_ == null) {
+ result.payload_ = payload_;
+ } else {
+ result.payload_ = metadataBuilder_.build();
+ }
+ }
+ if (payloadCase_ == 5) {
+ if (messageBuilder_ == null) {
+ result.payload_ = payload_;
+ } else {
+ result.payload_ = messageBuilder_.build();
+ }
+ }
+ if (peerBuilder_ == null) {
+ result.peer_ = peer_;
+ } else {
+ result.peer_ = peerBuilder_.build();
+ }
+ result.payloadCase_ = payloadCase_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder clone() {
+ return (Builder) super.clone();
+ }
+ public Builder setField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.setField(field, value);
+ }
+ public Builder clearField(
+ com.google.protobuf.Descriptors.FieldDescriptor field) {
+ return (Builder) super.clearField(field);
+ }
+ public Builder clearOneof(
+ com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+ return (Builder) super.clearOneof(oneof);
+ }
+ public Builder setRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ int index, java.lang.Object value) {
+ return (Builder) super.setRepeatedField(field, index, value);
+ }
+ public Builder addRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.addRepeatedField(field, value);
+ }
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof io.grpc.binarylog.GrpcLogEntry) {
+ return mergeFrom((io.grpc.binarylog.GrpcLogEntry)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(io.grpc.binarylog.GrpcLogEntry other) {
+ if (other == io.grpc.binarylog.GrpcLogEntry.getDefaultInstance()) return this;
+ if (other.type_ != 0) {
+ setTypeValue(other.getTypeValue());
+ }
+ if (other.logger_ != 0) {
+ setLoggerValue(other.getLoggerValue());
+ }
+ if (other.hasCallId()) {
+ mergeCallId(other.getCallId());
+ }
+ if (other.hasPeer()) {
+ mergePeer(other.getPeer());
+ }
+ switch (other.getPayloadCase()) {
+ case METADATA: {
+ mergeMetadata(other.getMetadata());
+ break;
+ }
+ case MESSAGE: {
+ mergeMessage(other.getMessage());
+ break;
+ }
+ case PAYLOAD_NOT_SET: {
+ break;
+ }
+ }
+ this.mergeUnknownFields(other.unknownFields);
+ onChanged();
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ io.grpc.binarylog.GrpcLogEntry parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (io.grpc.binarylog.GrpcLogEntry) e.getUnfinishedMessage();
+ throw e.unwrapIOException();
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int payloadCase_ = 0;
+ private java.lang.Object payload_;
+ public PayloadCase
+ getPayloadCase() {
+ return PayloadCase.forNumber(
+ payloadCase_);
+ }
+
+ public Builder clearPayload() {
+ payloadCase_ = 0;
+ payload_ = null;
+ onChanged();
+ return this;
+ }
+
+
+ private int type_ = 0;
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ public int getTypeValue() {
+ return type_;
+ }
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ public Builder setTypeValue(int value) {
+ type_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ public io.grpc.binarylog.GrpcLogEntry.Type getType() {
+ io.grpc.binarylog.GrpcLogEntry.Type result = io.grpc.binarylog.GrpcLogEntry.Type.valueOf(type_);
+ return result == null ? io.grpc.binarylog.GrpcLogEntry.Type.UNRECOGNIZED : result;
+ }
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ public Builder setType(io.grpc.binarylog.GrpcLogEntry.Type value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ type_ = value.getNumber();
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ public Builder clearType() {
+
+ type_ = 0;
+ onChanged();
+ return this;
+ }
+
+ private int logger_ = 0;
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ public int getLoggerValue() {
+ return logger_;
+ }
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ public Builder setLoggerValue(int value) {
+ logger_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ public io.grpc.binarylog.GrpcLogEntry.Logger getLogger() {
+ io.grpc.binarylog.GrpcLogEntry.Logger result = io.grpc.binarylog.GrpcLogEntry.Logger.valueOf(logger_);
+ return result == null ? io.grpc.binarylog.GrpcLogEntry.Logger.UNRECOGNIZED : result;
+ }
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ public Builder setLogger(io.grpc.binarylog.GrpcLogEntry.Logger value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ logger_ = value.getNumber();
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ public Builder clearLogger() {
+
+ logger_ = 0;
+ onChanged();
+ return this;
+ }
+
+ private io.grpc.binarylog.Uint128 callId_ = null;
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Uint128, io.grpc.binarylog.Uint128.Builder, io.grpc.binarylog.Uint128OrBuilder> callIdBuilder_;
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public boolean hasCallId() {
+ return callIdBuilder_ != null || callId_ != null;
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public io.grpc.binarylog.Uint128 getCallId() {
+ if (callIdBuilder_ == null) {
+ return callId_ == null ? io.grpc.binarylog.Uint128.getDefaultInstance() : callId_;
+ } else {
+ return callIdBuilder_.getMessage();
+ }
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public Builder setCallId(io.grpc.binarylog.Uint128 value) {
+ if (callIdBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ callId_ = value;
+ onChanged();
+ } else {
+ callIdBuilder_.setMessage(value);
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public Builder setCallId(
+ io.grpc.binarylog.Uint128.Builder builderForValue) {
+ if (callIdBuilder_ == null) {
+ callId_ = builderForValue.build();
+ onChanged();
+ } else {
+ callIdBuilder_.setMessage(builderForValue.build());
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public Builder mergeCallId(io.grpc.binarylog.Uint128 value) {
+ if (callIdBuilder_ == null) {
+ if (callId_ != null) {
+ callId_ =
+ io.grpc.binarylog.Uint128.newBuilder(callId_).mergeFrom(value).buildPartial();
+ } else {
+ callId_ = value;
+ }
+ onChanged();
+ } else {
+ callIdBuilder_.mergeFrom(value);
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public Builder clearCallId() {
+ if (callIdBuilder_ == null) {
+ callId_ = null;
+ onChanged();
+ } else {
+ callId_ = null;
+ callIdBuilder_ = null;
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public io.grpc.binarylog.Uint128.Builder getCallIdBuilder() {
+
+ onChanged();
+ return getCallIdFieldBuilder().getBuilder();
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ public io.grpc.binarylog.Uint128OrBuilder getCallIdOrBuilder() {
+ if (callIdBuilder_ != null) {
+ return callIdBuilder_.getMessageOrBuilder();
+ } else {
+ return callId_ == null ?
+ io.grpc.binarylog.Uint128.getDefaultInstance() : callId_;
+ }
+ }
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Uint128, io.grpc.binarylog.Uint128.Builder, io.grpc.binarylog.Uint128OrBuilder>
+ getCallIdFieldBuilder() {
+ if (callIdBuilder_ == null) {
+ callIdBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Uint128, io.grpc.binarylog.Uint128.Builder, io.grpc.binarylog.Uint128OrBuilder>(
+ getCallId(),
+ getParentForChildren(),
+ isClean());
+ callId_ = null;
+ }
+ return callIdBuilder_;
+ }
+
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Metadata, io.grpc.binarylog.Metadata.Builder, io.grpc.binarylog.MetadataOrBuilder> metadataBuilder_;
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public boolean hasMetadata() {
+ return payloadCase_ == 4;
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public io.grpc.binarylog.Metadata getMetadata() {
+ if (metadataBuilder_ == null) {
+ if (payloadCase_ == 4) {
+ return (io.grpc.binarylog.Metadata) payload_;
+ }
+ return io.grpc.binarylog.Metadata.getDefaultInstance();
+ } else {
+ if (payloadCase_ == 4) {
+ return metadataBuilder_.getMessage();
+ }
+ return io.grpc.binarylog.Metadata.getDefaultInstance();
+ }
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public Builder setMetadata(io.grpc.binarylog.Metadata value) {
+ if (metadataBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ payload_ = value;
+ onChanged();
+ } else {
+ metadataBuilder_.setMessage(value);
+ }
+ payloadCase_ = 4;
+ return this;
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public Builder setMetadata(
+ io.grpc.binarylog.Metadata.Builder builderForValue) {
+ if (metadataBuilder_ == null) {
+ payload_ = builderForValue.build();
+ onChanged();
+ } else {
+ metadataBuilder_.setMessage(builderForValue.build());
+ }
+ payloadCase_ = 4;
+ return this;
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public Builder mergeMetadata(io.grpc.binarylog.Metadata value) {
+ if (metadataBuilder_ == null) {
+ if (payloadCase_ == 4 &&
+ payload_ != io.grpc.binarylog.Metadata.getDefaultInstance()) {
+ payload_ = io.grpc.binarylog.Metadata.newBuilder((io.grpc.binarylog.Metadata) payload_)
+ .mergeFrom(value).buildPartial();
+ } else {
+ payload_ = value;
+ }
+ onChanged();
+ } else {
+ if (payloadCase_ == 4) {
+ metadataBuilder_.mergeFrom(value);
+ }
+ metadataBuilder_.setMessage(value);
+ }
+ payloadCase_ = 4;
+ return this;
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public Builder clearMetadata() {
+ if (metadataBuilder_ == null) {
+ if (payloadCase_ == 4) {
+ payloadCase_ = 0;
+ payload_ = null;
+ onChanged();
+ }
+ } else {
+ if (payloadCase_ == 4) {
+ payloadCase_ = 0;
+ payload_ = null;
+ }
+ metadataBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public io.grpc.binarylog.Metadata.Builder getMetadataBuilder() {
+ return getMetadataFieldBuilder().getBuilder();
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ public io.grpc.binarylog.MetadataOrBuilder getMetadataOrBuilder() {
+ if ((payloadCase_ == 4) && (metadataBuilder_ != null)) {
+ return metadataBuilder_.getMessageOrBuilder();
+ } else {
+ if (payloadCase_ == 4) {
+ return (io.grpc.binarylog.Metadata) payload_;
+ }
+ return io.grpc.binarylog.Metadata.getDefaultInstance();
+ }
+ }
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Metadata, io.grpc.binarylog.Metadata.Builder, io.grpc.binarylog.MetadataOrBuilder>
+ getMetadataFieldBuilder() {
+ if (metadataBuilder_ == null) {
+ if (!(payloadCase_ == 4)) {
+ payload_ = io.grpc.binarylog.Metadata.getDefaultInstance();
+ }
+ metadataBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Metadata, io.grpc.binarylog.Metadata.Builder, io.grpc.binarylog.MetadataOrBuilder>(
+ (io.grpc.binarylog.Metadata) payload_,
+ getParentForChildren(),
+ isClean());
+ payload_ = null;
+ }
+ payloadCase_ = 4;
+ onChanged();;
+ return metadataBuilder_;
+ }
+
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Message, io.grpc.binarylog.Message.Builder, io.grpc.binarylog.MessageOrBuilder> messageBuilder_;
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public boolean hasMessage() {
+ return payloadCase_ == 5;
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public io.grpc.binarylog.Message getMessage() {
+ if (messageBuilder_ == null) {
+ if (payloadCase_ == 5) {
+ return (io.grpc.binarylog.Message) payload_;
+ }
+ return io.grpc.binarylog.Message.getDefaultInstance();
+ } else {
+ if (payloadCase_ == 5) {
+ return messageBuilder_.getMessage();
+ }
+ return io.grpc.binarylog.Message.getDefaultInstance();
+ }
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public Builder setMessage(io.grpc.binarylog.Message value) {
+ if (messageBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ payload_ = value;
+ onChanged();
+ } else {
+ messageBuilder_.setMessage(value);
+ }
+ payloadCase_ = 5;
+ return this;
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public Builder setMessage(
+ io.grpc.binarylog.Message.Builder builderForValue) {
+ if (messageBuilder_ == null) {
+ payload_ = builderForValue.build();
+ onChanged();
+ } else {
+ messageBuilder_.setMessage(builderForValue.build());
+ }
+ payloadCase_ = 5;
+ return this;
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public Builder mergeMessage(io.grpc.binarylog.Message value) {
+ if (messageBuilder_ == null) {
+ if (payloadCase_ == 5 &&
+ payload_ != io.grpc.binarylog.Message.getDefaultInstance()) {
+ payload_ = io.grpc.binarylog.Message.newBuilder((io.grpc.binarylog.Message) payload_)
+ .mergeFrom(value).buildPartial();
+ } else {
+ payload_ = value;
+ }
+ onChanged();
+ } else {
+ if (payloadCase_ == 5) {
+ messageBuilder_.mergeFrom(value);
+ }
+ messageBuilder_.setMessage(value);
+ }
+ payloadCase_ = 5;
+ return this;
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public Builder clearMessage() {
+ if (messageBuilder_ == null) {
+ if (payloadCase_ == 5) {
+ payloadCase_ = 0;
+ payload_ = null;
+ onChanged();
+ }
+ } else {
+ if (payloadCase_ == 5) {
+ payloadCase_ = 0;
+ payload_ = null;
+ }
+ messageBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public io.grpc.binarylog.Message.Builder getMessageBuilder() {
+ return getMessageFieldBuilder().getBuilder();
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ public io.grpc.binarylog.MessageOrBuilder getMessageOrBuilder() {
+ if ((payloadCase_ == 5) && (messageBuilder_ != null)) {
+ return messageBuilder_.getMessageOrBuilder();
+ } else {
+ if (payloadCase_ == 5) {
+ return (io.grpc.binarylog.Message) payload_;
+ }
+ return io.grpc.binarylog.Message.getDefaultInstance();
+ }
+ }
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Message, io.grpc.binarylog.Message.Builder, io.grpc.binarylog.MessageOrBuilder>
+ getMessageFieldBuilder() {
+ if (messageBuilder_ == null) {
+ if (!(payloadCase_ == 5)) {
+ payload_ = io.grpc.binarylog.Message.getDefaultInstance();
+ }
+ messageBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Message, io.grpc.binarylog.Message.Builder, io.grpc.binarylog.MessageOrBuilder>(
+ (io.grpc.binarylog.Message) payload_,
+ getParentForChildren(),
+ isClean());
+ payload_ = null;
+ }
+ payloadCase_ = 5;
+ onChanged();;
+ return messageBuilder_;
+ }
+
+ private io.grpc.binarylog.Peer peer_ = null;
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Peer, io.grpc.binarylog.Peer.Builder, io.grpc.binarylog.PeerOrBuilder> peerBuilder_;
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public boolean hasPeer() {
+ return peerBuilder_ != null || peer_ != null;
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public io.grpc.binarylog.Peer getPeer() {
+ if (peerBuilder_ == null) {
+ return peer_ == null ? io.grpc.binarylog.Peer.getDefaultInstance() : peer_;
+ } else {
+ return peerBuilder_.getMessage();
+ }
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public Builder setPeer(io.grpc.binarylog.Peer value) {
+ if (peerBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ peer_ = value;
+ onChanged();
+ } else {
+ peerBuilder_.setMessage(value);
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public Builder setPeer(
+ io.grpc.binarylog.Peer.Builder builderForValue) {
+ if (peerBuilder_ == null) {
+ peer_ = builderForValue.build();
+ onChanged();
+ } else {
+ peerBuilder_.setMessage(builderForValue.build());
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public Builder mergePeer(io.grpc.binarylog.Peer value) {
+ if (peerBuilder_ == null) {
+ if (peer_ != null) {
+ peer_ =
+ io.grpc.binarylog.Peer.newBuilder(peer_).mergeFrom(value).buildPartial();
+ } else {
+ peer_ = value;
+ }
+ onChanged();
+ } else {
+ peerBuilder_.mergeFrom(value);
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public Builder clearPeer() {
+ if (peerBuilder_ == null) {
+ peer_ = null;
+ onChanged();
+ } else {
+ peer_ = null;
+ peerBuilder_ = null;
+ }
+
+ return this;
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public io.grpc.binarylog.Peer.Builder getPeerBuilder() {
+
+ onChanged();
+ return getPeerFieldBuilder().getBuilder();
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ public io.grpc.binarylog.PeerOrBuilder getPeerOrBuilder() {
+ if (peerBuilder_ != null) {
+ return peerBuilder_.getMessageOrBuilder();
+ } else {
+ return peer_ == null ?
+ io.grpc.binarylog.Peer.getDefaultInstance() : peer_;
+ }
+ }
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ private com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Peer, io.grpc.binarylog.Peer.Builder, io.grpc.binarylog.PeerOrBuilder>
+ getPeerFieldBuilder() {
+ if (peerBuilder_ == null) {
+ peerBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+ io.grpc.binarylog.Peer, io.grpc.binarylog.Peer.Builder, io.grpc.binarylog.PeerOrBuilder>(
+ getPeer(),
+ getParentForChildren(),
+ isClean());
+ peer_ = null;
+ }
+ return peerBuilder_;
+ }
+ public final Builder setUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.setUnknownFieldsProto3(unknownFields);
+ }
+
+ public final Builder mergeUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.mergeUnknownFields(unknownFields);
+ }
+
+
+ // @@protoc_insertion_point(builder_scope:grpc.binarylog.v1alpha.GrpcLogEntry)
+ }
+
+ // @@protoc_insertion_point(class_scope:grpc.binarylog.v1alpha.GrpcLogEntry)
+ private static final io.grpc.binarylog.GrpcLogEntry DEFAULT_INSTANCE;
+ static {
+ DEFAULT_INSTANCE = new io.grpc.binarylog.GrpcLogEntry();
+ }
+
+ public static io.grpc.binarylog.GrpcLogEntry getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ private static final com.google.protobuf.Parser
+ PARSER = new com.google.protobuf.AbstractParser() {
+ public GrpcLogEntry parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new GrpcLogEntry(input, extensionRegistry);
+ }
+ };
+
+ public static com.google.protobuf.Parser parser() {
+ return PARSER;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Parser getParserForType() {
+ return PARSER;
+ }
+
+ public io.grpc.binarylog.GrpcLogEntry getDefaultInstanceForType() {
+ return DEFAULT_INSTANCE;
+ }
+
+}
+
diff --git a/services/src/generated/main/java/io/grpc/binarylog/GrpcLogEntryOrBuilder.java b/services/src/generated/main/java/io/grpc/binarylog/GrpcLogEntryOrBuilder.java
new file mode 100644
index 0000000000..de4d9b9f45
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/GrpcLogEntryOrBuilder.java
@@ -0,0 +1,151 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+public interface GrpcLogEntryOrBuilder extends
+ // @@protoc_insertion_point(interface_extends:grpc.binarylog.v1alpha.GrpcLogEntry)
+ com.google.protobuf.MessageOrBuilder {
+
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ int getTypeValue();
+ /**
+ *
+ * One of the above Type enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Type type = 1;
+ */
+ io.grpc.binarylog.GrpcLogEntry.Type getType();
+
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ int getLoggerValue();
+ /**
+ *
+ * One of the above Logger enum
+ *
+ *
+ * .grpc.binarylog.v1alpha.GrpcLogEntry.Logger logger = 2;
+ */
+ io.grpc.binarylog.GrpcLogEntry.Logger getLogger();
+
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ boolean hasCallId();
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ io.grpc.binarylog.Uint128 getCallId();
+ /**
+ *
+ * Uniquely identifies a call. Each call may have several log entries, they
+ * will share the same call_id. 128 bits split into 2 64-bit parts.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Uint128 call_id = 3;
+ */
+ io.grpc.binarylog.Uint128OrBuilder getCallIdOrBuilder();
+
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ boolean hasMetadata();
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ io.grpc.binarylog.Metadata getMetadata();
+ /**
+ *
+ * Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ *
+ *
+ * .grpc.binarylog.v1alpha.Metadata metadata = 4;
+ */
+ io.grpc.binarylog.MetadataOrBuilder getMetadataOrBuilder();
+
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ boolean hasMessage();
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ io.grpc.binarylog.Message getMessage();
+ /**
+ *
+ * Used by REQUEST and RESPONSE
+ *
+ *
+ * .grpc.binarylog.v1alpha.Message message = 5;
+ */
+ io.grpc.binarylog.MessageOrBuilder getMessageOrBuilder();
+
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ boolean hasPeer();
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ io.grpc.binarylog.Peer getPeer();
+ /**
+ *
+ * Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ * and RECV_INITIAL_METADATA entries.
+ *
+ *
+ * .grpc.binarylog.v1alpha.Peer peer = 6;
+ */
+ io.grpc.binarylog.PeerOrBuilder getPeerOrBuilder();
+
+ public io.grpc.binarylog.GrpcLogEntry.PayloadCase getPayloadCase();
+}
diff --git a/services/src/generated/main/java/io/grpc/binarylog/Message.java b/services/src/generated/main/java/io/grpc/binarylog/Message.java
new file mode 100644
index 0000000000..1f5bdddca3
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/Message.java
@@ -0,0 +1,646 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+/**
+ *
+ * Message payload, used by REQUEST and RESPONSE
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Message}
+ */
+public final class Message extends
+ com.google.protobuf.GeneratedMessageV3 implements
+ // @@protoc_insertion_point(message_implements:grpc.binarylog.v1alpha.Message)
+ MessageOrBuilder {
+private static final long serialVersionUID = 0L;
+ // Use Message.newBuilder() to construct.
+ private Message(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+ super(builder);
+ }
+ private Message() {
+ flags_ = 0;
+ length_ = 0;
+ data_ = com.google.protobuf.ByteString.EMPTY;
+ }
+
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private Message(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ this();
+ if (extensionRegistry == null) {
+ throw new java.lang.NullPointerException();
+ }
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownFieldProto3(
+ input, unknownFields, extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+
+ flags_ = input.readUInt32();
+ break;
+ }
+ case 16: {
+
+ length_ = input.readUInt32();
+ break;
+ }
+ case 26: {
+
+ data_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Message_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Message_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Message.class, io.grpc.binarylog.Message.Builder.class);
+ }
+
+ public static final int FLAGS_FIELD_NUMBER = 1;
+ private int flags_;
+ /**
+ *
+ * This flag is currently used to indicate whether the payload is compressed,
+ * it may contain other semantics in the future. Value of 1 indicates that the
+ * binary octet sequence of Message is compressed using the mechanism declared
+ * by the Message-Encoding header. A value of 0 indicates that no encoding of
+ * Message bytes has occurred.
+ *
+ *
+ * uint32 flags = 1;
+ */
+ public int getFlags() {
+ return flags_;
+ }
+
+ public static final int LENGTH_FIELD_NUMBER = 2;
+ private int length_;
+ /**
+ *
+ * Length of the message. It may not be the same as the length of the
+ * data field, as the logging payload can be truncated or omitted.
+ *
+ *
+ * uint32 length = 2;
+ */
+ public int getLength() {
+ return length_;
+ }
+
+ public static final int DATA_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString data_;
+ /**
+ *
+ * Binary payload, post compression (depends on the flags field), may be
+ * truncated or omitted.
+ *
+ *
+ * bytes data = 3;
+ */
+ public com.google.protobuf.ByteString getData() {
+ return data_;
+ }
+
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized == 1) return true;
+ if (isInitialized == 0) return false;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ if (flags_ != 0) {
+ output.writeUInt32(1, flags_);
+ }
+ if (length_ != 0) {
+ output.writeUInt32(2, length_);
+ }
+ if (!data_.isEmpty()) {
+ output.writeBytes(3, data_);
+ }
+ unknownFields.writeTo(output);
+ }
+
+ public int getSerializedSize() {
+ int size = memoizedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (flags_ != 0) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, flags_);
+ }
+ if (length_ != 0) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(2, length_);
+ }
+ if (!data_.isEmpty()) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, data_);
+ }
+ size += unknownFields.getSerializedSize();
+ memoizedSize = size;
+ return size;
+ }
+
+ @java.lang.Override
+ public boolean equals(final java.lang.Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof io.grpc.binarylog.Message)) {
+ return super.equals(obj);
+ }
+ io.grpc.binarylog.Message other = (io.grpc.binarylog.Message) obj;
+
+ boolean result = true;
+ result = result && (getFlags()
+ == other.getFlags());
+ result = result && (getLength()
+ == other.getLength());
+ result = result && getData()
+ .equals(other.getData());
+ result = result && unknownFields.equals(other.unknownFields);
+ return result;
+ }
+
+ @java.lang.Override
+ public int hashCode() {
+ if (memoizedHashCode != 0) {
+ return memoizedHashCode;
+ }
+ int hash = 41;
+ hash = (19 * hash) + getDescriptor().hashCode();
+ hash = (37 * hash) + FLAGS_FIELD_NUMBER;
+ hash = (53 * hash) + getFlags();
+ hash = (37 * hash) + LENGTH_FIELD_NUMBER;
+ hash = (53 * hash) + getLength();
+ hash = (37 * hash) + DATA_FIELD_NUMBER;
+ hash = (53 * hash) + getData().hashCode();
+ hash = (29 * hash) + unknownFields.hashCode();
+ memoizedHashCode = hash;
+ return hash;
+ }
+
+ public static io.grpc.binarylog.Message parseFrom(
+ java.nio.ByteBuffer data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ java.nio.ByteBuffer data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Message parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Message parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Message parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Message parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Message parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder() {
+ return DEFAULT_INSTANCE.toBuilder();
+ }
+ public static Builder newBuilder(io.grpc.binarylog.Message prototype) {
+ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() {
+ return this == DEFAULT_INSTANCE
+ ? new Builder() : new Builder().mergeFrom(this);
+ }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ *
+ * Message payload, used by REQUEST and RESPONSE
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Message}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageV3.Builder implements
+ // @@protoc_insertion_point(builder_implements:grpc.binarylog.v1alpha.Message)
+ io.grpc.binarylog.MessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Message_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Message_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Message.class, io.grpc.binarylog.Message.Builder.class);
+ }
+
+ // Construct using io.grpc.binarylog.Message.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessageV3
+ .alwaysUseFieldBuilders) {
+ }
+ }
+ public Builder clear() {
+ super.clear();
+ flags_ = 0;
+
+ length_ = 0;
+
+ data_ = com.google.protobuf.ByteString.EMPTY;
+
+ return this;
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Message_descriptor;
+ }
+
+ public io.grpc.binarylog.Message getDefaultInstanceForType() {
+ return io.grpc.binarylog.Message.getDefaultInstance();
+ }
+
+ public io.grpc.binarylog.Message build() {
+ io.grpc.binarylog.Message result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public io.grpc.binarylog.Message buildPartial() {
+ io.grpc.binarylog.Message result = new io.grpc.binarylog.Message(this);
+ result.flags_ = flags_;
+ result.length_ = length_;
+ result.data_ = data_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder clone() {
+ return (Builder) super.clone();
+ }
+ public Builder setField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.setField(field, value);
+ }
+ public Builder clearField(
+ com.google.protobuf.Descriptors.FieldDescriptor field) {
+ return (Builder) super.clearField(field);
+ }
+ public Builder clearOneof(
+ com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+ return (Builder) super.clearOneof(oneof);
+ }
+ public Builder setRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ int index, java.lang.Object value) {
+ return (Builder) super.setRepeatedField(field, index, value);
+ }
+ public Builder addRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.addRepeatedField(field, value);
+ }
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof io.grpc.binarylog.Message) {
+ return mergeFrom((io.grpc.binarylog.Message)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(io.grpc.binarylog.Message other) {
+ if (other == io.grpc.binarylog.Message.getDefaultInstance()) return this;
+ if (other.getFlags() != 0) {
+ setFlags(other.getFlags());
+ }
+ if (other.getLength() != 0) {
+ setLength(other.getLength());
+ }
+ if (other.getData() != com.google.protobuf.ByteString.EMPTY) {
+ setData(other.getData());
+ }
+ this.mergeUnknownFields(other.unknownFields);
+ onChanged();
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ io.grpc.binarylog.Message parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (io.grpc.binarylog.Message) e.getUnfinishedMessage();
+ throw e.unwrapIOException();
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ private int flags_ ;
+ /**
+ *
+ * This flag is currently used to indicate whether the payload is compressed,
+ * it may contain other semantics in the future. Value of 1 indicates that the
+ * binary octet sequence of Message is compressed using the mechanism declared
+ * by the Message-Encoding header. A value of 0 indicates that no encoding of
+ * Message bytes has occurred.
+ *
+ *
+ * uint32 flags = 1;
+ */
+ public int getFlags() {
+ return flags_;
+ }
+ /**
+ *
+ * This flag is currently used to indicate whether the payload is compressed,
+ * it may contain other semantics in the future. Value of 1 indicates that the
+ * binary octet sequence of Message is compressed using the mechanism declared
+ * by the Message-Encoding header. A value of 0 indicates that no encoding of
+ * Message bytes has occurred.
+ *
+ *
+ * uint32 flags = 1;
+ */
+ public Builder setFlags(int value) {
+
+ flags_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * This flag is currently used to indicate whether the payload is compressed,
+ * it may contain other semantics in the future. Value of 1 indicates that the
+ * binary octet sequence of Message is compressed using the mechanism declared
+ * by the Message-Encoding header. A value of 0 indicates that no encoding of
+ * Message bytes has occurred.
+ *
+ *
+ * uint32 flags = 1;
+ */
+ public Builder clearFlags() {
+
+ flags_ = 0;
+ onChanged();
+ return this;
+ }
+
+ private int length_ ;
+ /**
+ *
+ * Length of the message. It may not be the same as the length of the
+ * data field, as the logging payload can be truncated or omitted.
+ *
+ *
+ * uint32 length = 2;
+ */
+ public int getLength() {
+ return length_;
+ }
+ /**
+ *
+ * Length of the message. It may not be the same as the length of the
+ * data field, as the logging payload can be truncated or omitted.
+ *
+ *
+ * uint32 length = 2;
+ */
+ public Builder setLength(int value) {
+
+ length_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * Length of the message. It may not be the same as the length of the
+ * data field, as the logging payload can be truncated or omitted.
+ *
+ *
+ * uint32 length = 2;
+ */
+ public Builder clearLength() {
+
+ length_ = 0;
+ onChanged();
+ return this;
+ }
+
+ private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ *
+ * Binary payload, post compression (depends on the flags field), may be
+ * truncated or omitted.
+ *
+ *
+ * bytes data = 3;
+ */
+ public com.google.protobuf.ByteString getData() {
+ return data_;
+ }
+ /**
+ *
+ * Binary payload, post compression (depends on the flags field), may be
+ * truncated or omitted.
+ *
+ *
+ * bytes data = 3;
+ */
+ public Builder setData(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ data_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * Binary payload, post compression (depends on the flags field), may be
+ * truncated or omitted.
+ *
+ *
+ * bytes data = 3;
+ */
+ public Builder clearData() {
+
+ data_ = getDefaultInstance().getData();
+ onChanged();
+ return this;
+ }
+ public final Builder setUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.setUnknownFieldsProto3(unknownFields);
+ }
+
+ public final Builder mergeUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.mergeUnknownFields(unknownFields);
+ }
+
+
+ // @@protoc_insertion_point(builder_scope:grpc.binarylog.v1alpha.Message)
+ }
+
+ // @@protoc_insertion_point(class_scope:grpc.binarylog.v1alpha.Message)
+ private static final io.grpc.binarylog.Message DEFAULT_INSTANCE;
+ static {
+ DEFAULT_INSTANCE = new io.grpc.binarylog.Message();
+ }
+
+ public static io.grpc.binarylog.Message getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ private static final com.google.protobuf.Parser
+ PARSER = new com.google.protobuf.AbstractParser() {
+ public Message parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new Message(input, extensionRegistry);
+ }
+ };
+
+ public static com.google.protobuf.Parser parser() {
+ return PARSER;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Parser getParserForType() {
+ return PARSER;
+ }
+
+ public io.grpc.binarylog.Message getDefaultInstanceForType() {
+ return DEFAULT_INSTANCE;
+ }
+
+}
+
diff --git a/services/src/generated/main/java/io/grpc/binarylog/MessageOrBuilder.java b/services/src/generated/main/java/io/grpc/binarylog/MessageOrBuilder.java
new file mode 100644
index 0000000000..9d905230fb
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/MessageOrBuilder.java
@@ -0,0 +1,42 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+public interface MessageOrBuilder extends
+ // @@protoc_insertion_point(interface_extends:grpc.binarylog.v1alpha.Message)
+ com.google.protobuf.MessageOrBuilder {
+
+ /**
+ *
+ * This flag is currently used to indicate whether the payload is compressed,
+ * it may contain other semantics in the future. Value of 1 indicates that the
+ * binary octet sequence of Message is compressed using the mechanism declared
+ * by the Message-Encoding header. A value of 0 indicates that no encoding of
+ * Message bytes has occurred.
+ *
+ *
+ * uint32 flags = 1;
+ */
+ int getFlags();
+
+ /**
+ *
+ * Length of the message. It may not be the same as the length of the
+ * data field, as the logging payload can be truncated or omitted.
+ *
+ *
+ * uint32 length = 2;
+ */
+ int getLength();
+
+ /**
+ *
+ * Binary payload, post compression (depends on the flags field), may be
+ * truncated or omitted.
+ *
+ *
+ * bytes data = 3;
+ */
+ com.google.protobuf.ByteString getData();
+}
diff --git a/services/src/generated/main/java/io/grpc/binarylog/Metadata.java b/services/src/generated/main/java/io/grpc/binarylog/Metadata.java
new file mode 100644
index 0000000000..c1875a71df
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/Metadata.java
@@ -0,0 +1,748 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+/**
+ *
+ * A list of metadata pairs, used in the payload of CLIENT_INIT_METADATA,
+ * SERVER_INIT_METADATA and TRAILING_METADATA
+ * Implementations may omit some entries to honor the header limits
+ * of GRPC_BINARY_LOG_CONFIG. Implementations can choose which entries are logged.
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Metadata}
+ */
+public final class Metadata extends
+ com.google.protobuf.GeneratedMessageV3 implements
+ // @@protoc_insertion_point(message_implements:grpc.binarylog.v1alpha.Metadata)
+ MetadataOrBuilder {
+private static final long serialVersionUID = 0L;
+ // Use Metadata.newBuilder() to construct.
+ private Metadata(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+ super(builder);
+ }
+ private Metadata() {
+ entry_ = java.util.Collections.emptyList();
+ }
+
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private Metadata(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ this();
+ if (extensionRegistry == null) {
+ throw new java.lang.NullPointerException();
+ }
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownFieldProto3(
+ input, unknownFields, extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+ entry_ = new java.util.ArrayList();
+ mutable_bitField0_ |= 0x00000001;
+ }
+ entry_.add(
+ input.readMessage(io.grpc.binarylog.MetadataEntry.parser(), extensionRegistry));
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+ entry_ = java.util.Collections.unmodifiableList(entry_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Metadata_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Metadata_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Metadata.class, io.grpc.binarylog.Metadata.Builder.class);
+ }
+
+ public static final int ENTRY_FIELD_NUMBER = 1;
+ private java.util.List entry_;
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public java.util.List getEntryList() {
+ return entry_;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public java.util.List
+ getEntryOrBuilderList() {
+ return entry_;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public int getEntryCount() {
+ return entry_.size();
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntry getEntry(int index) {
+ return entry_.get(index);
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntryOrBuilder getEntryOrBuilder(
+ int index) {
+ return entry_.get(index);
+ }
+
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized == 1) return true;
+ if (isInitialized == 0) return false;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ for (int i = 0; i < entry_.size(); i++) {
+ output.writeMessage(1, entry_.get(i));
+ }
+ unknownFields.writeTo(output);
+ }
+
+ public int getSerializedSize() {
+ int size = memoizedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ for (int i = 0; i < entry_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(1, entry_.get(i));
+ }
+ size += unknownFields.getSerializedSize();
+ memoizedSize = size;
+ return size;
+ }
+
+ @java.lang.Override
+ public boolean equals(final java.lang.Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof io.grpc.binarylog.Metadata)) {
+ return super.equals(obj);
+ }
+ io.grpc.binarylog.Metadata other = (io.grpc.binarylog.Metadata) obj;
+
+ boolean result = true;
+ result = result && getEntryList()
+ .equals(other.getEntryList());
+ result = result && unknownFields.equals(other.unknownFields);
+ return result;
+ }
+
+ @java.lang.Override
+ public int hashCode() {
+ if (memoizedHashCode != 0) {
+ return memoizedHashCode;
+ }
+ int hash = 41;
+ hash = (19 * hash) + getDescriptor().hashCode();
+ if (getEntryCount() > 0) {
+ hash = (37 * hash) + ENTRY_FIELD_NUMBER;
+ hash = (53 * hash) + getEntryList().hashCode();
+ }
+ hash = (29 * hash) + unknownFields.hashCode();
+ memoizedHashCode = hash;
+ return hash;
+ }
+
+ public static io.grpc.binarylog.Metadata parseFrom(
+ java.nio.ByteBuffer data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ java.nio.ByteBuffer data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Metadata parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Metadata parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Metadata parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder() {
+ return DEFAULT_INSTANCE.toBuilder();
+ }
+ public static Builder newBuilder(io.grpc.binarylog.Metadata prototype) {
+ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() {
+ return this == DEFAULT_INSTANCE
+ ? new Builder() : new Builder().mergeFrom(this);
+ }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ *
+ * A list of metadata pairs, used in the payload of CLIENT_INIT_METADATA,
+ * SERVER_INIT_METADATA and TRAILING_METADATA
+ * Implementations may omit some entries to honor the header limits
+ * of GRPC_BINARY_LOG_CONFIG. Implementations can choose which entries are logged.
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Metadata}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageV3.Builder implements
+ // @@protoc_insertion_point(builder_implements:grpc.binarylog.v1alpha.Metadata)
+ io.grpc.binarylog.MetadataOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Metadata_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Metadata_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Metadata.class, io.grpc.binarylog.Metadata.Builder.class);
+ }
+
+ // Construct using io.grpc.binarylog.Metadata.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessageV3
+ .alwaysUseFieldBuilders) {
+ getEntryFieldBuilder();
+ }
+ }
+ public Builder clear() {
+ super.clear();
+ if (entryBuilder_ == null) {
+ entry_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000001);
+ } else {
+ entryBuilder_.clear();
+ }
+ return this;
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Metadata_descriptor;
+ }
+
+ public io.grpc.binarylog.Metadata getDefaultInstanceForType() {
+ return io.grpc.binarylog.Metadata.getDefaultInstance();
+ }
+
+ public io.grpc.binarylog.Metadata build() {
+ io.grpc.binarylog.Metadata result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public io.grpc.binarylog.Metadata buildPartial() {
+ io.grpc.binarylog.Metadata result = new io.grpc.binarylog.Metadata(this);
+ int from_bitField0_ = bitField0_;
+ if (entryBuilder_ == null) {
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ entry_ = java.util.Collections.unmodifiableList(entry_);
+ bitField0_ = (bitField0_ & ~0x00000001);
+ }
+ result.entry_ = entry_;
+ } else {
+ result.entry_ = entryBuilder_.build();
+ }
+ onBuilt();
+ return result;
+ }
+
+ public Builder clone() {
+ return (Builder) super.clone();
+ }
+ public Builder setField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.setField(field, value);
+ }
+ public Builder clearField(
+ com.google.protobuf.Descriptors.FieldDescriptor field) {
+ return (Builder) super.clearField(field);
+ }
+ public Builder clearOneof(
+ com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+ return (Builder) super.clearOneof(oneof);
+ }
+ public Builder setRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ int index, java.lang.Object value) {
+ return (Builder) super.setRepeatedField(field, index, value);
+ }
+ public Builder addRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.addRepeatedField(field, value);
+ }
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof io.grpc.binarylog.Metadata) {
+ return mergeFrom((io.grpc.binarylog.Metadata)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(io.grpc.binarylog.Metadata other) {
+ if (other == io.grpc.binarylog.Metadata.getDefaultInstance()) return this;
+ if (entryBuilder_ == null) {
+ if (!other.entry_.isEmpty()) {
+ if (entry_.isEmpty()) {
+ entry_ = other.entry_;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ } else {
+ ensureEntryIsMutable();
+ entry_.addAll(other.entry_);
+ }
+ onChanged();
+ }
+ } else {
+ if (!other.entry_.isEmpty()) {
+ if (entryBuilder_.isEmpty()) {
+ entryBuilder_.dispose();
+ entryBuilder_ = null;
+ entry_ = other.entry_;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ entryBuilder_ =
+ com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+ getEntryFieldBuilder() : null;
+ } else {
+ entryBuilder_.addAllMessages(other.entry_);
+ }
+ }
+ }
+ this.mergeUnknownFields(other.unknownFields);
+ onChanged();
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ io.grpc.binarylog.Metadata parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (io.grpc.binarylog.Metadata) e.getUnfinishedMessage();
+ throw e.unwrapIOException();
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ private java.util.List entry_ =
+ java.util.Collections.emptyList();
+ private void ensureEntryIsMutable() {
+ if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+ entry_ = new java.util.ArrayList(entry_);
+ bitField0_ |= 0x00000001;
+ }
+ }
+
+ private com.google.protobuf.RepeatedFieldBuilderV3<
+ io.grpc.binarylog.MetadataEntry, io.grpc.binarylog.MetadataEntry.Builder, io.grpc.binarylog.MetadataEntryOrBuilder> entryBuilder_;
+
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public java.util.List getEntryList() {
+ if (entryBuilder_ == null) {
+ return java.util.Collections.unmodifiableList(entry_);
+ } else {
+ return entryBuilder_.getMessageList();
+ }
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public int getEntryCount() {
+ if (entryBuilder_ == null) {
+ return entry_.size();
+ } else {
+ return entryBuilder_.getCount();
+ }
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntry getEntry(int index) {
+ if (entryBuilder_ == null) {
+ return entry_.get(index);
+ } else {
+ return entryBuilder_.getMessage(index);
+ }
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder setEntry(
+ int index, io.grpc.binarylog.MetadataEntry value) {
+ if (entryBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureEntryIsMutable();
+ entry_.set(index, value);
+ onChanged();
+ } else {
+ entryBuilder_.setMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder setEntry(
+ int index, io.grpc.binarylog.MetadataEntry.Builder builderForValue) {
+ if (entryBuilder_ == null) {
+ ensureEntryIsMutable();
+ entry_.set(index, builderForValue.build());
+ onChanged();
+ } else {
+ entryBuilder_.setMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder addEntry(io.grpc.binarylog.MetadataEntry value) {
+ if (entryBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureEntryIsMutable();
+ entry_.add(value);
+ onChanged();
+ } else {
+ entryBuilder_.addMessage(value);
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder addEntry(
+ int index, io.grpc.binarylog.MetadataEntry value) {
+ if (entryBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureEntryIsMutable();
+ entry_.add(index, value);
+ onChanged();
+ } else {
+ entryBuilder_.addMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder addEntry(
+ io.grpc.binarylog.MetadataEntry.Builder builderForValue) {
+ if (entryBuilder_ == null) {
+ ensureEntryIsMutable();
+ entry_.add(builderForValue.build());
+ onChanged();
+ } else {
+ entryBuilder_.addMessage(builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder addEntry(
+ int index, io.grpc.binarylog.MetadataEntry.Builder builderForValue) {
+ if (entryBuilder_ == null) {
+ ensureEntryIsMutable();
+ entry_.add(index, builderForValue.build());
+ onChanged();
+ } else {
+ entryBuilder_.addMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder addAllEntry(
+ java.lang.Iterable values) {
+ if (entryBuilder_ == null) {
+ ensureEntryIsMutable();
+ com.google.protobuf.AbstractMessageLite.Builder.addAll(
+ values, entry_);
+ onChanged();
+ } else {
+ entryBuilder_.addAllMessages(values);
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder clearEntry() {
+ if (entryBuilder_ == null) {
+ entry_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000001);
+ onChanged();
+ } else {
+ entryBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public Builder removeEntry(int index) {
+ if (entryBuilder_ == null) {
+ ensureEntryIsMutable();
+ entry_.remove(index);
+ onChanged();
+ } else {
+ entryBuilder_.remove(index);
+ }
+ return this;
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntry.Builder getEntryBuilder(
+ int index) {
+ return getEntryFieldBuilder().getBuilder(index);
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntryOrBuilder getEntryOrBuilder(
+ int index) {
+ if (entryBuilder_ == null) {
+ return entry_.get(index); } else {
+ return entryBuilder_.getMessageOrBuilder(index);
+ }
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public java.util.List
+ getEntryOrBuilderList() {
+ if (entryBuilder_ != null) {
+ return entryBuilder_.getMessageOrBuilderList();
+ } else {
+ return java.util.Collections.unmodifiableList(entry_);
+ }
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntry.Builder addEntryBuilder() {
+ return getEntryFieldBuilder().addBuilder(
+ io.grpc.binarylog.MetadataEntry.getDefaultInstance());
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public io.grpc.binarylog.MetadataEntry.Builder addEntryBuilder(
+ int index) {
+ return getEntryFieldBuilder().addBuilder(
+ index, io.grpc.binarylog.MetadataEntry.getDefaultInstance());
+ }
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ public java.util.List
+ getEntryBuilderList() {
+ return getEntryFieldBuilder().getBuilderList();
+ }
+ private com.google.protobuf.RepeatedFieldBuilderV3<
+ io.grpc.binarylog.MetadataEntry, io.grpc.binarylog.MetadataEntry.Builder, io.grpc.binarylog.MetadataEntryOrBuilder>
+ getEntryFieldBuilder() {
+ if (entryBuilder_ == null) {
+ entryBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+ io.grpc.binarylog.MetadataEntry, io.grpc.binarylog.MetadataEntry.Builder, io.grpc.binarylog.MetadataEntryOrBuilder>(
+ entry_,
+ ((bitField0_ & 0x00000001) == 0x00000001),
+ getParentForChildren(),
+ isClean());
+ entry_ = null;
+ }
+ return entryBuilder_;
+ }
+ public final Builder setUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.setUnknownFieldsProto3(unknownFields);
+ }
+
+ public final Builder mergeUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.mergeUnknownFields(unknownFields);
+ }
+
+
+ // @@protoc_insertion_point(builder_scope:grpc.binarylog.v1alpha.Metadata)
+ }
+
+ // @@protoc_insertion_point(class_scope:grpc.binarylog.v1alpha.Metadata)
+ private static final io.grpc.binarylog.Metadata DEFAULT_INSTANCE;
+ static {
+ DEFAULT_INSTANCE = new io.grpc.binarylog.Metadata();
+ }
+
+ public static io.grpc.binarylog.Metadata getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ private static final com.google.protobuf.Parser
+ PARSER = new com.google.protobuf.AbstractParser() {
+ public Metadata parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new Metadata(input, extensionRegistry);
+ }
+ };
+
+ public static com.google.protobuf.Parser parser() {
+ return PARSER;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Parser getParserForType() {
+ return PARSER;
+ }
+
+ public io.grpc.binarylog.Metadata getDefaultInstanceForType() {
+ return DEFAULT_INSTANCE;
+ }
+
+}
+
diff --git a/services/src/generated/main/java/io/grpc/binarylog/MetadataEntry.java b/services/src/generated/main/java/io/grpc/binarylog/MetadataEntry.java
new file mode 100644
index 0000000000..8ecdd2b357
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/MetadataEntry.java
@@ -0,0 +1,585 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+/**
+ *
+ * A metadata key value pair
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.MetadataEntry}
+ */
+public final class MetadataEntry extends
+ com.google.protobuf.GeneratedMessageV3 implements
+ // @@protoc_insertion_point(message_implements:grpc.binarylog.v1alpha.MetadataEntry)
+ MetadataEntryOrBuilder {
+private static final long serialVersionUID = 0L;
+ // Use MetadataEntry.newBuilder() to construct.
+ private MetadataEntry(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+ super(builder);
+ }
+ private MetadataEntry() {
+ key_ = "";
+ value_ = com.google.protobuf.ByteString.EMPTY;
+ }
+
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private MetadataEntry(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ this();
+ if (extensionRegistry == null) {
+ throw new java.lang.NullPointerException();
+ }
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownFieldProto3(
+ input, unknownFields, extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ java.lang.String s = input.readStringRequireUtf8();
+
+ key_ = s;
+ break;
+ }
+ case 18: {
+
+ value_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_MetadataEntry_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_MetadataEntry_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.MetadataEntry.class, io.grpc.binarylog.MetadataEntry.Builder.class);
+ }
+
+ public static final int KEY_FIELD_NUMBER = 1;
+ private volatile java.lang.Object key_;
+ /**
+ * string key = 1;
+ */
+ public java.lang.String getKey() {
+ java.lang.Object ref = key_;
+ if (ref instanceof java.lang.String) {
+ return (java.lang.String) ref;
+ } else {
+ com.google.protobuf.ByteString bs =
+ (com.google.protobuf.ByteString) ref;
+ java.lang.String s = bs.toStringUtf8();
+ key_ = s;
+ return s;
+ }
+ }
+ /**
+ * string key = 1;
+ */
+ public com.google.protobuf.ByteString
+ getKeyBytes() {
+ java.lang.Object ref = key_;
+ if (ref instanceof java.lang.String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ key_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+
+ public static final int VALUE_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString value_;
+ /**
+ * bytes value = 2;
+ */
+ public com.google.protobuf.ByteString getValue() {
+ return value_;
+ }
+
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized == 1) return true;
+ if (isInitialized == 0) return false;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ if (!getKeyBytes().isEmpty()) {
+ com.google.protobuf.GeneratedMessageV3.writeString(output, 1, key_);
+ }
+ if (!value_.isEmpty()) {
+ output.writeBytes(2, value_);
+ }
+ unknownFields.writeTo(output);
+ }
+
+ public int getSerializedSize() {
+ int size = memoizedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (!getKeyBytes().isEmpty()) {
+ size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, key_);
+ }
+ if (!value_.isEmpty()) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, value_);
+ }
+ size += unknownFields.getSerializedSize();
+ memoizedSize = size;
+ return size;
+ }
+
+ @java.lang.Override
+ public boolean equals(final java.lang.Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof io.grpc.binarylog.MetadataEntry)) {
+ return super.equals(obj);
+ }
+ io.grpc.binarylog.MetadataEntry other = (io.grpc.binarylog.MetadataEntry) obj;
+
+ boolean result = true;
+ result = result && getKey()
+ .equals(other.getKey());
+ result = result && getValue()
+ .equals(other.getValue());
+ result = result && unknownFields.equals(other.unknownFields);
+ return result;
+ }
+
+ @java.lang.Override
+ public int hashCode() {
+ if (memoizedHashCode != 0) {
+ return memoizedHashCode;
+ }
+ int hash = 41;
+ hash = (19 * hash) + getDescriptor().hashCode();
+ hash = (37 * hash) + KEY_FIELD_NUMBER;
+ hash = (53 * hash) + getKey().hashCode();
+ hash = (37 * hash) + VALUE_FIELD_NUMBER;
+ hash = (53 * hash) + getValue().hashCode();
+ hash = (29 * hash) + unknownFields.hashCode();
+ memoizedHashCode = hash;
+ return hash;
+ }
+
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ java.nio.ByteBuffer data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ java.nio.ByteBuffer data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.MetadataEntry parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder() {
+ return DEFAULT_INSTANCE.toBuilder();
+ }
+ public static Builder newBuilder(io.grpc.binarylog.MetadataEntry prototype) {
+ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() {
+ return this == DEFAULT_INSTANCE
+ ? new Builder() : new Builder().mergeFrom(this);
+ }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ *
+ * A metadata key value pair
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.MetadataEntry}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageV3.Builder implements
+ // @@protoc_insertion_point(builder_implements:grpc.binarylog.v1alpha.MetadataEntry)
+ io.grpc.binarylog.MetadataEntryOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_MetadataEntry_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_MetadataEntry_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.MetadataEntry.class, io.grpc.binarylog.MetadataEntry.Builder.class);
+ }
+
+ // Construct using io.grpc.binarylog.MetadataEntry.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessageV3
+ .alwaysUseFieldBuilders) {
+ }
+ }
+ public Builder clear() {
+ super.clear();
+ key_ = "";
+
+ value_ = com.google.protobuf.ByteString.EMPTY;
+
+ return this;
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_MetadataEntry_descriptor;
+ }
+
+ public io.grpc.binarylog.MetadataEntry getDefaultInstanceForType() {
+ return io.grpc.binarylog.MetadataEntry.getDefaultInstance();
+ }
+
+ public io.grpc.binarylog.MetadataEntry build() {
+ io.grpc.binarylog.MetadataEntry result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public io.grpc.binarylog.MetadataEntry buildPartial() {
+ io.grpc.binarylog.MetadataEntry result = new io.grpc.binarylog.MetadataEntry(this);
+ result.key_ = key_;
+ result.value_ = value_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder clone() {
+ return (Builder) super.clone();
+ }
+ public Builder setField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.setField(field, value);
+ }
+ public Builder clearField(
+ com.google.protobuf.Descriptors.FieldDescriptor field) {
+ return (Builder) super.clearField(field);
+ }
+ public Builder clearOneof(
+ com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+ return (Builder) super.clearOneof(oneof);
+ }
+ public Builder setRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ int index, java.lang.Object value) {
+ return (Builder) super.setRepeatedField(field, index, value);
+ }
+ public Builder addRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.addRepeatedField(field, value);
+ }
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof io.grpc.binarylog.MetadataEntry) {
+ return mergeFrom((io.grpc.binarylog.MetadataEntry)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(io.grpc.binarylog.MetadataEntry other) {
+ if (other == io.grpc.binarylog.MetadataEntry.getDefaultInstance()) return this;
+ if (!other.getKey().isEmpty()) {
+ key_ = other.key_;
+ onChanged();
+ }
+ if (other.getValue() != com.google.protobuf.ByteString.EMPTY) {
+ setValue(other.getValue());
+ }
+ this.mergeUnknownFields(other.unknownFields);
+ onChanged();
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ io.grpc.binarylog.MetadataEntry parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (io.grpc.binarylog.MetadataEntry) e.getUnfinishedMessage();
+ throw e.unwrapIOException();
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ private java.lang.Object key_ = "";
+ /**
+ * string key = 1;
+ */
+ public java.lang.String getKey() {
+ java.lang.Object ref = key_;
+ if (!(ref instanceof java.lang.String)) {
+ com.google.protobuf.ByteString bs =
+ (com.google.protobuf.ByteString) ref;
+ java.lang.String s = bs.toStringUtf8();
+ key_ = s;
+ return s;
+ } else {
+ return (java.lang.String) ref;
+ }
+ }
+ /**
+ * string key = 1;
+ */
+ public com.google.protobuf.ByteString
+ getKeyBytes() {
+ java.lang.Object ref = key_;
+ if (ref instanceof String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ key_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+ /**
+ * string key = 1;
+ */
+ public Builder setKey(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ key_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * string key = 1;
+ */
+ public Builder clearKey() {
+
+ key_ = getDefaultInstance().getKey();
+ onChanged();
+ return this;
+ }
+ /**
+ * string key = 1;
+ */
+ public Builder setKeyBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ checkByteStringIsUtf8(value);
+
+ key_ = value;
+ onChanged();
+ return this;
+ }
+
+ private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * bytes value = 2;
+ */
+ public com.google.protobuf.ByteString getValue() {
+ return value_;
+ }
+ /**
+ * bytes value = 2;
+ */
+ public Builder setValue(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ value_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * bytes value = 2;
+ */
+ public Builder clearValue() {
+
+ value_ = getDefaultInstance().getValue();
+ onChanged();
+ return this;
+ }
+ public final Builder setUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.setUnknownFieldsProto3(unknownFields);
+ }
+
+ public final Builder mergeUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.mergeUnknownFields(unknownFields);
+ }
+
+
+ // @@protoc_insertion_point(builder_scope:grpc.binarylog.v1alpha.MetadataEntry)
+ }
+
+ // @@protoc_insertion_point(class_scope:grpc.binarylog.v1alpha.MetadataEntry)
+ private static final io.grpc.binarylog.MetadataEntry DEFAULT_INSTANCE;
+ static {
+ DEFAULT_INSTANCE = new io.grpc.binarylog.MetadataEntry();
+ }
+
+ public static io.grpc.binarylog.MetadataEntry getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ private static final com.google.protobuf.Parser
+ PARSER = new com.google.protobuf.AbstractParser() {
+ public MetadataEntry parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new MetadataEntry(input, extensionRegistry);
+ }
+ };
+
+ public static com.google.protobuf.Parser parser() {
+ return PARSER;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Parser getParserForType() {
+ return PARSER;
+ }
+
+ public io.grpc.binarylog.MetadataEntry getDefaultInstanceForType() {
+ return DEFAULT_INSTANCE;
+ }
+
+}
+
diff --git a/services/src/generated/main/java/io/grpc/binarylog/MetadataEntryOrBuilder.java b/services/src/generated/main/java/io/grpc/binarylog/MetadataEntryOrBuilder.java
new file mode 100644
index 0000000000..177cd9d8ae
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/MetadataEntryOrBuilder.java
@@ -0,0 +1,24 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+public interface MetadataEntryOrBuilder extends
+ // @@protoc_insertion_point(interface_extends:grpc.binarylog.v1alpha.MetadataEntry)
+ com.google.protobuf.MessageOrBuilder {
+
+ /**
+ * string key = 1;
+ */
+ java.lang.String getKey();
+ /**
+ * string key = 1;
+ */
+ com.google.protobuf.ByteString
+ getKeyBytes();
+
+ /**
+ * bytes value = 2;
+ */
+ com.google.protobuf.ByteString getValue();
+}
diff --git a/services/src/generated/main/java/io/grpc/binarylog/MetadataOrBuilder.java b/services/src/generated/main/java/io/grpc/binarylog/MetadataOrBuilder.java
new file mode 100644
index 0000000000..296e90cdbd
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/MetadataOrBuilder.java
@@ -0,0 +1,33 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+public interface MetadataOrBuilder extends
+ // @@protoc_insertion_point(interface_extends:grpc.binarylog.v1alpha.Metadata)
+ com.google.protobuf.MessageOrBuilder {
+
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ java.util.List
+ getEntryList();
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ io.grpc.binarylog.MetadataEntry getEntry(int index);
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ int getEntryCount();
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ java.util.List
+ getEntryOrBuilderList();
+ /**
+ * repeated .grpc.binarylog.v1alpha.MetadataEntry entry = 1;
+ */
+ io.grpc.binarylog.MetadataEntryOrBuilder getEntryOrBuilder(
+ int index);
+}
diff --git a/services/src/generated/main/java/io/grpc/binarylog/Peer.java b/services/src/generated/main/java/io/grpc/binarylog/Peer.java
new file mode 100644
index 0000000000..549b61946a
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/Peer.java
@@ -0,0 +1,688 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+/**
+ *
+ * Peer information
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Peer}
+ */
+public final class Peer extends
+ com.google.protobuf.GeneratedMessageV3 implements
+ // @@protoc_insertion_point(message_implements:grpc.binarylog.v1alpha.Peer)
+ PeerOrBuilder {
+private static final long serialVersionUID = 0L;
+ // Use Peer.newBuilder() to construct.
+ private Peer(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+ super(builder);
+ }
+ private Peer() {
+ peerType_ = 0;
+ peer_ = com.google.protobuf.ByteString.EMPTY;
+ }
+
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private Peer(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ this();
+ if (extensionRegistry == null) {
+ throw new java.lang.NullPointerException();
+ }
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownFieldProto3(
+ input, unknownFields, extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ int rawValue = input.readEnum();
+
+ peerType_ = rawValue;
+ break;
+ }
+ case 18: {
+
+ peer_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Peer_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Peer_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Peer.class, io.grpc.binarylog.Peer.Builder.class);
+ }
+
+ /**
+ * Protobuf enum {@code grpc.binarylog.v1alpha.Peer.PeerType}
+ */
+ public enum PeerType
+ implements com.google.protobuf.ProtocolMessageEnum {
+ /**
+ *
+ * peer is struct sockaddr_in
+ *
+ *
+ * PEER_IPV4 = 0;
+ */
+ PEER_IPV4(0),
+ /**
+ *
+ * peer is struct sockaddr_in6
+ *
+ *
+ * PEER_IPV6 = 1;
+ */
+ PEER_IPV6(1),
+ /**
+ *
+ * peer is struct sockaddr_un
+ *
+ *
+ * PEER_UNIX = 2;
+ */
+ PEER_UNIX(2),
+ UNRECOGNIZED(-1),
+ ;
+
+ /**
+ *
+ * peer is struct sockaddr_in
+ *
+ *
+ * PEER_IPV4 = 0;
+ */
+ public static final int PEER_IPV4_VALUE = 0;
+ /**
+ *
+ * peer is struct sockaddr_in6
+ *
+ *
+ * PEER_IPV6 = 1;
+ */
+ public static final int PEER_IPV6_VALUE = 1;
+ /**
+ *
+ * peer is struct sockaddr_un
+ *
+ *
+ * PEER_UNIX = 2;
+ */
+ public static final int PEER_UNIX_VALUE = 2;
+
+
+ public final int getNumber() {
+ if (this == UNRECOGNIZED) {
+ throw new java.lang.IllegalArgumentException(
+ "Can't get the number of an unknown enum value.");
+ }
+ return value;
+ }
+
+ /**
+ * @deprecated Use {@link #forNumber(int)} instead.
+ */
+ @java.lang.Deprecated
+ public static PeerType valueOf(int value) {
+ return forNumber(value);
+ }
+
+ public static PeerType forNumber(int value) {
+ switch (value) {
+ case 0: return PEER_IPV4;
+ case 1: return PEER_IPV6;
+ case 2: return PEER_UNIX;
+ default: return null;
+ }
+ }
+
+ public static com.google.protobuf.Internal.EnumLiteMap
+ internalGetValueMap() {
+ return internalValueMap;
+ }
+ private static final com.google.protobuf.Internal.EnumLiteMap<
+ PeerType> internalValueMap =
+ new com.google.protobuf.Internal.EnumLiteMap() {
+ public PeerType findValueByNumber(int number) {
+ return PeerType.forNumber(number);
+ }
+ };
+
+ public final com.google.protobuf.Descriptors.EnumValueDescriptor
+ getValueDescriptor() {
+ return getDescriptor().getValues().get(ordinal());
+ }
+ public final com.google.protobuf.Descriptors.EnumDescriptor
+ getDescriptorForType() {
+ return getDescriptor();
+ }
+ public static final com.google.protobuf.Descriptors.EnumDescriptor
+ getDescriptor() {
+ return io.grpc.binarylog.Peer.getDescriptor().getEnumTypes().get(0);
+ }
+
+ private static final PeerType[] VALUES = values();
+
+ public static PeerType valueOf(
+ com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
+ if (desc.getType() != getDescriptor()) {
+ throw new java.lang.IllegalArgumentException(
+ "EnumValueDescriptor is not for this type.");
+ }
+ if (desc.getIndex() == -1) {
+ return UNRECOGNIZED;
+ }
+ return VALUES[desc.getIndex()];
+ }
+
+ private final int value;
+
+ private PeerType(int value) {
+ this.value = value;
+ }
+
+ // @@protoc_insertion_point(enum_scope:grpc.binarylog.v1alpha.Peer.PeerType)
+ }
+
+ public static final int PEER_TYPE_FIELD_NUMBER = 1;
+ private int peerType_;
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public int getPeerTypeValue() {
+ return peerType_;
+ }
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public io.grpc.binarylog.Peer.PeerType getPeerType() {
+ io.grpc.binarylog.Peer.PeerType result = io.grpc.binarylog.Peer.PeerType.valueOf(peerType_);
+ return result == null ? io.grpc.binarylog.Peer.PeerType.UNRECOGNIZED : result;
+ }
+
+ public static final int PEER_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString peer_;
+ /**
+ *
+ * value depends on peer_type
+ *
+ *
+ * bytes peer = 2;
+ */
+ public com.google.protobuf.ByteString getPeer() {
+ return peer_;
+ }
+
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized == 1) return true;
+ if (isInitialized == 0) return false;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ if (peerType_ != io.grpc.binarylog.Peer.PeerType.PEER_IPV4.getNumber()) {
+ output.writeEnum(1, peerType_);
+ }
+ if (!peer_.isEmpty()) {
+ output.writeBytes(2, peer_);
+ }
+ unknownFields.writeTo(output);
+ }
+
+ public int getSerializedSize() {
+ int size = memoizedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (peerType_ != io.grpc.binarylog.Peer.PeerType.PEER_IPV4.getNumber()) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeEnumSize(1, peerType_);
+ }
+ if (!peer_.isEmpty()) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, peer_);
+ }
+ size += unknownFields.getSerializedSize();
+ memoizedSize = size;
+ return size;
+ }
+
+ @java.lang.Override
+ public boolean equals(final java.lang.Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof io.grpc.binarylog.Peer)) {
+ return super.equals(obj);
+ }
+ io.grpc.binarylog.Peer other = (io.grpc.binarylog.Peer) obj;
+
+ boolean result = true;
+ result = result && peerType_ == other.peerType_;
+ result = result && getPeer()
+ .equals(other.getPeer());
+ result = result && unknownFields.equals(other.unknownFields);
+ return result;
+ }
+
+ @java.lang.Override
+ public int hashCode() {
+ if (memoizedHashCode != 0) {
+ return memoizedHashCode;
+ }
+ int hash = 41;
+ hash = (19 * hash) + getDescriptor().hashCode();
+ hash = (37 * hash) + PEER_TYPE_FIELD_NUMBER;
+ hash = (53 * hash) + peerType_;
+ hash = (37 * hash) + PEER_FIELD_NUMBER;
+ hash = (53 * hash) + getPeer().hashCode();
+ hash = (29 * hash) + unknownFields.hashCode();
+ memoizedHashCode = hash;
+ return hash;
+ }
+
+ public static io.grpc.binarylog.Peer parseFrom(
+ java.nio.ByteBuffer data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ java.nio.ByteBuffer data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Peer parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Peer parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Peer parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder() {
+ return DEFAULT_INSTANCE.toBuilder();
+ }
+ public static Builder newBuilder(io.grpc.binarylog.Peer prototype) {
+ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() {
+ return this == DEFAULT_INSTANCE
+ ? new Builder() : new Builder().mergeFrom(this);
+ }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ *
+ * Peer information
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Peer}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageV3.Builder implements
+ // @@protoc_insertion_point(builder_implements:grpc.binarylog.v1alpha.Peer)
+ io.grpc.binarylog.PeerOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Peer_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Peer_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Peer.class, io.grpc.binarylog.Peer.Builder.class);
+ }
+
+ // Construct using io.grpc.binarylog.Peer.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessageV3
+ .alwaysUseFieldBuilders) {
+ }
+ }
+ public Builder clear() {
+ super.clear();
+ peerType_ = 0;
+
+ peer_ = com.google.protobuf.ByteString.EMPTY;
+
+ return this;
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Peer_descriptor;
+ }
+
+ public io.grpc.binarylog.Peer getDefaultInstanceForType() {
+ return io.grpc.binarylog.Peer.getDefaultInstance();
+ }
+
+ public io.grpc.binarylog.Peer build() {
+ io.grpc.binarylog.Peer result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public io.grpc.binarylog.Peer buildPartial() {
+ io.grpc.binarylog.Peer result = new io.grpc.binarylog.Peer(this);
+ result.peerType_ = peerType_;
+ result.peer_ = peer_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder clone() {
+ return (Builder) super.clone();
+ }
+ public Builder setField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.setField(field, value);
+ }
+ public Builder clearField(
+ com.google.protobuf.Descriptors.FieldDescriptor field) {
+ return (Builder) super.clearField(field);
+ }
+ public Builder clearOneof(
+ com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+ return (Builder) super.clearOneof(oneof);
+ }
+ public Builder setRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ int index, java.lang.Object value) {
+ return (Builder) super.setRepeatedField(field, index, value);
+ }
+ public Builder addRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.addRepeatedField(field, value);
+ }
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof io.grpc.binarylog.Peer) {
+ return mergeFrom((io.grpc.binarylog.Peer)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(io.grpc.binarylog.Peer other) {
+ if (other == io.grpc.binarylog.Peer.getDefaultInstance()) return this;
+ if (other.peerType_ != 0) {
+ setPeerTypeValue(other.getPeerTypeValue());
+ }
+ if (other.getPeer() != com.google.protobuf.ByteString.EMPTY) {
+ setPeer(other.getPeer());
+ }
+ this.mergeUnknownFields(other.unknownFields);
+ onChanged();
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ io.grpc.binarylog.Peer parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (io.grpc.binarylog.Peer) e.getUnfinishedMessage();
+ throw e.unwrapIOException();
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ private int peerType_ = 0;
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public int getPeerTypeValue() {
+ return peerType_;
+ }
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public Builder setPeerTypeValue(int value) {
+ peerType_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public io.grpc.binarylog.Peer.PeerType getPeerType() {
+ io.grpc.binarylog.Peer.PeerType result = io.grpc.binarylog.Peer.PeerType.valueOf(peerType_);
+ return result == null ? io.grpc.binarylog.Peer.PeerType.UNRECOGNIZED : result;
+ }
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public Builder setPeerType(io.grpc.binarylog.Peer.PeerType value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ peerType_ = value.getNumber();
+ onChanged();
+ return this;
+ }
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ public Builder clearPeerType() {
+
+ peerType_ = 0;
+ onChanged();
+ return this;
+ }
+
+ private com.google.protobuf.ByteString peer_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ *
+ * value depends on peer_type
+ *
+ *
+ * bytes peer = 2;
+ */
+ public com.google.protobuf.ByteString getPeer() {
+ return peer_;
+ }
+ /**
+ *
+ * value depends on peer_type
+ *
+ *
+ * bytes peer = 2;
+ */
+ public Builder setPeer(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+
+ peer_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ *
+ * value depends on peer_type
+ *
+ *
+ * bytes peer = 2;
+ */
+ public Builder clearPeer() {
+
+ peer_ = getDefaultInstance().getPeer();
+ onChanged();
+ return this;
+ }
+ public final Builder setUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.setUnknownFieldsProto3(unknownFields);
+ }
+
+ public final Builder mergeUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.mergeUnknownFields(unknownFields);
+ }
+
+
+ // @@protoc_insertion_point(builder_scope:grpc.binarylog.v1alpha.Peer)
+ }
+
+ // @@protoc_insertion_point(class_scope:grpc.binarylog.v1alpha.Peer)
+ private static final io.grpc.binarylog.Peer DEFAULT_INSTANCE;
+ static {
+ DEFAULT_INSTANCE = new io.grpc.binarylog.Peer();
+ }
+
+ public static io.grpc.binarylog.Peer getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ private static final com.google.protobuf.Parser
+ PARSER = new com.google.protobuf.AbstractParser() {
+ public Peer parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new Peer(input, extensionRegistry);
+ }
+ };
+
+ public static com.google.protobuf.Parser parser() {
+ return PARSER;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Parser getParserForType() {
+ return PARSER;
+ }
+
+ public io.grpc.binarylog.Peer getDefaultInstanceForType() {
+ return DEFAULT_INSTANCE;
+ }
+
+}
+
diff --git a/services/src/generated/main/java/io/grpc/binarylog/PeerOrBuilder.java b/services/src/generated/main/java/io/grpc/binarylog/PeerOrBuilder.java
new file mode 100644
index 0000000000..247a59c8bb
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/PeerOrBuilder.java
@@ -0,0 +1,27 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+public interface PeerOrBuilder extends
+ // @@protoc_insertion_point(interface_extends:grpc.binarylog.v1alpha.Peer)
+ com.google.protobuf.MessageOrBuilder {
+
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ int getPeerTypeValue();
+ /**
+ * .grpc.binarylog.v1alpha.Peer.PeerType peer_type = 1;
+ */
+ io.grpc.binarylog.Peer.PeerType getPeerType();
+
+ /**
+ *
+ * value depends on peer_type
+ *
+ *
+ * bytes peer = 2;
+ */
+ com.google.protobuf.ByteString getPeer();
+}
diff --git a/services/src/generated/main/java/io/grpc/binarylog/Uint128.java b/services/src/generated/main/java/io/grpc/binarylog/Uint128.java
new file mode 100644
index 0000000000..1c0a940a96
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/Uint128.java
@@ -0,0 +1,515 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+/**
+ *
+ * Used to record call_id.
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Uint128}
+ */
+public final class Uint128 extends
+ com.google.protobuf.GeneratedMessageV3 implements
+ // @@protoc_insertion_point(message_implements:grpc.binarylog.v1alpha.Uint128)
+ Uint128OrBuilder {
+private static final long serialVersionUID = 0L;
+ // Use Uint128.newBuilder() to construct.
+ private Uint128(com.google.protobuf.GeneratedMessageV3.Builder builder) {
+ super(builder);
+ }
+ private Uint128() {
+ high_ = 0L;
+ low_ = 0L;
+ }
+
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private Uint128(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ this();
+ if (extensionRegistry == null) {
+ throw new java.lang.NullPointerException();
+ }
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownFieldProto3(
+ input, unknownFields, extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 9: {
+
+ high_ = input.readFixed64();
+ break;
+ }
+ case 17: {
+
+ low_ = input.readFixed64();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Uint128_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Uint128_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Uint128.class, io.grpc.binarylog.Uint128.Builder.class);
+ }
+
+ public static final int HIGH_FIELD_NUMBER = 1;
+ private long high_;
+ /**
+ * fixed64 high = 1;
+ */
+ public long getHigh() {
+ return high_;
+ }
+
+ public static final int LOW_FIELD_NUMBER = 2;
+ private long low_;
+ /**
+ * fixed64 low = 2;
+ */
+ public long getLow() {
+ return low_;
+ }
+
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized == 1) return true;
+ if (isInitialized == 0) return false;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ if (high_ != 0L) {
+ output.writeFixed64(1, high_);
+ }
+ if (low_ != 0L) {
+ output.writeFixed64(2, low_);
+ }
+ unknownFields.writeTo(output);
+ }
+
+ public int getSerializedSize() {
+ int size = memoizedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (high_ != 0L) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeFixed64Size(1, high_);
+ }
+ if (low_ != 0L) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeFixed64Size(2, low_);
+ }
+ size += unknownFields.getSerializedSize();
+ memoizedSize = size;
+ return size;
+ }
+
+ @java.lang.Override
+ public boolean equals(final java.lang.Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof io.grpc.binarylog.Uint128)) {
+ return super.equals(obj);
+ }
+ io.grpc.binarylog.Uint128 other = (io.grpc.binarylog.Uint128) obj;
+
+ boolean result = true;
+ result = result && (getHigh()
+ == other.getHigh());
+ result = result && (getLow()
+ == other.getLow());
+ result = result && unknownFields.equals(other.unknownFields);
+ return result;
+ }
+
+ @java.lang.Override
+ public int hashCode() {
+ if (memoizedHashCode != 0) {
+ return memoizedHashCode;
+ }
+ int hash = 41;
+ hash = (19 * hash) + getDescriptor().hashCode();
+ hash = (37 * hash) + HIGH_FIELD_NUMBER;
+ hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+ getHigh());
+ hash = (37 * hash) + LOW_FIELD_NUMBER;
+ hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+ getLow());
+ hash = (29 * hash) + unknownFields.hashCode();
+ memoizedHashCode = hash;
+ return hash;
+ }
+
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ java.nio.ByteBuffer data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ java.nio.ByteBuffer data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Uint128 parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Uint128 parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input);
+ }
+ public static io.grpc.binarylog.Uint128 parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return com.google.protobuf.GeneratedMessageV3
+ .parseWithIOException(PARSER, input, extensionRegistry);
+ }
+
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder() {
+ return DEFAULT_INSTANCE.toBuilder();
+ }
+ public static Builder newBuilder(io.grpc.binarylog.Uint128 prototype) {
+ return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() {
+ return this == DEFAULT_INSTANCE
+ ? new Builder() : new Builder().mergeFrom(this);
+ }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ *
+ * Used to record call_id.
+ *
+ *
+ * Protobuf type {@code grpc.binarylog.v1alpha.Uint128}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessageV3.Builder implements
+ // @@protoc_insertion_point(builder_implements:grpc.binarylog.v1alpha.Uint128)
+ io.grpc.binarylog.Uint128OrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Uint128_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Uint128_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ io.grpc.binarylog.Uint128.class, io.grpc.binarylog.Uint128.Builder.class);
+ }
+
+ // Construct using io.grpc.binarylog.Uint128.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessageV3
+ .alwaysUseFieldBuilders) {
+ }
+ }
+ public Builder clear() {
+ super.clear();
+ high_ = 0L;
+
+ low_ = 0L;
+
+ return this;
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return io.grpc.binarylog.BinaryLogProto.internal_static_grpc_binarylog_v1alpha_Uint128_descriptor;
+ }
+
+ public io.grpc.binarylog.Uint128 getDefaultInstanceForType() {
+ return io.grpc.binarylog.Uint128.getDefaultInstance();
+ }
+
+ public io.grpc.binarylog.Uint128 build() {
+ io.grpc.binarylog.Uint128 result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public io.grpc.binarylog.Uint128 buildPartial() {
+ io.grpc.binarylog.Uint128 result = new io.grpc.binarylog.Uint128(this);
+ result.high_ = high_;
+ result.low_ = low_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder clone() {
+ return (Builder) super.clone();
+ }
+ public Builder setField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.setField(field, value);
+ }
+ public Builder clearField(
+ com.google.protobuf.Descriptors.FieldDescriptor field) {
+ return (Builder) super.clearField(field);
+ }
+ public Builder clearOneof(
+ com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+ return (Builder) super.clearOneof(oneof);
+ }
+ public Builder setRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ int index, java.lang.Object value) {
+ return (Builder) super.setRepeatedField(field, index, value);
+ }
+ public Builder addRepeatedField(
+ com.google.protobuf.Descriptors.FieldDescriptor field,
+ java.lang.Object value) {
+ return (Builder) super.addRepeatedField(field, value);
+ }
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof io.grpc.binarylog.Uint128) {
+ return mergeFrom((io.grpc.binarylog.Uint128)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(io.grpc.binarylog.Uint128 other) {
+ if (other == io.grpc.binarylog.Uint128.getDefaultInstance()) return this;
+ if (other.getHigh() != 0L) {
+ setHigh(other.getHigh());
+ }
+ if (other.getLow() != 0L) {
+ setLow(other.getLow());
+ }
+ this.mergeUnknownFields(other.unknownFields);
+ onChanged();
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ io.grpc.binarylog.Uint128 parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (io.grpc.binarylog.Uint128) e.getUnfinishedMessage();
+ throw e.unwrapIOException();
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ private long high_ ;
+ /**
+ * fixed64 high = 1;
+ */
+ public long getHigh() {
+ return high_;
+ }
+ /**
+ * fixed64 high = 1;
+ */
+ public Builder setHigh(long value) {
+
+ high_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * fixed64 high = 1;
+ */
+ public Builder clearHigh() {
+
+ high_ = 0L;
+ onChanged();
+ return this;
+ }
+
+ private long low_ ;
+ /**
+ * fixed64 low = 2;
+ */
+ public long getLow() {
+ return low_;
+ }
+ /**
+ * fixed64 low = 2;
+ */
+ public Builder setLow(long value) {
+
+ low_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * fixed64 low = 2;
+ */
+ public Builder clearLow() {
+
+ low_ = 0L;
+ onChanged();
+ return this;
+ }
+ public final Builder setUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.setUnknownFieldsProto3(unknownFields);
+ }
+
+ public final Builder mergeUnknownFields(
+ final com.google.protobuf.UnknownFieldSet unknownFields) {
+ return super.mergeUnknownFields(unknownFields);
+ }
+
+
+ // @@protoc_insertion_point(builder_scope:grpc.binarylog.v1alpha.Uint128)
+ }
+
+ // @@protoc_insertion_point(class_scope:grpc.binarylog.v1alpha.Uint128)
+ private static final io.grpc.binarylog.Uint128 DEFAULT_INSTANCE;
+ static {
+ DEFAULT_INSTANCE = new io.grpc.binarylog.Uint128();
+ }
+
+ public static io.grpc.binarylog.Uint128 getDefaultInstance() {
+ return DEFAULT_INSTANCE;
+ }
+
+ private static final com.google.protobuf.Parser
+ PARSER = new com.google.protobuf.AbstractParser() {
+ public Uint128 parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new Uint128(input, extensionRegistry);
+ }
+ };
+
+ public static com.google.protobuf.Parser parser() {
+ return PARSER;
+ }
+
+ @java.lang.Override
+ public com.google.protobuf.Parser getParserForType() {
+ return PARSER;
+ }
+
+ public io.grpc.binarylog.Uint128 getDefaultInstanceForType() {
+ return DEFAULT_INSTANCE;
+ }
+
+}
+
diff --git a/services/src/generated/main/java/io/grpc/binarylog/Uint128OrBuilder.java b/services/src/generated/main/java/io/grpc/binarylog/Uint128OrBuilder.java
new file mode 100644
index 0000000000..8502c885ef
--- /dev/null
+++ b/services/src/generated/main/java/io/grpc/binarylog/Uint128OrBuilder.java
@@ -0,0 +1,19 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: io/grpc/binarylog.proto
+
+package io.grpc.binarylog;
+
+public interface Uint128OrBuilder extends
+ // @@protoc_insertion_point(interface_extends:grpc.binarylog.v1alpha.Uint128)
+ com.google.protobuf.MessageOrBuilder {
+
+ /**
+ * fixed64 high = 1;
+ */
+ long getHigh();
+
+ /**
+ * fixed64 low = 2;
+ */
+ long getLow();
+}
diff --git a/services/src/main/java/io/grpc/services/BinaryLog.java b/services/src/main/java/io/grpc/services/BinaryLog.java
index 07b9dc7021..f974e18f15 100644
--- a/services/src/main/java/io/grpc/services/BinaryLog.java
+++ b/services/src/main/java/io/grpc/services/BinaryLog.java
@@ -19,7 +19,24 @@ package io.grpc.services;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
+import com.google.common.primitives.Bytes;
+import com.google.protobuf.ByteString;
+import io.grpc.InternalMetadata;
+import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
+import io.grpc.binarylog.Message;
+import io.grpc.binarylog.Metadata.Builder;
+import io.grpc.binarylog.MetadataEntry;
+import io.grpc.binarylog.Peer;
+import io.grpc.binarylog.Peer.PeerType;
+import io.grpc.binarylog.Uint128;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
@@ -34,6 +51,10 @@ import javax.annotation.Nullable;
*/
final class BinaryLog {
private static final Logger logger = Logger.getLogger(BinaryLog.class.getName());
+ private static final int IP_PORT_BYTES = 2;
+ private static final int IP_PORT_UPPER_MASK = 0xff00;
+ private static final int IP_PORT_LOWER_MASK = 0xff;
+
private final int maxHeaderBytes;
private final int maxMessageBytes;
@@ -244,4 +265,101 @@ final class BinaryLog {
return null;
}
}
+
+ /**
+ * Returns a {@link Uint128} by interpreting the first 8 bytes as the high int64 and the second
+ * 8 bytes as the low int64.
+ */
+ // TODO(zpencer): verify int64 representation with other gRPC languages
+ static Uint128 callIdToProto(byte[] bytes) {
+ Preconditions.checkArgument(bytes.length == 16);
+ ByteBuffer bb = ByteBuffer.wrap(bytes);
+ long high = bb.getLong();
+ long low = bb.getLong();
+ return Uint128.newBuilder().setHigh(high).setLow(low).build();
+ }
+
+ @VisibleForTesting
+ // TODO(zpencer): the binlog design does not specify how to actually express the peer bytes
+ static Peer socketToProto(SocketAddress address) {
+ PeerType peerType = null;
+ byte[] peerAddress = null;
+
+ if (address instanceof InetSocketAddress) {
+ InetAddress inetAddress = ((InetSocketAddress) address).getAddress();
+ if (inetAddress instanceof Inet4Address) {
+ peerType = PeerType.PEER_IPV4;
+ } else if (inetAddress instanceof Inet6Address) {
+ peerType = PeerType.PEER_IPV6;
+ } else {
+ logger.log(Level.SEVERE, "unknown type of InetSocketAddress: {}", address);
+ }
+ int port = ((InetSocketAddress) address).getPort();
+ byte[] portBytes = new byte[IP_PORT_BYTES];
+ portBytes[0] = (byte) (port & IP_PORT_UPPER_MASK);
+ portBytes[1] = (byte) (port & IP_PORT_LOWER_MASK);
+ peerAddress = Bytes.concat(inetAddress.getAddress(), portBytes);
+ } else if (address.getClass().getName().equals("io.netty.channel.unix.DomainSocketAddress")) {
+ // To avoid a compile time dependency on grpc-netty, we check against the runtime class name.
+ peerType = PeerType.PEER_UNIX;
+ // DomainSocketAddress.toString() is equivalent to DomainSocketAdddress.path()
+ peerAddress = address.toString().getBytes(Charset.defaultCharset());
+ }
+ Peer.Builder builder = Peer.newBuilder();
+ if (peerType != null) {
+ builder.setPeerType(peerType);
+ }
+ if (peerAddress != null) {
+ builder.setPeer(ByteString.copyFrom(peerAddress));
+ }
+ return builder.build();
+ }
+
+ @VisibleForTesting
+ static io.grpc.binarylog.Metadata metadataToProto(Metadata metadata, int maxHeaderBytes) {
+ Preconditions.checkState(maxHeaderBytes >= 0);
+ Builder builder = io.grpc.binarylog.Metadata.newBuilder();
+ if (maxHeaderBytes > 0) {
+ byte[][] serialized = InternalMetadata.serialize(metadata);
+ int written = 0;
+ // This code is tightly coupled with Metadata's implementation
+ for (int i = 0; i < serialized.length && written < maxHeaderBytes; i += 2) {
+ byte[] key = serialized[i];
+ byte[] value = serialized[i + 1];
+ if (written + key.length + value.length <= maxHeaderBytes) {
+ builder.addEntry(
+ MetadataEntry
+ .newBuilder()
+ .setKeyBytes(ByteString.copyFrom(key))
+ .setValue(ByteString.copyFrom(value))
+ .build());
+ written += key.length;
+ written += value.length;
+ }
+ }
+ }
+ return builder.build();
+ }
+
+ @VisibleForTesting
+ static Message messageToProto(byte[] message, boolean compressed, int maxMessageBytes) {
+ Preconditions.checkState(maxMessageBytes >= 0);
+ Message.Builder builder = Message
+ .newBuilder()
+ .setFlags(flagsForMessage(compressed))
+ .setLength(message.length);
+ if (maxMessageBytes > 0) {
+ int limit = Math.min(maxMessageBytes, message.length);
+ builder.setData(ByteString.copyFrom(message, 0, limit));
+ }
+ return builder.build();
+ }
+
+ /**
+ * Returns a flag based on the arguments.
+ */
+ @VisibleForTesting
+ static int flagsForMessage(boolean compressed) {
+ return compressed ? 1 : 0;
+ }
}
diff --git a/services/src/main/proto/io/grpc/binarylog.proto b/services/src/main/proto/io/grpc/binarylog.proto
new file mode 100644
index 0000000000..4c92291680
--- /dev/null
+++ b/services/src/main/proto/io/grpc/binarylog.proto
@@ -0,0 +1,109 @@
+// Copyright 2016, gRPC Authors
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Service exported by server reflection
+
+syntax = "proto3";
+
+package grpc.binarylog.v1alpha;
+
+option java_multiple_files = true;
+option java_package = "io.grpc.binarylog";
+option java_outer_classname = "BinaryLogProto";
+
+// Log entry we store in binary logs
+message GrpcLogEntry {
+ // Enumerates the type of logs
+ enum Type {
+ SEND_INITIAL_METADATA = 0;
+ SEND_TRAILING_METADATA = 1;
+ SEND_MESSAGE = 2;
+ RECV_INITIAL_METADATA = 3;
+ RECV_TRAILING_METADATA = 4;
+ RECV_MESSAGE = 5;
+ };
+
+ // Enumerates the entity that generates the log entry
+ enum Logger {
+ CLIENT = 0;
+ SERVER = 1;
+ }
+
+ Type type = 1; // One of the above Type enum
+ Logger logger = 2; // One of the above Logger enum
+
+ // Uniquely identifies a call. Each call may have several log entries, they
+ // will share the same call_id. 128 bits split into 2 64-bit parts.
+ Uint128 call_id = 3;
+
+ // The logger uses one of the following fields to record the payload,
+ // according to the type of the log entry.
+ oneof payload {
+ // Used by CLIENT_INIT_METADATA, SERVER_INIT_METADATA and TRAILING_METADATA
+ Metadata metadata = 4;
+ // Used by REQUEST and RESPONSE
+ Message message = 5;
+ }
+
+ // Peer address information, will only be recorded in SEND_INITIAL_METADATA
+ // and RECV_INITIAL_METADATA entries.
+ Peer peer = 6;
+};
+
+// Message payload, used by REQUEST and RESPONSE
+message Message {
+ // This flag is currently used to indicate whether the payload is compressed,
+ // it may contain other semantics in the future. Value of 1 indicates that the
+ // binary octet sequence of Message is compressed using the mechanism declared
+ // by the Message-Encoding header. A value of 0 indicates that no encoding of
+ // Message bytes has occurred.
+ uint32 flags = 1; // TODO(zpencer): this is changed because there is no uint8
+ // Length of the message. It may not be the same as the length of the
+ // data field, as the logging payload can be truncated or omitted.
+ uint32 length = 2;
+ // Binary payload, post compression (depends on the flags field), may be
+ // truncated or omitted.
+ bytes data = 3;
+}
+
+// A list of metadata pairs, used in the payload of CLIENT_INIT_METADATA,
+// SERVER_INIT_METADATA and TRAILING_METADATA
+// Implementations may omit some entries to honor the header limits
+// of GRPC_BINARY_LOG_CONFIG. Implementations can choose which entries are logged.
+message Metadata {
+ repeated MetadataEntry entry = 1;
+}
+
+// A metadata key value pair
+message MetadataEntry {
+ string key = 1;
+ bytes value = 2;
+}
+
+// Peer information
+message Peer {
+ enum PeerType {
+ PEER_IPV4 = 0; // peer is struct sockaddr_in
+ PEER_IPV6 = 1; // peer is struct sockaddr_in6
+ PEER_UNIX = 2; // peer is struct sockaddr_un
+ };
+ PeerType peer_type = 1;
+ bytes peer = 2; // value depends on peer_type
+}
+
+// Used to record call_id.
+message Uint128 {
+ fixed64 high = 1;
+ fixed64 low = 2;
+};
diff --git a/services/src/test/java/io/grpc/services/BinaryLogTest.java b/services/src/test/java/io/grpc/services/BinaryLogTest.java
index 92eb37b4a6..a24cdac1aa 100644
--- a/services/src/test/java/io/grpc/services/BinaryLogTest.java
+++ b/services/src/test/java/io/grpc/services/BinaryLogTest.java
@@ -19,7 +19,19 @@ package io.grpc.services;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
+import com.google.common.primitives.Bytes;
+import com.google.protobuf.ByteString;
+import io.grpc.Metadata;
+import io.grpc.binarylog.Message;
+import io.grpc.binarylog.MetadataEntry;
+import io.grpc.binarylog.Peer;
+import io.grpc.binarylog.Uint128;
import io.grpc.services.BinaryLog.FactoryImpl;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.Charset;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -27,6 +39,7 @@ import org.junit.runners.JUnit4;
/** Tests for {@link BinaryLog}. */
@RunWith(JUnit4.class)
public final class BinaryLogTest {
+ private static final Charset US_ASCII = Charset.forName("US-ASCII");
private static final BinaryLog HEADER_FULL = new Builder().header(Integer.MAX_VALUE).build();
private static final BinaryLog HEADER_256 = new Builder().header(256).build();
private static final BinaryLog MSG_FULL = new Builder().msg(Integer.MAX_VALUE).build();
@@ -34,7 +47,51 @@ public final class BinaryLogTest {
private static final BinaryLog BOTH_256 = new Builder().header(256).msg(256).build();
private static final BinaryLog BOTH_FULL =
new Builder().header(Integer.MAX_VALUE).msg(Integer.MAX_VALUE).build();
-
+
+ private static final byte[] CALL_ID = new byte[] {
+ 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+ 0x19, 0x10, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
+
+ private static final Metadata.Key KEY_A =
+ Metadata.Key.of("a", Metadata.ASCII_STRING_MARSHALLER);
+ private static final Metadata.Key KEY_B =
+ Metadata.Key.of("b", Metadata.ASCII_STRING_MARSHALLER);
+ private static final Metadata.Key KEY_C =
+ Metadata.Key.of("c", Metadata.ASCII_STRING_MARSHALLER);
+ private static final MetadataEntry ENTRY_A;
+ private static final MetadataEntry ENTRY_B;
+ private static final MetadataEntry ENTRY_C;
+ private static final Metadata metadata;
+ private static final boolean IS_COMPRESSED = true;
+ private static final boolean IS_UNCOMPRESSED = false;
+
+ static {
+ String dataA = "aaaaaaaaa";
+ String dataB = "bbbbbbbbb";
+ String dataC = "ccccccccc";
+ metadata = new Metadata();
+ metadata.put(KEY_A, dataA);
+ metadata.put(KEY_B, dataB);
+ metadata.put(KEY_C, dataC);
+ ENTRY_A =
+ MetadataEntry
+ .newBuilder()
+ .setKey(KEY_A.name())
+ .setValue(ByteString.copyFrom(dataA.getBytes(US_ASCII)))
+ .build();
+ ENTRY_B =
+ MetadataEntry
+ .newBuilder()
+ .setKey(KEY_B.name())
+ .setValue(ByteString.copyFrom(dataB.getBytes(US_ASCII)))
+ .build();
+ ENTRY_C =
+ MetadataEntry
+ .newBuilder()
+ .setKey(KEY_C.name())
+ .setValue(ByteString.copyFrom(dataC.getBytes(US_ASCII)))
+ .build();
+ }
@Test
public void configBinLog_global() throws Exception {
@@ -203,6 +260,192 @@ public final class BinaryLogTest {
assertEquals(HEADER_256, factory.getLog("p.other2/m"));
}
+ @Test
+ public void callIdToProto() {
+ assertEquals(
+ Uint128
+ .newBuilder()
+ .setHigh(0x1112131415161718L)
+ .setLow(0x19101a1b1c1d1e1fL)
+ .build(),
+ BinaryLog.callIdToProto(CALL_ID));
+
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void callIdToProto_invalid_shorter_len() {
+ BinaryLog.callIdToProto(new byte[14]);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void callIdToProto_invalid_longer_len() {
+ BinaryLog.callIdToProto(new byte[18]);
+ }
+
+ @Test
+ public void socketToProto_ipv4() throws Exception {
+ InetAddress address = InetAddress.getByName("127.0.0.1");
+ int port = 12345;
+ InetSocketAddress socketAddress = new InetSocketAddress(address, port);
+ byte[] addressBytes = address.getAddress();
+ byte[] portBytes = new byte[] {(byte) (port & 0xff00), (byte) (port & 0xff)};
+ assertEquals(
+ Peer
+ .newBuilder()
+ .setPeerType(Peer.PeerType.PEER_IPV4)
+ .setPeer(ByteString.copyFrom(Bytes.concat(addressBytes, portBytes)))
+ .build(),
+ BinaryLog.socketToProto(socketAddress));
+ }
+
+ @Test
+ public void socketToProto_ipv6() throws Exception {
+ // this is a ipv6 link local address
+ InetAddress address = InetAddress.getByName("fe:80:12:34:56:78:90:ab");
+ int port = 12345;
+ InetSocketAddress socketAddress = new InetSocketAddress(address, port);
+ byte[] addressBytes = address.getAddress();
+ byte[] portBytes = new byte[] {(byte) (port & 0xff00), (byte) (port & 0xff)};
+ assertEquals(
+ Peer
+ .newBuilder()
+ .setPeerType(Peer.PeerType.PEER_IPV6)
+ .setPeer(ByteString.copyFrom(Bytes.concat(addressBytes, portBytes)))
+ .build(),
+ BinaryLog.socketToProto(socketAddress));
+ }
+
+ @Test
+ public void socketToProto_unix() throws Exception {
+ String path = "/some/path";
+ DomainSocketAddress socketAddress = new DomainSocketAddress(path);
+ assertEquals(
+ Peer
+ .newBuilder()
+ .setPeerType(Peer.PeerType.PEER_UNIX)
+ .setPeer(ByteString.copyFrom(path.getBytes(US_ASCII)))
+ .build(),
+ BinaryLog.socketToProto(socketAddress)
+ );
+ }
+
+ @Test
+ public void socketToProto_unknown() throws Exception {
+ SocketAddress unknownSocket = new SocketAddress() { };
+ assertEquals(
+ Peer.newBuilder().build(),
+ BinaryLog.socketToProto(unknownSocket)
+ );
+ }
+
+ @Test
+ public void metadataToProto() throws Exception {
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .addEntry(ENTRY_A)
+ .addEntry(ENTRY_B)
+ .addEntry(ENTRY_C)
+ .build(),
+ BinaryLog.metadataToProto(metadata, Integer.MAX_VALUE));
+ }
+
+ @Test
+ public void metadataToProto_truncated() throws Exception {
+ // 0 byte limit not enough for any metadata
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .build(),
+ BinaryLog.metadataToProto(metadata, 0));
+ // not enough bytes for first key value
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .build(),
+ BinaryLog.metadataToProto(metadata, 9));
+ // enough for first key value
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .addEntry(ENTRY_A)
+ .build(),
+ BinaryLog.metadataToProto(metadata, 10));
+ // Test edge cases for >= 2 key values
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .addEntry(ENTRY_A)
+ .build(),
+ BinaryLog.metadataToProto(metadata, 19));
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .addEntry(ENTRY_A)
+ .addEntry(ENTRY_B)
+ .build(),
+ BinaryLog.metadataToProto(metadata, 20));
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .addEntry(ENTRY_A)
+ .addEntry(ENTRY_B)
+ .build(),
+ BinaryLog.metadataToProto(metadata, 29));
+ assertEquals(
+ io.grpc.binarylog.Metadata
+ .newBuilder()
+ .addEntry(ENTRY_A)
+ .addEntry(ENTRY_B)
+ .addEntry(ENTRY_C)
+ .build(),
+ BinaryLog.metadataToProto(metadata, 30));
+ }
+
+ @Test
+ public void messageToProto() throws Exception {
+ byte[] bytes = "this is a long message: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ .getBytes(US_ASCII);
+ Message message = BinaryLog.messageToProto(bytes, false, Integer.MAX_VALUE);
+ assertEquals(
+ Message
+ .newBuilder()
+ .setData(ByteString.copyFrom(bytes))
+ .setFlags(0)
+ .setLength(bytes.length)
+ .build(),
+ message);
+ }
+
+ @Test
+ public void messageToProto_truncated() throws Exception {
+ byte[] bytes = "this is a long message: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
+ .getBytes(US_ASCII);
+ assertEquals(
+ Message
+ .newBuilder()
+ .setFlags(0)
+ .setLength(bytes.length)
+ .build(),
+ BinaryLog.messageToProto(bytes, false, 0));
+
+ int limit = 10;
+ assertEquals(
+ Message
+ .newBuilder()
+ .setData(ByteString.copyFrom(bytes, 0, limit))
+ .setFlags(0)
+ .setLength(bytes.length)
+ .build(),
+ BinaryLog.messageToProto(bytes, false, limit));
+ }
+
+ @Test
+ public void toFlag() throws Exception {
+ assertEquals(0, BinaryLog.flagsForMessage(IS_UNCOMPRESSED));
+ assertEquals(1, BinaryLog.flagsForMessage(IS_COMPRESSED));
+ }
+
/** A builder class to make unit test code more readable. */
private static final class Builder {
int maxHeaderBytes = 0;