diff --git a/akka-remote/src/main/java/akka/remote/ContainerFormats.java b/akka-remote/src/main/java/akka/remote/ContainerFormats.java index 1e63dd0f4b..677071914c 100644 --- a/akka-remote/src/main/java/akka/remote/ContainerFormats.java +++ b/akka-remote/src/main/java/akka/remote/ContainerFormats.java @@ -4563,6 +4563,2115 @@ public final class ContainerFormats { // @@protoc_insertion_point(class_scope:Payload) } + public interface ThrowableOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required string className = 1; + /** + * required string className = 1; + */ + boolean hasClassName(); + /** + * required string className = 1; + */ + java.lang.String getClassName(); + /** + * required string className = 1; + */ + akka.protobuf.ByteString + getClassNameBytes(); + + // optional string message = 2; + /** + * optional string message = 2; + */ + boolean hasMessage(); + /** + * optional string message = 2; + */ + java.lang.String getMessage(); + /** + * optional string message = 2; + */ + akka.protobuf.ByteString + getMessageBytes(); + + // optional .Payload cause = 3; + /** + * optional .Payload cause = 3; + */ + boolean hasCause(); + /** + * optional .Payload cause = 3; + */ + akka.remote.ContainerFormats.Payload getCause(); + /** + * optional .Payload cause = 3; + */ + akka.remote.ContainerFormats.PayloadOrBuilder getCauseOrBuilder(); + + // repeated .StackTraceElement stackTrace = 4; + /** + * repeated .StackTraceElement stackTrace = 4; + */ + java.util.List + getStackTraceList(); + /** + * repeated .StackTraceElement stackTrace = 4; + */ + akka.remote.ContainerFormats.StackTraceElement getStackTrace(int index); + /** + * repeated .StackTraceElement stackTrace = 4; + */ + int getStackTraceCount(); + /** + * repeated .StackTraceElement stackTrace = 4; + */ + java.util.List + getStackTraceOrBuilderList(); + /** + * repeated .StackTraceElement stackTrace = 4; + */ + akka.remote.ContainerFormats.StackTraceElementOrBuilder getStackTraceOrBuilder( + int index); + } + /** + * Protobuf type {@code Throwable} + */ + public static final class Throwable extends + akka.protobuf.GeneratedMessage + implements ThrowableOrBuilder { + // Use Throwable.newBuilder() to construct. + private Throwable(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private Throwable(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final Throwable defaultInstance; + public static Throwable getDefaultInstance() { + return defaultInstance; + } + + public Throwable getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Throwable( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + className_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + message_ = input.readBytes(); + break; + } + case 26: { + akka.remote.ContainerFormats.Payload.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + subBuilder = cause_.toBuilder(); + } + cause_ = input.readMessage(akka.remote.ContainerFormats.Payload.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(cause_); + cause_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + stackTrace_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + stackTrace_.add(input.readMessage(akka.remote.ContainerFormats.StackTraceElement.PARSER, extensionRegistry)); + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + stackTrace_ = java.util.Collections.unmodifiableList(stackTrace_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_Throwable_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_Throwable_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.Throwable.class, akka.remote.ContainerFormats.Throwable.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public Throwable parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new Throwable(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string className = 1; + public static final int CLASSNAME_FIELD_NUMBER = 1; + private java.lang.Object className_; + /** + * required string className = 1; + */ + public boolean hasClassName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string className = 1; + */ + public java.lang.String getClassName() { + java.lang.Object ref = className_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + akka.protobuf.ByteString bs = + (akka.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + className_ = s; + } + return s; + } + } + /** + * required string className = 1; + */ + public akka.protobuf.ByteString + getClassNameBytes() { + java.lang.Object ref = className_; + if (ref instanceof java.lang.String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + className_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + + // optional string message = 2; + public static final int MESSAGE_FIELD_NUMBER = 2; + private java.lang.Object message_; + /** + * optional string message = 2; + */ + public boolean hasMessage() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string message = 2; + */ + public java.lang.String getMessage() { + java.lang.Object ref = message_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + akka.protobuf.ByteString bs = + (akka.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + message_ = s; + } + return s; + } + } + /** + * optional string message = 2; + */ + public akka.protobuf.ByteString + getMessageBytes() { + java.lang.Object ref = message_; + if (ref instanceof java.lang.String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + message_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + + // optional .Payload cause = 3; + public static final int CAUSE_FIELD_NUMBER = 3; + private akka.remote.ContainerFormats.Payload cause_; + /** + * optional .Payload cause = 3; + */ + public boolean hasCause() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .Payload cause = 3; + */ + public akka.remote.ContainerFormats.Payload getCause() { + return cause_; + } + /** + * optional .Payload cause = 3; + */ + public akka.remote.ContainerFormats.PayloadOrBuilder getCauseOrBuilder() { + return cause_; + } + + // repeated .StackTraceElement stackTrace = 4; + public static final int STACKTRACE_FIELD_NUMBER = 4; + private java.util.List stackTrace_; + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public java.util.List getStackTraceList() { + return stackTrace_; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public java.util.List + getStackTraceOrBuilderList() { + return stackTrace_; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public int getStackTraceCount() { + return stackTrace_.size(); + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElement getStackTrace(int index) { + return stackTrace_.get(index); + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElementOrBuilder getStackTraceOrBuilder( + int index) { + return stackTrace_.get(index); + } + + private void initFields() { + className_ = ""; + message_ = ""; + cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + stackTrace_ = java.util.Collections.emptyList(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasClassName()) { + memoizedIsInitialized = 0; + return false; + } + if (hasCause()) { + if (!getCause().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getStackTraceCount(); i++) { + if (!getStackTrace(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getClassNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getMessageBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeMessage(3, cause_); + } + for (int i = 0; i < stackTrace_.size(); i++) { + output.writeMessage(4, stackTrace_.get(i)); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeBytesSize(1, getClassNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeBytesSize(2, getMessageBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(3, cause_); + } + for (int i = 0; i < stackTrace_.size(); i++) { + size += akka.protobuf.CodedOutputStream + .computeMessageSize(4, stackTrace_.get(i)); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.ContainerFormats.Throwable parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.Throwable parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.Throwable parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.Throwable parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.Throwable parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.Throwable parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.Throwable parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.ContainerFormats.Throwable parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.Throwable parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.Throwable parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.ContainerFormats.Throwable prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Throwable} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.ContainerFormats.ThrowableOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_Throwable_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_Throwable_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.Throwable.class, akka.remote.ContainerFormats.Throwable.Builder.class); + } + + // Construct using akka.remote.ContainerFormats.Throwable.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getCauseFieldBuilder(); + getStackTraceFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + className_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + message_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + if (causeBuilder_ == null) { + cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + } else { + causeBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (stackTraceBuilder_ == null) { + stackTrace_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + stackTraceBuilder_.clear(); + } + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.ContainerFormats.internal_static_Throwable_descriptor; + } + + public akka.remote.ContainerFormats.Throwable getDefaultInstanceForType() { + return akka.remote.ContainerFormats.Throwable.getDefaultInstance(); + } + + public akka.remote.ContainerFormats.Throwable build() { + akka.remote.ContainerFormats.Throwable result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.ContainerFormats.Throwable buildPartial() { + akka.remote.ContainerFormats.Throwable result = new akka.remote.ContainerFormats.Throwable(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.className_ = className_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.message_ = message_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + if (causeBuilder_ == null) { + result.cause_ = cause_; + } else { + result.cause_ = causeBuilder_.build(); + } + if (stackTraceBuilder_ == null) { + if (((bitField0_ & 0x00000008) == 0x00000008)) { + stackTrace_ = java.util.Collections.unmodifiableList(stackTrace_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.stackTrace_ = stackTrace_; + } else { + result.stackTrace_ = stackTraceBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.ContainerFormats.Throwable) { + return mergeFrom((akka.remote.ContainerFormats.Throwable)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.ContainerFormats.Throwable other) { + if (other == akka.remote.ContainerFormats.Throwable.getDefaultInstance()) return this; + if (other.hasClassName()) { + bitField0_ |= 0x00000001; + className_ = other.className_; + onChanged(); + } + if (other.hasMessage()) { + bitField0_ |= 0x00000002; + message_ = other.message_; + onChanged(); + } + if (other.hasCause()) { + mergeCause(other.getCause()); + } + if (stackTraceBuilder_ == null) { + if (!other.stackTrace_.isEmpty()) { + if (stackTrace_.isEmpty()) { + stackTrace_ = other.stackTrace_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureStackTraceIsMutable(); + stackTrace_.addAll(other.stackTrace_); + } + onChanged(); + } + } else { + if (!other.stackTrace_.isEmpty()) { + if (stackTraceBuilder_.isEmpty()) { + stackTraceBuilder_.dispose(); + stackTraceBuilder_ = null; + stackTrace_ = other.stackTrace_; + bitField0_ = (bitField0_ & ~0x00000008); + stackTraceBuilder_ = + akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getStackTraceFieldBuilder() : null; + } else { + stackTraceBuilder_.addAllMessages(other.stackTrace_); + } + } + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasClassName()) { + + return false; + } + if (hasCause()) { + if (!getCause().isInitialized()) { + + return false; + } + } + for (int i = 0; i < getStackTraceCount(); i++) { + if (!getStackTrace(i).isInitialized()) { + + return false; + } + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.ContainerFormats.Throwable parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.ContainerFormats.Throwable) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string className = 1; + private java.lang.Object className_ = ""; + /** + * required string className = 1; + */ + public boolean hasClassName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string className = 1; + */ + public java.lang.String getClassName() { + java.lang.Object ref = className_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((akka.protobuf.ByteString) ref) + .toStringUtf8(); + className_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string className = 1; + */ + public akka.protobuf.ByteString + getClassNameBytes() { + java.lang.Object ref = className_; + if (ref instanceof String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + className_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + /** + * required string className = 1; + */ + public Builder setClassName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + className_ = value; + onChanged(); + return this; + } + /** + * required string className = 1; + */ + public Builder clearClassName() { + bitField0_ = (bitField0_ & ~0x00000001); + className_ = getDefaultInstance().getClassName(); + onChanged(); + return this; + } + /** + * required string className = 1; + */ + public Builder setClassNameBytes( + akka.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + className_ = value; + onChanged(); + return this; + } + + // optional string message = 2; + private java.lang.Object message_ = ""; + /** + * optional string message = 2; + */ + public boolean hasMessage() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * optional string message = 2; + */ + public java.lang.String getMessage() { + java.lang.Object ref = message_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((akka.protobuf.ByteString) ref) + .toStringUtf8(); + message_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string message = 2; + */ + public akka.protobuf.ByteString + getMessageBytes() { + java.lang.Object ref = message_; + if (ref instanceof String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + message_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + /** + * optional string message = 2; + */ + public Builder setMessage( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + message_ = value; + onChanged(); + return this; + } + /** + * optional string message = 2; + */ + public Builder clearMessage() { + bitField0_ = (bitField0_ & ~0x00000002); + message_ = getDefaultInstance().getMessage(); + onChanged(); + return this; + } + /** + * optional string message = 2; + */ + public Builder setMessageBytes( + akka.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + message_ = value; + onChanged(); + return this; + } + + // optional .Payload cause = 3; + private akka.remote.ContainerFormats.Payload cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder> causeBuilder_; + /** + * optional .Payload cause = 3; + */ + public boolean hasCause() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * optional .Payload cause = 3; + */ + public akka.remote.ContainerFormats.Payload getCause() { + if (causeBuilder_ == null) { + return cause_; + } else { + return causeBuilder_.getMessage(); + } + } + /** + * optional .Payload cause = 3; + */ + public Builder setCause(akka.remote.ContainerFormats.Payload value) { + if (causeBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + cause_ = value; + onChanged(); + } else { + causeBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Payload cause = 3; + */ + public Builder setCause( + akka.remote.ContainerFormats.Payload.Builder builderForValue) { + if (causeBuilder_ == null) { + cause_ = builderForValue.build(); + onChanged(); + } else { + causeBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Payload cause = 3; + */ + public Builder mergeCause(akka.remote.ContainerFormats.Payload value) { + if (causeBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + cause_ != akka.remote.ContainerFormats.Payload.getDefaultInstance()) { + cause_ = + akka.remote.ContainerFormats.Payload.newBuilder(cause_).mergeFrom(value).buildPartial(); + } else { + cause_ = value; + } + onChanged(); + } else { + causeBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Payload cause = 3; + */ + public Builder clearCause() { + if (causeBuilder_ == null) { + cause_ = akka.remote.ContainerFormats.Payload.getDefaultInstance(); + onChanged(); + } else { + causeBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * optional .Payload cause = 3; + */ + public akka.remote.ContainerFormats.Payload.Builder getCauseBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCauseFieldBuilder().getBuilder(); + } + /** + * optional .Payload cause = 3; + */ + public akka.remote.ContainerFormats.PayloadOrBuilder getCauseOrBuilder() { + if (causeBuilder_ != null) { + return causeBuilder_.getMessageOrBuilder(); + } else { + return cause_; + } + } + /** + * optional .Payload cause = 3; + */ + private akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder> + getCauseFieldBuilder() { + if (causeBuilder_ == null) { + causeBuilder_ = new akka.protobuf.SingleFieldBuilder< + akka.remote.ContainerFormats.Payload, akka.remote.ContainerFormats.Payload.Builder, akka.remote.ContainerFormats.PayloadOrBuilder>( + cause_, + getParentForChildren(), + isClean()); + cause_ = null; + } + return causeBuilder_; + } + + // repeated .StackTraceElement stackTrace = 4; + private java.util.List stackTrace_ = + java.util.Collections.emptyList(); + private void ensureStackTraceIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + stackTrace_ = new java.util.ArrayList(stackTrace_); + bitField0_ |= 0x00000008; + } + } + + private akka.protobuf.RepeatedFieldBuilder< + akka.remote.ContainerFormats.StackTraceElement, akka.remote.ContainerFormats.StackTraceElement.Builder, akka.remote.ContainerFormats.StackTraceElementOrBuilder> stackTraceBuilder_; + + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public java.util.List getStackTraceList() { + if (stackTraceBuilder_ == null) { + return java.util.Collections.unmodifiableList(stackTrace_); + } else { + return stackTraceBuilder_.getMessageList(); + } + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public int getStackTraceCount() { + if (stackTraceBuilder_ == null) { + return stackTrace_.size(); + } else { + return stackTraceBuilder_.getCount(); + } + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElement getStackTrace(int index) { + if (stackTraceBuilder_ == null) { + return stackTrace_.get(index); + } else { + return stackTraceBuilder_.getMessage(index); + } + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder setStackTrace( + int index, akka.remote.ContainerFormats.StackTraceElement value) { + if (stackTraceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStackTraceIsMutable(); + stackTrace_.set(index, value); + onChanged(); + } else { + stackTraceBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder setStackTrace( + int index, akka.remote.ContainerFormats.StackTraceElement.Builder builderForValue) { + if (stackTraceBuilder_ == null) { + ensureStackTraceIsMutable(); + stackTrace_.set(index, builderForValue.build()); + onChanged(); + } else { + stackTraceBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder addStackTrace(akka.remote.ContainerFormats.StackTraceElement value) { + if (stackTraceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStackTraceIsMutable(); + stackTrace_.add(value); + onChanged(); + } else { + stackTraceBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder addStackTrace( + int index, akka.remote.ContainerFormats.StackTraceElement value) { + if (stackTraceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureStackTraceIsMutable(); + stackTrace_.add(index, value); + onChanged(); + } else { + stackTraceBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder addStackTrace( + akka.remote.ContainerFormats.StackTraceElement.Builder builderForValue) { + if (stackTraceBuilder_ == null) { + ensureStackTraceIsMutable(); + stackTrace_.add(builderForValue.build()); + onChanged(); + } else { + stackTraceBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder addStackTrace( + int index, akka.remote.ContainerFormats.StackTraceElement.Builder builderForValue) { + if (stackTraceBuilder_ == null) { + ensureStackTraceIsMutable(); + stackTrace_.add(index, builderForValue.build()); + onChanged(); + } else { + stackTraceBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder addAllStackTrace( + java.lang.Iterable values) { + if (stackTraceBuilder_ == null) { + ensureStackTraceIsMutable(); + super.addAll(values, stackTrace_); + onChanged(); + } else { + stackTraceBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder clearStackTrace() { + if (stackTraceBuilder_ == null) { + stackTrace_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + stackTraceBuilder_.clear(); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public Builder removeStackTrace(int index) { + if (stackTraceBuilder_ == null) { + ensureStackTraceIsMutable(); + stackTrace_.remove(index); + onChanged(); + } else { + stackTraceBuilder_.remove(index); + } + return this; + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElement.Builder getStackTraceBuilder( + int index) { + return getStackTraceFieldBuilder().getBuilder(index); + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElementOrBuilder getStackTraceOrBuilder( + int index) { + if (stackTraceBuilder_ == null) { + return stackTrace_.get(index); } else { + return stackTraceBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public java.util.List + getStackTraceOrBuilderList() { + if (stackTraceBuilder_ != null) { + return stackTraceBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(stackTrace_); + } + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElement.Builder addStackTraceBuilder() { + return getStackTraceFieldBuilder().addBuilder( + akka.remote.ContainerFormats.StackTraceElement.getDefaultInstance()); + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public akka.remote.ContainerFormats.StackTraceElement.Builder addStackTraceBuilder( + int index) { + return getStackTraceFieldBuilder().addBuilder( + index, akka.remote.ContainerFormats.StackTraceElement.getDefaultInstance()); + } + /** + * repeated .StackTraceElement stackTrace = 4; + */ + public java.util.List + getStackTraceBuilderList() { + return getStackTraceFieldBuilder().getBuilderList(); + } + private akka.protobuf.RepeatedFieldBuilder< + akka.remote.ContainerFormats.StackTraceElement, akka.remote.ContainerFormats.StackTraceElement.Builder, akka.remote.ContainerFormats.StackTraceElementOrBuilder> + getStackTraceFieldBuilder() { + if (stackTraceBuilder_ == null) { + stackTraceBuilder_ = new akka.protobuf.RepeatedFieldBuilder< + akka.remote.ContainerFormats.StackTraceElement, akka.remote.ContainerFormats.StackTraceElement.Builder, akka.remote.ContainerFormats.StackTraceElementOrBuilder>( + stackTrace_, + ((bitField0_ & 0x00000008) == 0x00000008), + getParentForChildren(), + isClean()); + stackTrace_ = null; + } + return stackTraceBuilder_; + } + + // @@protoc_insertion_point(builder_scope:Throwable) + } + + static { + defaultInstance = new Throwable(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:Throwable) + } + + public interface StackTraceElementOrBuilder + extends akka.protobuf.MessageOrBuilder { + + // required string className = 1; + /** + * required string className = 1; + */ + boolean hasClassName(); + /** + * required string className = 1; + */ + java.lang.String getClassName(); + /** + * required string className = 1; + */ + akka.protobuf.ByteString + getClassNameBytes(); + + // required string methodName = 2; + /** + * required string methodName = 2; + */ + boolean hasMethodName(); + /** + * required string methodName = 2; + */ + java.lang.String getMethodName(); + /** + * required string methodName = 2; + */ + akka.protobuf.ByteString + getMethodNameBytes(); + + // required string fileName = 3; + /** + * required string fileName = 3; + */ + boolean hasFileName(); + /** + * required string fileName = 3; + */ + java.lang.String getFileName(); + /** + * required string fileName = 3; + */ + akka.protobuf.ByteString + getFileNameBytes(); + + // required int32 lineNumber = 4; + /** + * required int32 lineNumber = 4; + */ + boolean hasLineNumber(); + /** + * required int32 lineNumber = 4; + */ + int getLineNumber(); + } + /** + * Protobuf type {@code StackTraceElement} + */ + public static final class StackTraceElement extends + akka.protobuf.GeneratedMessage + implements StackTraceElementOrBuilder { + // Use StackTraceElement.newBuilder() to construct. + private StackTraceElement(akka.protobuf.GeneratedMessage.Builder builder) { + super(builder); + this.unknownFields = builder.getUnknownFields(); + } + private StackTraceElement(boolean noInit) { this.unknownFields = akka.protobuf.UnknownFieldSet.getDefaultInstance(); } + + private static final StackTraceElement defaultInstance; + public static StackTraceElement getDefaultInstance() { + return defaultInstance; + } + + public StackTraceElement getDefaultInstanceForType() { + return defaultInstance; + } + + private final akka.protobuf.UnknownFieldSet unknownFields; + @java.lang.Override + public final akka.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private StackTraceElement( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + initFields(); + int mutable_bitField0_ = 0; + akka.protobuf.UnknownFieldSet.Builder unknownFields = + akka.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + done = true; + } + break; + } + case 10: { + bitField0_ |= 0x00000001; + className_ = input.readBytes(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + methodName_ = input.readBytes(); + break; + } + case 26: { + bitField0_ |= 0x00000004; + fileName_ = input.readBytes(); + break; + } + case 32: { + bitField0_ |= 0x00000008; + lineNumber_ = input.readInt32(); + break; + } + } + } + } catch (akka.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new akka.protobuf.InvalidProtocolBufferException( + e.getMessage()).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_StackTraceElement_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_StackTraceElement_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.StackTraceElement.class, akka.remote.ContainerFormats.StackTraceElement.Builder.class); + } + + public static akka.protobuf.Parser PARSER = + new akka.protobuf.AbstractParser() { + public StackTraceElement parsePartialFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return new StackTraceElement(input, extensionRegistry); + } + }; + + @java.lang.Override + public akka.protobuf.Parser getParserForType() { + return PARSER; + } + + private int bitField0_; + // required string className = 1; + public static final int CLASSNAME_FIELD_NUMBER = 1; + private java.lang.Object className_; + /** + * required string className = 1; + */ + public boolean hasClassName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string className = 1; + */ + public java.lang.String getClassName() { + java.lang.Object ref = className_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + akka.protobuf.ByteString bs = + (akka.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + className_ = s; + } + return s; + } + } + /** + * required string className = 1; + */ + public akka.protobuf.ByteString + getClassNameBytes() { + java.lang.Object ref = className_; + if (ref instanceof java.lang.String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + className_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + + // required string methodName = 2; + public static final int METHODNAME_FIELD_NUMBER = 2; + private java.lang.Object methodName_; + /** + * required string methodName = 2; + */ + public boolean hasMethodName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string methodName = 2; + */ + public java.lang.String getMethodName() { + java.lang.Object ref = methodName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + akka.protobuf.ByteString bs = + (akka.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + methodName_ = s; + } + return s; + } + } + /** + * required string methodName = 2; + */ + public akka.protobuf.ByteString + getMethodNameBytes() { + java.lang.Object ref = methodName_; + if (ref instanceof java.lang.String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + methodName_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + + // required string fileName = 3; + public static final int FILENAME_FIELD_NUMBER = 3; + private java.lang.Object fileName_; + /** + * required string fileName = 3; + */ + public boolean hasFileName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string fileName = 3; + */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + akka.protobuf.ByteString bs = + (akka.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + fileName_ = s; + } + return s; + } + } + /** + * required string fileName = 3; + */ + public akka.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof java.lang.String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + + // required int32 lineNumber = 4; + public static final int LINENUMBER_FIELD_NUMBER = 4; + private int lineNumber_; + /** + * required int32 lineNumber = 4; + */ + public boolean hasLineNumber() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 lineNumber = 4; + */ + public int getLineNumber() { + return lineNumber_; + } + + private void initFields() { + className_ = ""; + methodName_ = ""; + fileName_ = ""; + lineNumber_ = 0; + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasClassName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMethodName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasFileName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLineNumber()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(akka.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeBytes(1, getClassNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeBytes(2, getMethodNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeBytes(3, getFileNameBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeInt32(4, lineNumber_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += akka.protobuf.CodedOutputStream + .computeBytesSize(1, getClassNameBytes()); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += akka.protobuf.CodedOutputStream + .computeBytesSize(2, getMethodNameBytes()); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += akka.protobuf.CodedOutputStream + .computeBytesSize(3, getFileNameBytes()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += akka.protobuf.CodedOutputStream + .computeInt32Size(4, lineNumber_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + public static akka.remote.ContainerFormats.StackTraceElement parseFrom( + akka.protobuf.ByteString data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom( + akka.protobuf.ByteString data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom(byte[] data) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom( + byte[] data, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws akka.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.StackTraceElement parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input); + } + public static akka.remote.ContainerFormats.StackTraceElement parseDelimitedFrom( + java.io.InputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseDelimitedFrom(input, extensionRegistry); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom( + akka.protobuf.CodedInputStream input) + throws java.io.IOException { + return PARSER.parseFrom(input); + } + public static akka.remote.ContainerFormats.StackTraceElement parseFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return PARSER.parseFrom(input, extensionRegistry); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(akka.remote.ContainerFormats.StackTraceElement prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code StackTraceElement} + */ + public static final class Builder extends + akka.protobuf.GeneratedMessage.Builder + implements akka.remote.ContainerFormats.StackTraceElementOrBuilder { + public static final akka.protobuf.Descriptors.Descriptor + getDescriptor() { + return akka.remote.ContainerFormats.internal_static_StackTraceElement_descriptor; + } + + protected akka.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return akka.remote.ContainerFormats.internal_static_StackTraceElement_fieldAccessorTable + .ensureFieldAccessorsInitialized( + akka.remote.ContainerFormats.StackTraceElement.class, akka.remote.ContainerFormats.StackTraceElement.Builder.class); + } + + // Construct using akka.remote.ContainerFormats.StackTraceElement.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + akka.protobuf.GeneratedMessage.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (akka.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + className_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + methodName_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + fileName_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + lineNumber_ = 0; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public akka.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return akka.remote.ContainerFormats.internal_static_StackTraceElement_descriptor; + } + + public akka.remote.ContainerFormats.StackTraceElement getDefaultInstanceForType() { + return akka.remote.ContainerFormats.StackTraceElement.getDefaultInstance(); + } + + public akka.remote.ContainerFormats.StackTraceElement build() { + akka.remote.ContainerFormats.StackTraceElement result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + public akka.remote.ContainerFormats.StackTraceElement buildPartial() { + akka.remote.ContainerFormats.StackTraceElement result = new akka.remote.ContainerFormats.StackTraceElement(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.className_ = className_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.methodName_ = methodName_; + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000004; + } + result.fileName_ = fileName_; + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000008; + } + result.lineNumber_ = lineNumber_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(akka.protobuf.Message other) { + if (other instanceof akka.remote.ContainerFormats.StackTraceElement) { + return mergeFrom((akka.remote.ContainerFormats.StackTraceElement)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(akka.remote.ContainerFormats.StackTraceElement other) { + if (other == akka.remote.ContainerFormats.StackTraceElement.getDefaultInstance()) return this; + if (other.hasClassName()) { + bitField0_ |= 0x00000001; + className_ = other.className_; + onChanged(); + } + if (other.hasMethodName()) { + bitField0_ |= 0x00000002; + methodName_ = other.methodName_; + onChanged(); + } + if (other.hasFileName()) { + bitField0_ |= 0x00000004; + fileName_ = other.fileName_; + onChanged(); + } + if (other.hasLineNumber()) { + setLineNumber(other.getLineNumber()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasClassName()) { + + return false; + } + if (!hasMethodName()) { + + return false; + } + if (!hasFileName()) { + + return false; + } + if (!hasLineNumber()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + akka.protobuf.CodedInputStream input, + akka.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + akka.remote.ContainerFormats.StackTraceElement parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (akka.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (akka.remote.ContainerFormats.StackTraceElement) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + // required string className = 1; + private java.lang.Object className_ = ""; + /** + * required string className = 1; + */ + public boolean hasClassName() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + /** + * required string className = 1; + */ + public java.lang.String getClassName() { + java.lang.Object ref = className_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((akka.protobuf.ByteString) ref) + .toStringUtf8(); + className_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string className = 1; + */ + public akka.protobuf.ByteString + getClassNameBytes() { + java.lang.Object ref = className_; + if (ref instanceof String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + className_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + /** + * required string className = 1; + */ + public Builder setClassName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + className_ = value; + onChanged(); + return this; + } + /** + * required string className = 1; + */ + public Builder clearClassName() { + bitField0_ = (bitField0_ & ~0x00000001); + className_ = getDefaultInstance().getClassName(); + onChanged(); + return this; + } + /** + * required string className = 1; + */ + public Builder setClassNameBytes( + akka.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + className_ = value; + onChanged(); + return this; + } + + // required string methodName = 2; + private java.lang.Object methodName_ = ""; + /** + * required string methodName = 2; + */ + public boolean hasMethodName() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + /** + * required string methodName = 2; + */ + public java.lang.String getMethodName() { + java.lang.Object ref = methodName_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((akka.protobuf.ByteString) ref) + .toStringUtf8(); + methodName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string methodName = 2; + */ + public akka.protobuf.ByteString + getMethodNameBytes() { + java.lang.Object ref = methodName_; + if (ref instanceof String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + methodName_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + /** + * required string methodName = 2; + */ + public Builder setMethodName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + methodName_ = value; + onChanged(); + return this; + } + /** + * required string methodName = 2; + */ + public Builder clearMethodName() { + bitField0_ = (bitField0_ & ~0x00000002); + methodName_ = getDefaultInstance().getMethodName(); + onChanged(); + return this; + } + /** + * required string methodName = 2; + */ + public Builder setMethodNameBytes( + akka.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + methodName_ = value; + onChanged(); + return this; + } + + // required string fileName = 3; + private java.lang.Object fileName_ = ""; + /** + * required string fileName = 3; + */ + public boolean hasFileName() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + /** + * required string fileName = 3; + */ + public java.lang.String getFileName() { + java.lang.Object ref = fileName_; + if (!(ref instanceof java.lang.String)) { + java.lang.String s = ((akka.protobuf.ByteString) ref) + .toStringUtf8(); + fileName_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string fileName = 3; + */ + public akka.protobuf.ByteString + getFileNameBytes() { + java.lang.Object ref = fileName_; + if (ref instanceof String) { + akka.protobuf.ByteString b = + akka.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + fileName_ = b; + return b; + } else { + return (akka.protobuf.ByteString) ref; + } + } + /** + * required string fileName = 3; + */ + public Builder setFileName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + fileName_ = value; + onChanged(); + return this; + } + /** + * required string fileName = 3; + */ + public Builder clearFileName() { + bitField0_ = (bitField0_ & ~0x00000004); + fileName_ = getDefaultInstance().getFileName(); + onChanged(); + return this; + } + /** + * required string fileName = 3; + */ + public Builder setFileNameBytes( + akka.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + fileName_ = value; + onChanged(); + return this; + } + + // required int32 lineNumber = 4; + private int lineNumber_ ; + /** + * required int32 lineNumber = 4; + */ + public boolean hasLineNumber() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + /** + * required int32 lineNumber = 4; + */ + public int getLineNumber() { + return lineNumber_; + } + /** + * required int32 lineNumber = 4; + */ + public Builder setLineNumber(int value) { + bitField0_ |= 0x00000008; + lineNumber_ = value; + onChanged(); + return this; + } + /** + * required int32 lineNumber = 4; + */ + public Builder clearLineNumber() { + bitField0_ = (bitField0_ & ~0x00000008); + lineNumber_ = 0; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:StackTraceElement) + } + + static { + defaultInstance = new StackTraceElement(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:StackTraceElement) + } + private static akka.protobuf.Descriptors.Descriptor internal_static_SelectionEnvelope_descriptor; private static @@ -4598,6 +6707,16 @@ public final class ContainerFormats { private static akka.protobuf.GeneratedMessage.FieldAccessorTable internal_static_Payload_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_Throwable_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_Throwable_fieldAccessorTable; + private static akka.protobuf.Descriptors.Descriptor + internal_static_StackTraceElement_descriptor; + private static + akka.protobuf.GeneratedMessage.FieldAccessorTable + internal_static_StackTraceElement_fieldAccessorTable; public static akka.protobuf.Descriptors.FileDescriptor getDescriptor() { @@ -4619,9 +6738,14 @@ public final class ContainerFormats { "path\030\001 \002(\t\"!\n\006Option\022\027\n\005value\030\001 \001(\0132\010.Pa", "yload\"Q\n\007Payload\022\027\n\017enclosedMessage\030\001 \002(" + "\014\022\024\n\014serializerId\030\002 \002(\005\022\027\n\017messageManife" + - "st\030\004 \001(\014*<\n\013PatternType\022\n\n\006PARENT\020\000\022\016\n\nC" + - "HILD_NAME\020\001\022\021\n\rCHILD_PATTERN\020\002B\017\n\013akka.r" + - "emoteH\001" + "st\030\004 \001(\014\"p\n\tThrowable\022\021\n\tclassName\030\001 \002(\t" + + "\022\017\n\007message\030\002 \001(\t\022\027\n\005cause\030\003 \001(\0132\010.Paylo" + + "ad\022&\n\nstackTrace\030\004 \003(\0132\022.StackTraceEleme" + + "nt\"`\n\021StackTraceElement\022\021\n\tclassName\030\001 \002" + + "(\t\022\022\n\nmethodName\030\002 \002(\t\022\020\n\010fileName\030\003 \002(\t" + + "\022\022\n\nlineNumber\030\004 \002(\005*<\n\013PatternType\022\n\n\006P" + + "ARENT\020\000\022\016\n\nCHILD_NAME\020\001\022\021\n\rCHILD_PATTERN" + + "\020\002B\017\n\013akka.remoteH\001" }; akka.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new akka.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @@ -4670,6 +6794,18 @@ public final class ContainerFormats { akka.protobuf.GeneratedMessage.FieldAccessorTable( internal_static_Payload_descriptor, new java.lang.String[] { "EnclosedMessage", "SerializerId", "MessageManifest", }); + internal_static_Throwable_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_Throwable_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_Throwable_descriptor, + new java.lang.String[] { "ClassName", "Message", "Cause", "StackTrace", }); + internal_static_StackTraceElement_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_StackTraceElement_fieldAccessorTable = new + akka.protobuf.GeneratedMessage.FieldAccessorTable( + internal_static_StackTraceElement_descriptor, + new java.lang.String[] { "ClassName", "MethodName", "FileName", "LineNumber", }); return null; } }; diff --git a/akka-remote/src/main/protobuf/ContainerFormats.proto b/akka-remote/src/main/protobuf/ContainerFormats.proto index 84785740c4..6ff9fda613 100644 --- a/akka-remote/src/main/protobuf/ContainerFormats.proto +++ b/akka-remote/src/main/protobuf/ContainerFormats.proto @@ -50,3 +50,17 @@ message Payload { required int32 serializerId = 2; optional bytes messageManifest = 4; } + +message Throwable { + required string className = 1; + optional string message = 2; + optional Payload cause = 3; + repeated StackTraceElement stackTrace = 4; +} + +message StackTraceElement { + required string className = 1; + required string methodName = 2; + required string fileName = 3; + required int32 lineNumber = 4; +} diff --git a/akka-remote/src/main/resources/reference.conf b/akka-remote/src/main/resources/reference.conf index 721d1bad78..c28ee7ae2c 100644 --- a/akka-remote/src/main/resources/reference.conf +++ b/akka-remote/src/main/resources/reference.conf @@ -48,6 +48,23 @@ akka { "akka.actor.ActorIdentity" = akka-misc "scala.Some" = akka-misc "scala.None$" = akka-misc + "akka.actor.Status$Success" = akka-misc + "akka.actor.Status$Failure" = akka-misc + + # Java Serializer is by default used for exceptions. + # It's recommended that you implement custom serializer for exceptions that are + # sent remotely, e.g. in akka.actor.Status.Failure for ask replies. You can add + # binding to akka-misc (MiscMessageSerializerSpec) for the exceptions that have + # a constructor with single message String or constructor with message String as + # first parameter and cause Throwable as second parameter. Note that it's not + # safe to add this binding for general exceptions such as IllegalArgumentException + # because it may have a subclass without required constructor. + "java.lang.Throwable" = java + "akka.actor.IllegalActorStateException" = akka-misc + "akka.actor.ActorKilledException" = akka-misc + "akka.actor.InvalidActorNameException" = akka-misc + "akka.actor.InvalidMessageException" = akka-misc + } serialization-identifiers { diff --git a/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala b/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala index 025511de9c..266773c78e 100644 --- a/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala +++ b/akka-remote/src/main/scala/akka/remote/serialization/MiscMessageSerializer.scala @@ -11,6 +11,8 @@ import akka.serialization.{ Serialization, BaseSerializer, SerializationExtensio class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerWithStringManifest with BaseSerializer { private lazy val serialization = SerializationExtension(system) + private val payloadSupport = new WrappedPayloadSupport(system) + private val throwableSupport = new ThrowableSupport(system) private val NoneSerialized = Array.empty[Byte] @@ -19,19 +21,22 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW case identity: ActorIdentity ⇒ serializeActorIdentity(identity) case Some(value) ⇒ serializeSome(value) case None ⇒ NoneSerialized + case s: Status.Success ⇒ serializeStatusSuccess(s) + case f: Status.Failure ⇒ serializeStatusFailure(f) + case t: Throwable ⇒ throwableSupport.serializeThrowable(t) case _ ⇒ throw new IllegalArgumentException(s"Cannot serialize object of type [${obj.getClass.getName}]") } private def serializeIdentify(identify: Identify): Array[Byte] = ContainerFormats.Identify.newBuilder() - .setMessageId(payloadBuilder(identify.messageId)) + .setMessageId(payloadSupport.payloadBuilder(identify.messageId)) .build() .toByteArray private def serializeActorIdentity(actorIdentity: ActorIdentity): Array[Byte] = { val builder = ContainerFormats.ActorIdentity.newBuilder() - .setCorrelationId(payloadBuilder(actorIdentity.correlationId)) + .setCorrelationId(payloadSupport.payloadBuilder(actorIdentity.correlationId)) actorIdentity.ref.foreach { actorRef ⇒ builder.setRef(actorRefBuilder(actorRef)) @@ -44,7 +49,7 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW private def serializeSome(someValue: Any): Array[Byte] = ContainerFormats.Option.newBuilder() - .setValue(payloadBuilder(someValue)) + .setValue(payloadSupport.payloadBuilder(someValue)) .build() .toByteArray @@ -52,43 +57,35 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW ContainerFormats.ActorRef.newBuilder() .setPath(Serialization.serializedActorPath(actorRef)) - private def payloadBuilder(input: Any): ContainerFormats.Payload.Builder = { - val payload = input.asInstanceOf[AnyRef] - val builder = ContainerFormats.Payload.newBuilder() - val serializer = serialization.findSerializerFor(payload) + private def serializeStatusSuccess(success: Status.Success): Array[Byte] = + payloadSupport.payloadBuilder(success.status).build().toByteArray - builder - .setEnclosedMessage(ByteString.copyFrom(serializer.toBinary(payload))) - .setSerializerId(serializer.identifier) - - serializer match { - case ser2: SerializerWithStringManifest ⇒ - val manifest = ser2.manifest(payload) - if (manifest != "") - builder.setMessageManifest(ByteString.copyFromUtf8(manifest)) - case _ ⇒ - if (serializer.includeManifest) - builder.setMessageManifest(ByteString.copyFromUtf8(payload.getClass.getName)) - } - - builder - } + private def serializeStatusFailure(failure: Status.Failure): Array[Byte] = + payloadSupport.payloadBuilder(failure.cause).build().toByteArray private val IdentifyManifest = "A" private val ActorIdentifyManifest = "B" private val OptionManifest = "C" + private val StatusSuccessManifest = "D" + private val StatusFailureManifest = "E" + private val ThrowableManifest = "F" private val fromBinaryMap = Map[String, Array[Byte] ⇒ AnyRef]( IdentifyManifest → deserializeIdentify, ActorIdentifyManifest → deserializeActorIdentity, - OptionManifest → deserializeOption - ) + OptionManifest → deserializeOption, + StatusSuccessManifest → deserializeStatusSuccess, + StatusFailureManifest → deserializeStatusFailure, + ThrowableManifest → throwableSupport.deserializeThrowable) override def manifest(o: AnyRef): String = o match { - case _: Identify ⇒ IdentifyManifest - case _: ActorIdentity ⇒ ActorIdentifyManifest - case _: Option[Any] ⇒ OptionManifest + case _: Identify ⇒ IdentifyManifest + case _: ActorIdentity ⇒ ActorIdentifyManifest + case _: Option[Any] ⇒ OptionManifest + case _: Status.Success ⇒ StatusSuccessManifest + case _: Status.Failure ⇒ StatusFailureManifest + case _: Throwable ⇒ ThrowableManifest case _ ⇒ throw new IllegalArgumentException(s"Can't serialize object of type ${o.getClass} in [${getClass.getName}]") } @@ -102,13 +99,13 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW private def deserializeIdentify(bytes: Array[Byte]): Identify = { val identifyProto = ContainerFormats.Identify.parseFrom(bytes) - val messageId = deserializePayload(identifyProto.getMessageId) + val messageId = payloadSupport.deserializePayload(identifyProto.getMessageId) Identify(messageId) } private def deserializeActorIdentity(bytes: Array[Byte]): ActorIdentity = { val actorIdentityProto = ContainerFormats.ActorIdentity.parseFrom(bytes) - val correlationId = deserializePayload(actorIdentityProto.getCorrelationId) + val correlationId = payloadSupport.deserializePayload(actorIdentityProto.getCorrelationId) val actorRef = if (actorIdentityProto.hasRef) Some(deserializeActorRef(actorIdentityProto.getRef)) @@ -125,16 +122,14 @@ class MiscMessageSerializer(val system: ExtendedActorSystem) extends SerializerW None else { val optionProto = ContainerFormats.Option.parseFrom(bytes) - Some(deserializePayload(optionProto.getValue)) + Some(payloadSupport.deserializePayload(optionProto.getValue)) } } - private def deserializePayload(payload: ContainerFormats.Payload): Any = { - val manifest = if (payload.hasMessageManifest) payload.getMessageManifest.toStringUtf8 else "" - serialization.deserialize( - payload.getEnclosedMessage.toByteArray, - payload.getSerializerId, - manifest).get - } + private def deserializeStatusSuccess(bytes: Array[Byte]): Status.Success = + Status.Success(payloadSupport.deserializePayload(ContainerFormats.Payload.parseFrom(bytes))) + + private def deserializeStatusFailure(bytes: Array[Byte]): Status.Failure = + Status.Failure(payloadSupport.deserializePayload(ContainerFormats.Payload.parseFrom(bytes)).asInstanceOf[Throwable]) } diff --git a/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala b/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala new file mode 100644 index 0000000000..136f822da2 --- /dev/null +++ b/akka-remote/src/main/scala/akka/remote/serialization/ThrowableSupport.scala @@ -0,0 +1,73 @@ +/** + * Copyright (C) 2016 Lightbend Inc. + */ +package akka.remote.serialization + +import akka.actor.ExtendedActorSystem +import akka.remote.ContainerFormats +import akka.serialization.SerializationExtension + +/** + * INTERNAL API + */ +private[akka] class ThrowableSupport(system: ExtendedActorSystem) { + + private lazy val serialization = SerializationExtension(system) + private val payloadSupport = new WrappedPayloadSupport(system) + + def serializeThrowable(t: Throwable): Array[Byte] = { + val b = ContainerFormats.Throwable.newBuilder() + .setClassName(t.getClass.getName) + if (t.getMessage != null) + b.setMessage(t.getMessage) + if (t.getCause != null) + b.setCause(payloadSupport.payloadBuilder(t.getCause)) + val stackTrace = t.getStackTrace + if (stackTrace != null) { + var i = 0 + while (i < stackTrace.length) { + b.addStackTrace(stackTraceElementBuilder(stackTrace(i))) + i += 1 + } + } + + b.build().toByteArray + } + + def stackTraceElementBuilder(elem: StackTraceElement): ContainerFormats.StackTraceElement.Builder = { + ContainerFormats.StackTraceElement.newBuilder() + .setClassName(elem.getClassName) + .setMethodName(elem.getMethodName) + .setFileName(elem.getFileName) + .setLineNumber(elem.getLineNumber) + } + + def deserializeThrowable(bytes: Array[Byte]): Throwable = { + val protoT = ContainerFormats.Throwable.parseFrom(bytes) + val t: Throwable = + if (protoT.hasCause) { + val cause = payloadSupport.deserializePayload(protoT.getCause).asInstanceOf[Throwable] + system.dynamicAccess.createInstanceFor[Throwable]( + protoT.getClassName, + List(classOf[String] → protoT.getMessage, classOf[Throwable] → cause)).get + } else { + // Important security note: before creating an instance of from the class name we + // check that the class is a Throwable and that it has a configured serializer. + val clazz = system.dynamicAccess.getClassFor[Throwable](protoT.getClassName).get + serialization.serializerFor(clazz) // this will throw NotSerializableException if no serializer configured + + system.dynamicAccess.createInstanceFor[Throwable]( + clazz, + List(classOf[String] → protoT.getMessage)).get + } + + import scala.collection.JavaConverters._ + val stackTrace = + (protoT.getStackTraceList.asScala.map { elem ⇒ + new StackTraceElement(elem.getClassName, elem.getMethodName, elem.getFileName, elem.getLineNumber) + }).toArray + t.setStackTrace(stackTrace) + t + } + +} diff --git a/akka-remote/src/main/scala/akka/remote/serialization/WrappedPayloadSupport.scala b/akka-remote/src/main/scala/akka/remote/serialization/WrappedPayloadSupport.scala new file mode 100644 index 0000000000..738c4eb6eb --- /dev/null +++ b/akka-remote/src/main/scala/akka/remote/serialization/WrappedPayloadSupport.scala @@ -0,0 +1,49 @@ +/** + * Copyright (C) 2016 Lightbend Inc. + */ +package akka.remote.serialization + +import akka.actor.ExtendedActorSystem +import akka.remote.ContainerFormats +import akka.serialization.SerializationExtension +import akka.serialization.SerializerWithStringManifest +import akka.protobuf.ByteString + +/** + * INTERNAL API + */ +private[akka] class WrappedPayloadSupport(system: ExtendedActorSystem) { + + private lazy val serialization = SerializationExtension(system) + + def payloadBuilder(input: Any): ContainerFormats.Payload.Builder = { + val payload = input.asInstanceOf[AnyRef] + val builder = ContainerFormats.Payload.newBuilder() + val serializer = serialization.findSerializerFor(payload) + + builder + .setEnclosedMessage(ByteString.copyFrom(serializer.toBinary(payload))) + .setSerializerId(serializer.identifier) + + serializer match { + case ser2: SerializerWithStringManifest ⇒ + val manifest = ser2.manifest(payload) + if (manifest != "") + builder.setMessageManifest(ByteString.copyFromUtf8(manifest)) + case _ ⇒ + if (serializer.includeManifest) + builder.setMessageManifest(ByteString.copyFromUtf8(payload.getClass.getName)) + } + + builder + } + + def deserializePayload(payload: ContainerFormats.Payload): Any = { + val manifest = if (payload.hasMessageManifest) payload.getMessageManifest.toStringUtf8 else "" + serialization.deserialize( + payload.getEnclosedMessage.toByteArray, + payload.getSerializerId, + manifest).get + } + +} diff --git a/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala b/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala index a5ed4c45b7..d6c6366684 100644 --- a/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala +++ b/akka-remote/src/test/scala/akka/remote/serialization/MiscMessageSerializerSpec.scala @@ -9,6 +9,7 @@ import akka.remote.MessageSerializer import akka.serialization.SerializationExtension import akka.testkit.AkkaSpec import com.typesafe.config.ConfigFactory +import scala.util.control.NoStackTrace object MiscMessageSerializerSpec { val serializationTestOverrides = @@ -16,12 +17,46 @@ object MiscMessageSerializerSpec { akka.actor.enable-additional-serialization-bindings=on # or they can be enabled with # akka.remote.artery.enabled=on + + akka.actor.serialization-bindings { + "akka.remote.serialization.MiscMessageSerializerSpec$TestException" = akka-misc + } """ val testConfig = ConfigFactory.parseString(serializationTestOverrides).withFallback(AkkaSpec.testConf) + + class TestException(msg: String, cause: Throwable) extends RuntimeException(msg, cause) { + def this(msg: String) = this(msg, null) + + override def equals(other: Any): Boolean = other match { + case e: TestException ⇒ + e.getMessage == getMessage && e.stackTrace == stackTrace && e.getCause == getCause + case _ ⇒ false + } + + def stackTrace: List[StackTraceElement] = + if (getStackTrace == null) Nil + else getStackTrace.toList + } + + class TestExceptionNoStack(msg: String) extends TestException(msg) with NoStackTrace { + override def equals(other: Any): Boolean = other match { + case e: TestExceptionNoStack ⇒ + e.getMessage == getMessage && e.stackTrace == stackTrace + case _ ⇒ false + } + } + + class OtherException(msg: String) extends IllegalArgumentException(msg) { + override def equals(other: Any): Boolean = other match { + case e: OtherException ⇒ e.getMessage == getMessage + case _ ⇒ false + } + } } class MiscMessageSerializerSpec extends AkkaSpec(MiscMessageSerializerSpec.testConfig) { + import MiscMessageSerializerSpec._ "MiscMessageSerializer" must { Seq( @@ -30,6 +65,12 @@ class MiscMessageSerializerSpec extends AkkaSpec(MiscMessageSerializerSpec.testC "Identify with Some" → Identify(Some("value")), "ActorIdentity without actor ref" → ActorIdentity("some-message", ref = None), "ActorIdentity with actor ref" → ActorIdentity("some-message", ref = Some(testActor)), + "TestException" → new TestException("err"), + "TestExceptionNoStack" → new TestExceptionNoStack("err2"), + "TestException with cause" → new TestException("err3", new TestException("cause")), + "Status.Success" → Status.Success("value"), + "Status.Failure" → Status.Failure(new TestException("err")), + "Status.Failure JavaSer" → Status.Failure(new OtherException("exc")), // exc with JavaSerializer "Some" → Some("value"), "None" → None).foreach { case (scenario, item) ⇒