{
+ private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol result;
+
+ // Construct using se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.newBuilder()
+ private Builder() {}
+
+ private static Builder create() {
+ Builder builder = new Builder();
+ builder.result = new se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
+ return builder;
+ }
+
+ protected se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol internalGetResult() {
+ return result;
+ }
+
+ public Builder clear() {
+ if (result == null) {
+ throw new IllegalStateException(
+ "Cannot call clear() after build().");
+ }
+ result = new se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol();
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(result);
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDescriptor();
+ }
+
+ public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol getDefaultInstanceForType() {
+ return se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance();
+ }
+
+ public boolean isInitialized() {
+ return result.isInitialized();
+ }
+ public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol build() {
+ if (result != null && !isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return buildPartial();
+ }
+
+ private se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildParsed()
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ if (!isInitialized()) {
+ throw newUninitializedMessageException(
+ result).asInvalidProtocolBufferException();
+ }
+ return buildPartial();
+ }
+
+ public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol buildPartial() {
+ if (result == null) {
+ throw new IllegalStateException(
+ "build() has already been called on this Builder.");
+ }
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol returnMe = result;
+ result = null;
+ return returnMe;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol) {
+ return mergeFrom((se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol other) {
+ if (other == se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.getDefaultInstance()) return this;
+ if (other.hasActorRef()) {
+ mergeActorRef(other.getActorRef());
+ }
+ if (other.hasInterfaceName()) {
+ setInterfaceName(other.getInterfaceName());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder(
+ this.getUnknownFields());
+ while (true) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ this.setUnknownFields(unknownFields.build());
+ return this;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ this.setUnknownFields(unknownFields.build());
+ return this;
+ }
+ break;
+ }
+ case 10: {
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder subBuilder = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder();
+ if (hasActorRef()) {
+ subBuilder.mergeFrom(getActorRef());
+ }
+ input.readMessage(subBuilder, extensionRegistry);
+ setActorRef(subBuilder.buildPartial());
+ break;
+ }
+ case 18: {
+ setInterfaceName(input.readString());
+ break;
+ }
+ }
+ }
+ }
+
+
+ // required .SerializedActorRefProtocol actorRef = 1;
+ public boolean hasActorRef() {
+ return result.hasActorRef();
+ }
+ public se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol getActorRef() {
+ return result.getActorRef();
+ }
+ public Builder setActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ result.hasActorRef = true;
+ result.actorRef_ = value;
+ return this;
+ }
+ public Builder setActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder builderForValue) {
+ result.hasActorRef = true;
+ result.actorRef_ = builderForValue.build();
+ return this;
+ }
+ public Builder mergeActorRef(se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol value) {
+ if (result.hasActorRef() &&
+ result.actorRef_ != se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance()) {
+ result.actorRef_ =
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.newBuilder(result.actorRef_).mergeFrom(value).buildPartial();
+ } else {
+ result.actorRef_ = value;
+ }
+ result.hasActorRef = true;
+ return this;
+ }
+ public Builder clearActorRef() {
+ result.hasActorRef = false;
+ result.actorRef_ = se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.getDefaultInstance();
+ return this;
+ }
+
+ // required string interfaceName = 2;
+ public boolean hasInterfaceName() {
+ return result.hasInterfaceName();
+ }
+ public java.lang.String getInterfaceName() {
+ return result.getInterfaceName();
+ }
+ public Builder setInterfaceName(java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ result.hasInterfaceName = true;
+ result.interfaceName_ = value;
+ return this;
+ }
+ public Builder clearInterfaceName() {
+ result.hasInterfaceName = false;
+ result.interfaceName_ = getDefaultInstance().getInterfaceName();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:SerializedTypedActorRefProtocol)
+ }
+
+ static {
+ defaultInstance = new SerializedTypedActorRefProtocol(true);
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.internalForceInit();
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:SerializedTypedActorRefProtocol)
+ }
+
public static final class MessageProtocol extends
com.google.protobuf.GeneratedMessage {
// Use MessageProtocol.newBuilder() to construct.
@@ -5700,11 +6408,21 @@ public final class RemoteProtocol {
private static
com.google.protobuf.GeneratedMessage.FieldAccessorTable
internal_static_RemoteActorRefProtocol_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_RemoteTypedActorRefProtocol_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_RemoteTypedActorRefProtocol_fieldAccessorTable;
private static com.google.protobuf.Descriptors.Descriptor
internal_static_SerializedActorRefProtocol_descriptor;
private static
com.google.protobuf.GeneratedMessage.FieldAccessorTable
internal_static_SerializedActorRefProtocol_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_SerializedTypedActorRefProtocol_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable;
private static com.google.protobuf.Descriptors.Descriptor
internal_static_MessageProtocol_descriptor;
private static
@@ -5767,49 +6485,54 @@ public final class RemoteProtocol {
"\n\024RemoteProtocol.proto\"v\n\026RemoteActorRef" +
"Protocol\022\014\n\004uuid\030\001 \002(\t\022\026\n\016actorClassname" +
"\030\002 \002(\t\022%\n\013homeAddress\030\003 \002(\0132\020.AddressPro" +
- "tocol\022\017\n\007timeout\030\004 \001(\004\"\200\003\n\032SerializedAct" +
- "orRefProtocol\022\014\n\004uuid\030\001 \002(\t\022\n\n\002id\030\002 \002(\t\022" +
- "\026\n\016actorClassname\030\003 \002(\t\022)\n\017originalAddre" +
- "ss\030\004 \002(\0132\020.AddressProtocol\022\025\n\ractorInsta" +
- "nce\030\005 \001(\014\022\033\n\023serializerClassname\030\006 \001(\t\022\024" +
- "\n\014isTransactor\030\007 \001(\010\022\017\n\007timeout\030\010 \001(\004\022\026\n" +
- "\016receiveTimeout\030\t \001(\004\022%\n\tlifeCycle\030\n \001(\013",
- "2\022.LifeCycleProtocol\022+\n\nsupervisor\030\013 \001(\013" +
- "2\027.RemoteActorRefProtocol\022\024\n\014hotswapStac" +
- "k\030\014 \001(\014\022(\n\010messages\030\r \003(\0132\026.RemoteReques" +
- "tProtocol\"r\n\017MessageProtocol\0225\n\023serializ" +
- "ationScheme\030\001 \002(\0162\030.SerializationSchemeT" +
- "ype\022\017\n\007message\030\002 \002(\014\022\027\n\017messageManifest\030" +
- "\003 \001(\014\"\236\001\n\021ActorInfoProtocol\022\014\n\004uuid\030\001 \002(" +
- "\t\022\016\n\006target\030\002 \002(\t\022\017\n\007timeout\030\003 \002(\004\022\035\n\tac" +
- "torType\030\004 \002(\0162\n.ActorType\022/\n\016typedActorI" +
- "nfo\030\005 \001(\0132\027.TypedActorInfoProtocol\022\n\n\002id",
- "\030\006 \001(\t\";\n\026TypedActorInfoProtocol\022\021\n\tinte" +
- "rface\030\001 \002(\t\022\016\n\006method\030\002 \002(\t\"\352\001\n\025RemoteRe" +
- "questProtocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002 \002" +
- "(\0132\020.MessageProtocol\022%\n\tactorInfo\030\003 \002(\0132" +
- "\022.ActorInfoProtocol\022\020\n\010isOneWay\030\004 \002(\010\022\026\n" +
- "\016supervisorUuid\030\005 \001(\t\022\'\n\006sender\030\006 \001(\0132\027." +
- "RemoteActorRefProtocol\022(\n\010metadata\030\007 \003(\013" +
- "2\026.MetadataEntryProtocol\"\324\001\n\023RemoteReply" +
- "Protocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002 \001(\0132\020." +
- "MessageProtocol\022%\n\texception\030\003 \001(\0132\022.Exc",
- "eptionProtocol\022\026\n\016supervisorUuid\030\004 \001(\t\022\017" +
- "\n\007isActor\030\005 \002(\010\022\024\n\014isSuccessful\030\006 \002(\010\022(\n" +
- "\010metadata\030\007 \003(\0132\026.MetadataEntryProtocol\"" +
- ")\n\014UuidProtocol\022\014\n\004high\030\001 \002(\004\022\013\n\003low\030\002 \002" +
- "(\004\"3\n\025MetadataEntryProtocol\022\013\n\003key\030\001 \002(\t" +
- "\022\r\n\005value\030\002 \002(\014\"6\n\021LifeCycleProtocol\022!\n\t" +
- "lifeCycle\030\001 \002(\0162\016.LifeCycleType\"1\n\017Addre" +
- "ssProtocol\022\020\n\010hostname\030\001 \002(\t\022\014\n\004port\030\002 \002" +
- "(\r\"7\n\021ExceptionProtocol\022\021\n\tclassname\030\001 \002" +
- "(\t\022\017\n\007message\030\002 \002(\t*=\n\tActorType\022\017\n\013SCAL",
- "A_ACTOR\020\001\022\016\n\nJAVA_ACTOR\020\002\022\017\n\013TYPED_ACTOR" +
- "\020\003*]\n\027SerializationSchemeType\022\010\n\004JAVA\020\001\022" +
- "\013\n\007SBINARY\020\002\022\016\n\nSCALA_JSON\020\003\022\r\n\tJAVA_JSO" +
- "N\020\004\022\014\n\010PROTOBUF\020\005*-\n\rLifeCycleType\022\r\n\tPE" +
- "RMANENT\020\001\022\r\n\tTEMPORARY\020\002B-\n)se.scalables" +
- "olutions.akka.remote.protocolH\001"
+ "tocol\022\017\n\007timeout\030\004 \001(\004\"_\n\033RemoteTypedAct" +
+ "orRefProtocol\022)\n\010actorRef\030\001 \002(\0132\027.Remote" +
+ "ActorRefProtocol\022\025\n\rinterfaceName\030\002 \002(\t\"" +
+ "\200\003\n\032SerializedActorRefProtocol\022\014\n\004uuid\030\001" +
+ " \002(\t\022\n\n\002id\030\002 \002(\t\022\026\n\016actorClassname\030\003 \002(\t" +
+ "\022)\n\017originalAddress\030\004 \002(\0132\020.AddressProto" +
+ "col\022\025\n\ractorInstance\030\005 \001(\014\022\033\n\023serializer",
+ "Classname\030\006 \001(\t\022\024\n\014isTransactor\030\007 \001(\010\022\017\n" +
+ "\007timeout\030\010 \001(\004\022\026\n\016receiveTimeout\030\t \001(\004\022%" +
+ "\n\tlifeCycle\030\n \001(\0132\022.LifeCycleProtocol\022+\n" +
+ "\nsupervisor\030\013 \001(\0132\027.RemoteActorRefProtoc" +
+ "ol\022\024\n\014hotswapStack\030\014 \001(\014\022(\n\010messages\030\r \003" +
+ "(\0132\026.RemoteRequestProtocol\"g\n\037Serialized" +
+ "TypedActorRefProtocol\022-\n\010actorRef\030\001 \002(\0132" +
+ "\033.SerializedActorRefProtocol\022\025\n\rinterfac" +
+ "eName\030\002 \002(\t\"r\n\017MessageProtocol\0225\n\023serial" +
+ "izationScheme\030\001 \002(\0162\030.SerializationSchem",
+ "eType\022\017\n\007message\030\002 \002(\014\022\027\n\017messageManifes" +
+ "t\030\003 \001(\014\"\236\001\n\021ActorInfoProtocol\022\014\n\004uuid\030\001 " +
+ "\002(\t\022\016\n\006target\030\002 \002(\t\022\017\n\007timeout\030\003 \002(\004\022\035\n\t" +
+ "actorType\030\004 \002(\0162\n.ActorType\022/\n\016typedActo" +
+ "rInfo\030\005 \001(\0132\027.TypedActorInfoProtocol\022\n\n\002" +
+ "id\030\006 \001(\t\";\n\026TypedActorInfoProtocol\022\021\n\tin" +
+ "terface\030\001 \002(\t\022\016\n\006method\030\002 \002(\t\"\352\001\n\025Remote" +
+ "RequestProtocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002" +
+ " \002(\0132\020.MessageProtocol\022%\n\tactorInfo\030\003 \002(" +
+ "\0132\022.ActorInfoProtocol\022\020\n\010isOneWay\030\004 \002(\010\022",
+ "\026\n\016supervisorUuid\030\005 \001(\t\022\'\n\006sender\030\006 \001(\0132" +
+ "\027.RemoteActorRefProtocol\022(\n\010metadata\030\007 \003" +
+ "(\0132\026.MetadataEntryProtocol\"\324\001\n\023RemoteRep" +
+ "lyProtocol\022\n\n\002id\030\001 \002(\004\022!\n\007message\030\002 \001(\0132" +
+ "\020.MessageProtocol\022%\n\texception\030\003 \001(\0132\022.E" +
+ "xceptionProtocol\022\026\n\016supervisorUuid\030\004 \001(\t" +
+ "\022\017\n\007isActor\030\005 \002(\010\022\024\n\014isSuccessful\030\006 \002(\010\022" +
+ "(\n\010metadata\030\007 \003(\0132\026.MetadataEntryProtoco" +
+ "l\")\n\014UuidProtocol\022\014\n\004high\030\001 \002(\004\022\013\n\003low\030\002" +
+ " \002(\004\"3\n\025MetadataEntryProtocol\022\013\n\003key\030\001 \002",
+ "(\t\022\r\n\005value\030\002 \002(\014\"6\n\021LifeCycleProtocol\022!" +
+ "\n\tlifeCycle\030\001 \002(\0162\016.LifeCycleType\"1\n\017Add" +
+ "ressProtocol\022\020\n\010hostname\030\001 \002(\t\022\014\n\004port\030\002" +
+ " \002(\r\"7\n\021ExceptionProtocol\022\021\n\tclassname\030\001" +
+ " \002(\t\022\017\n\007message\030\002 \002(\t*=\n\tActorType\022\017\n\013SC" +
+ "ALA_ACTOR\020\001\022\016\n\nJAVA_ACTOR\020\002\022\017\n\013TYPED_ACT" +
+ "OR\020\003*]\n\027SerializationSchemeType\022\010\n\004JAVA\020" +
+ "\001\022\013\n\007SBINARY\020\002\022\016\n\nSCALA_JSON\020\003\022\r\n\tJAVA_J" +
+ "SON\020\004\022\014\n\010PROTOBUF\020\005*-\n\rLifeCycleType\022\r\n\t" +
+ "PERMANENT\020\001\022\r\n\tTEMPORARY\020\002B-\n)se.scalabl",
+ "esolutions.akka.remote.protocolH\001"
};
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -5824,16 +6547,32 @@ public final class RemoteProtocol {
new java.lang.String[] { "Uuid", "ActorClassname", "HomeAddress", "Timeout", },
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteActorRefProtocol.Builder.class);
- internal_static_SerializedActorRefProtocol_descriptor =
+ internal_static_RemoteTypedActorRefProtocol_descriptor =
getDescriptor().getMessageTypes().get(1);
+ internal_static_RemoteTypedActorRefProtocol_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_RemoteTypedActorRefProtocol_descriptor,
+ new java.lang.String[] { "ActorRef", "InterfaceName", },
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.class,
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteTypedActorRefProtocol.Builder.class);
+ internal_static_SerializedActorRefProtocol_descriptor =
+ getDescriptor().getMessageTypes().get(2);
internal_static_SerializedActorRefProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_SerializedActorRefProtocol_descriptor,
new java.lang.String[] { "Uuid", "Id", "ActorClassname", "OriginalAddress", "ActorInstance", "SerializerClassname", "IsTransactor", "Timeout", "ReceiveTimeout", "LifeCycle", "Supervisor", "HotswapStack", "Messages", },
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedActorRefProtocol.Builder.class);
+ internal_static_SerializedTypedActorRefProtocol_descriptor =
+ getDescriptor().getMessageTypes().get(3);
+ internal_static_SerializedTypedActorRefProtocol_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_SerializedTypedActorRefProtocol_descriptor,
+ new java.lang.String[] { "ActorRef", "InterfaceName", },
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.class,
+ se.scalablesolutions.akka.remote.protocol.RemoteProtocol.SerializedTypedActorRefProtocol.Builder.class);
internal_static_MessageProtocol_descriptor =
- getDescriptor().getMessageTypes().get(2);
+ getDescriptor().getMessageTypes().get(4);
internal_static_MessageProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_MessageProtocol_descriptor,
@@ -5841,7 +6580,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MessageProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MessageProtocol.Builder.class);
internal_static_ActorInfoProtocol_descriptor =
- getDescriptor().getMessageTypes().get(3);
+ getDescriptor().getMessageTypes().get(5);
internal_static_ActorInfoProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_ActorInfoProtocol_descriptor,
@@ -5849,7 +6588,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.ActorInfoProtocol.Builder.class);
internal_static_TypedActorInfoProtocol_descriptor =
- getDescriptor().getMessageTypes().get(4);
+ getDescriptor().getMessageTypes().get(6);
internal_static_TypedActorInfoProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_TypedActorInfoProtocol_descriptor,
@@ -5857,7 +6596,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.TypedActorInfoProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.TypedActorInfoProtocol.Builder.class);
internal_static_RemoteRequestProtocol_descriptor =
- getDescriptor().getMessageTypes().get(5);
+ getDescriptor().getMessageTypes().get(7);
internal_static_RemoteRequestProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_RemoteRequestProtocol_descriptor,
@@ -5865,7 +6604,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteRequestProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteRequestProtocol.Builder.class);
internal_static_RemoteReplyProtocol_descriptor =
- getDescriptor().getMessageTypes().get(6);
+ getDescriptor().getMessageTypes().get(8);
internal_static_RemoteReplyProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_RemoteReplyProtocol_descriptor,
@@ -5873,7 +6612,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteReplyProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.RemoteReplyProtocol.Builder.class);
internal_static_UuidProtocol_descriptor =
- getDescriptor().getMessageTypes().get(7);
+ getDescriptor().getMessageTypes().get(9);
internal_static_UuidProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_UuidProtocol_descriptor,
@@ -5881,7 +6620,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.UuidProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.UuidProtocol.Builder.class);
internal_static_MetadataEntryProtocol_descriptor =
- getDescriptor().getMessageTypes().get(8);
+ getDescriptor().getMessageTypes().get(10);
internal_static_MetadataEntryProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_MetadataEntryProtocol_descriptor,
@@ -5889,7 +6628,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.MetadataEntryProtocol.Builder.class);
internal_static_LifeCycleProtocol_descriptor =
- getDescriptor().getMessageTypes().get(9);
+ getDescriptor().getMessageTypes().get(11);
internal_static_LifeCycleProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_LifeCycleProtocol_descriptor,
@@ -5897,7 +6636,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.LifeCycleProtocol.Builder.class);
internal_static_AddressProtocol_descriptor =
- getDescriptor().getMessageTypes().get(10);
+ getDescriptor().getMessageTypes().get(12);
internal_static_AddressProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_AddressProtocol_descriptor,
@@ -5905,7 +6644,7 @@ public final class RemoteProtocol {
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.AddressProtocol.class,
se.scalablesolutions.akka.remote.protocol.RemoteProtocol.AddressProtocol.Builder.class);
internal_static_ExceptionProtocol_descriptor =
- getDescriptor().getMessageTypes().get(11);
+ getDescriptor().getMessageTypes().get(13);
internal_static_ExceptionProtocol_fieldAccessorTable = new
com.google.protobuf.GeneratedMessage.FieldAccessorTable(
internal_static_ExceptionProtocol_descriptor,
diff --git a/akka-remote/src/main/protocol/RemoteProtocol.proto b/akka-remote/src/main/protocol/RemoteProtocol.proto
index 4343fecf7f..e84ae9f18e 100644
--- a/akka-remote/src/main/protocol/RemoteProtocol.proto
+++ b/akka-remote/src/main/protocol/RemoteProtocol.proto
@@ -22,6 +22,15 @@ message RemoteActorRefProtocol {
optional uint64 timeout = 4;
}
+/**
+ * Defines a remote ActorRef that "remembers" and uses its original typed Actor instance
+ * on the original node.
+ */
+message RemoteTypedActorRefProtocol {
+ required RemoteActorRefProtocol actorRef = 1;
+ required string interfaceName = 2;
+}
+
/**
* Defines a fully serialized remote ActorRef (with serialized Actor instance)
* that is about to be instantiated on the remote node. It is fully disconnected
@@ -43,6 +52,16 @@ message SerializedActorRefProtocol {
repeated RemoteRequestProtocol messages = 13;
}
+/**
+ * Defines a fully serialized remote ActorRef (with serialized typed actor instance)
+ * that is about to be instantiated on the remote node. It is fully disconnected
+ * from its original host.
+ */
+message SerializedTypedActorRefProtocol {
+ required SerializedActorRefProtocol actorRef = 1;
+ required string interfaceName = 2;
+}
+
/**
* Defines a message.
*/
diff --git a/akka-remote/src/main/scala/remote/RemoteServer.scala b/akka-remote/src/main/scala/remote/RemoteServer.scala
index c1f25b6d4f..b258c4867d 100644
--- a/akka-remote/src/main/scala/remote/RemoteServer.scala
+++ b/akka-remote/src/main/scala/remote/RemoteServer.scala
@@ -67,6 +67,7 @@ object RemoteNode extends RemoteServer
* @author Jonas Bonér
*/
object RemoteServer {
+ val UUID_PREFIX = "uuid:"
val HOSTNAME = config.getString("akka.remote.server.hostname", "localhost")
val PORT = config.getInt("akka.remote.server.port", 9999)
@@ -123,18 +124,20 @@ object RemoteServer {
private class RemoteActorSet {
private[RemoteServer] val actors = new ConcurrentHashMap[String, ActorRef]
+ private[RemoteServer] val actorsByUuid = new ConcurrentHashMap[String, ActorRef]
private[RemoteServer] val typedActors = new ConcurrentHashMap[String, AnyRef]
+ private[RemoteServer] val typedActorsByUuid = new ConcurrentHashMap[String, AnyRef]
}
private val guard = new ReadWriteGuard
private val remoteActorSets = Map[Address, RemoteActorSet]()
private val remoteServers = Map[Address, RemoteServer]()
- private[akka] def registerActor(address: InetSocketAddress, uuid: String, actor: ActorRef) = guard.withWriteGuard {
- actorsFor(RemoteServer.Address(address.getHostName, address.getPort)).actors.put(uuid, actor)
+ private[akka] def registerActorByUuid(address: InetSocketAddress, uuid: String, actor: ActorRef) = guard.withWriteGuard {
+ actorsFor(RemoteServer.Address(address.getHostName, address.getPort)).actorsByUuid.put(uuid, actor)
}
- private[akka] def registerTypedActor(address: InetSocketAddress, uuid: String, typedActor: AnyRef) = guard.withWriteGuard {
+ private[akka] def registerTypedActorByUuid(address: InetSocketAddress, uuid: String, typedActor: AnyRef) = guard.withWriteGuard {
actorsFor(RemoteServer.Address(address.getHostName, address.getPort)).typedActors.put(uuid, typedActor)
}
@@ -192,6 +195,7 @@ case class RemoteServerClientDisconnected(@BeanProperty val server: RemoteServer
* @author Jonas Bonér
*/
class RemoteServer extends Logging with ListenerManagement {
+ import RemoteServer._
def name = "RemoteServer@" + hostname + ":" + port
private[akka] var address = RemoteServer.Address(RemoteServer.HOSTNAME,RemoteServer.PORT)
@@ -283,10 +287,11 @@ class RemoteServer extends Logging with ListenerManagement {
* @param typedActor typed actor to register
*/
def registerTypedActor(id: String, typedActor: AnyRef): Unit = synchronized {
- val typedActors = RemoteServer.actorsFor(RemoteServer.Address(hostname, port)).typedActors
- if (!typedActors.contains(id)) {
- log.debug("Registering server side remote actor [%s] with id [%s] on [%s:%d]", typedActor.getClass.getName, id, hostname, port)
- typedActors.put(id, typedActor)
+ log.debug("Registering server side remote typed actor [%s] with id [%s]", typedActor.getClass.getName, id)
+ if (id.startsWith(UUID_PREFIX)) {
+ registerTypedActor(id.substring(UUID_PREFIX.length), typedActor, typedActorsByUuid())
+ } else {
+ registerTypedActor(id, typedActor, typedActors())
}
}
@@ -301,12 +306,27 @@ class RemoteServer extends Logging with ListenerManagement {
* NOTE: If you use this method to register your remote actor then you must unregister the actor by this ID yourself.
*/
def register(id: String, actorRef: ActorRef): Unit = synchronized {
+ log.debug("Registering server side remote actor [%s] with id [%s]", actorRef.actorClass.getName, id)
+ if (id.startsWith(UUID_PREFIX)) {
+ register(id.substring(UUID_PREFIX.length), actorRef, actorsByUuid())
+ } else {
+ register(id, actorRef, actors())
+ }
+ }
+
+ private def register(id: String, actorRef: ActorRef, registry: ConcurrentHashMap[String, ActorRef]) {
if (_isRunning) {
- val actorMap = actors()
- if (!actorMap.contains(id)) {
+ if (!registry.contains(id)) {
if (!actorRef.isRunning) actorRef.start
- log.debug("Registering server side remote actor [%s] with id [%s]", actorRef.actorClass.getName, id)
- actorMap.put(id, actorRef)
+ registry.put(id, actorRef)
+ }
+ }
+ }
+
+ private def registerTypedActor(id: String, typedActor: AnyRef, registry: ConcurrentHashMap[String, AnyRef]) {
+ if (_isRunning) {
+ if (!registry.contains(id)) {
+ registry.put(id, typedActor)
}
}
}
@@ -319,7 +339,7 @@ class RemoteServer extends Logging with ListenerManagement {
log.debug("Unregistering server side remote actor [%s] with id [%s:%s]", actorRef.actorClass.getName, actorRef.id, actorRef.uuid)
val actorMap = actors()
actorMap remove actorRef.id
- if (actorRef.registeredInRemoteNodeDuringSerialization) actorMap remove actorRef.uuid
+ if (actorRef.registeredInRemoteNodeDuringSerialization) actorsByUuid() remove actorRef.uuid
}
}
@@ -331,10 +351,15 @@ class RemoteServer extends Logging with ListenerManagement {
def unregister(id: String):Unit = synchronized {
if (_isRunning) {
log.info("Unregistering server side remote actor with id [%s]", id)
- val actorMap = actors()
- val actorRef = actorMap get id
- actorMap remove id
- if (actorRef.registeredInRemoteNodeDuringSerialization) actorMap remove actorRef.uuid
+ if (id.startsWith(UUID_PREFIX)) {
+ actorsByUuid().remove(id.substring(UUID_PREFIX.length))
+ } else {
+ val actorRef = actors().get(id)
+ if (actorRef.registeredInRemoteNodeDuringSerialization) {
+ actorsByUuid() remove actorRef.uuid
+ }
+ actors() remove id
+ }
}
}
@@ -346,8 +371,11 @@ class RemoteServer extends Logging with ListenerManagement {
def unregisterTypedActor(id: String):Unit = synchronized {
if (_isRunning) {
log.info("Unregistering server side remote typed actor with id [%s]", id)
- val registeredTypedActors = typedActors()
- registeredTypedActors.remove(id)
+ if (id.startsWith(UUID_PREFIX)) {
+ typedActorsByUuid().remove(id.substring(UUID_PREFIX.length))
+ } else {
+ typedActors().remove(id)
+ }
}
}
@@ -355,8 +383,10 @@ class RemoteServer extends Logging with ListenerManagement {
protected[akka] override def notifyListeners(message: => Any): Unit = super.notifyListeners(message)
- private[akka] def actors() = RemoteServer.actorsFor(address).actors
- private[akka] def typedActors() = RemoteServer.actorsFor(address).typedActors
+ private[akka] def actors() = RemoteServer.actorsFor(address).actors
+ private[akka] def actorsByUuid() = RemoteServer.actorsFor(address).actorsByUuid
+ private[akka] def typedActors() = RemoteServer.actorsFor(address).typedActors
+ private[akka] def typedActorsByUuid() = RemoteServer.actorsFor(address).typedActorsByUuid
}
object RemoteServerSslContext {
@@ -419,6 +449,7 @@ class RemoteServerHandler(
val openChannels: ChannelGroup,
val applicationLoader: Option[ClassLoader],
val server: RemoteServer) extends SimpleChannelUpstreamHandler with Logging {
+ import RemoteServer._
val AW_PROXY_PREFIX = "$$ProxiedByAW".intern
applicationLoader.foreach(MessageSerializer.setClassLoader(_))
@@ -477,11 +508,12 @@ class RemoteServerHandler(
private def handleRemoteRequestProtocol(request: RemoteRequestProtocol, channel: Channel) = {
log.debug("Received RemoteRequestProtocol[\n%s]", request.toString)
- val actorType = request.getActorInfo.getActorType
- if (actorType == SCALA_ACTOR) dispatchToActor(request, channel)
- else if (actorType == JAVA_ACTOR) throw new IllegalActorStateException("ActorType JAVA_ACTOR is currently not supported")
- else if (actorType == TYPED_ACTOR) dispatchToTypedActor(request, channel)
- else throw new IllegalActorStateException("Unknown ActorType [" + actorType + "]")
+ request.getActorInfo.getActorType match {
+ case SCALA_ACTOR => dispatchToActor(request, channel)
+ case TYPED_ACTOR => dispatchToTypedActor(request, channel)
+ case JAVA_ACTOR => throw new IllegalActorStateException("ActorType JAVA_ACTOR is currently not supported")
+ case other => throw new IllegalActorStateException("Unknown ActorType [" + other + "]")
+ }
}
private def dispatchToActor(request: RemoteRequestProtocol, channel: Channel) = {
@@ -565,32 +597,23 @@ class RemoteServerHandler(
}
}
- /**
- * Find a registered actor by ID (default) or UUID.
- * Actors are registered by id apart from registering during serialization see SerializationProtocol.
- */
- private def findActorByIdOrUuid(id: String, uuid: String) : ActorRef = {
- val registeredActors = server.actors()
- var actorRefOrNull = registeredActors get id
- if (actorRefOrNull eq null) {
- actorRefOrNull = registeredActors get uuid
- }
- actorRefOrNull
+ private def findActorById(id: String) : ActorRef = {
+ server.actors().get(id)
}
- /**
- * Find a registered typed actor by ID (default) or UUID.
- * Actors are registered by id apart from registering during serialization see SerializationProtocol.
- */
- private def findTypedActorByIdOrUUid(id: String, uuid: String) : AnyRef = {
- val registeredActors = server.typedActors()
- var actorRefOrNull = registeredActors get id
- if (actorRefOrNull eq null) {
- actorRefOrNull = registeredActors get uuid
- }
- actorRefOrNull
+ private def findActorByUuid(uuid: String) : ActorRef = {
+ server.actorsByUuid().get(uuid)
}
+ private def findTypedActorById(id: String) : AnyRef = {
+ server.typedActors().get(id)
+ }
+
+ private def findTypedActorByUuid(uuid: String) : AnyRef = {
+ server.typedActorsByUuid().get(uuid)
+ }
+
+
/**
* Creates a new instance of the actor with name, uuid and timeout specified as arguments.
*
@@ -605,8 +628,12 @@ class RemoteServerHandler(
val name = actorInfo.getTarget
val timeout = actorInfo.getTimeout
- val actorRefOrNull = findActorByIdOrUuid(id, uuid)
-
+ val actorRefOrNull = if (id.startsWith(UUID_PREFIX)) {
+ findActorByUuid(id.substring(UUID_PREFIX.length))
+ } else {
+ findActorById(id)
+ }
+
if (actorRefOrNull eq null) {
try {
log.info("Creating a new remote actor [%s:%s]", name, uuid)
@@ -632,7 +659,11 @@ class RemoteServerHandler(
val uuid = actorInfo.getUuid
val id = actorInfo.getId
- val typedActorOrNull = findTypedActorByIdOrUUid(id, uuid)
+ val typedActorOrNull = if (id.startsWith(UUID_PREFIX)) {
+ findTypedActorByUuid(id.substring(UUID_PREFIX.length))
+ } else {
+ findTypedActorById(id)
+ }
if (typedActorOrNull eq null) {
val typedActorInfo = actorInfo.getTypedActorInfo
diff --git a/akka-remote/src/main/scala/serialization/SerializationProtocol.scala b/akka-remote/src/main/scala/serialization/SerializationProtocol.scala
index 1577b62e13..c9b443f4ec 100644
--- a/akka-remote/src/main/scala/serialization/SerializationProtocol.scala
+++ b/akka-remote/src/main/scala/serialization/SerializationProtocol.scala
@@ -4,7 +4,6 @@
package se.scalablesolutions.akka.serialization
-import se.scalablesolutions.akka.actor.{Actor, ActorRef, LocalActorRef, RemoteActorRef, IllegalActorStateException, ActorType}
import se.scalablesolutions.akka.stm.global._
import se.scalablesolutions.akka.stm.TransactionManagement._
import se.scalablesolutions.akka.stm.TransactionManagement
@@ -16,6 +15,7 @@ import se.scalablesolutions.akka.config.{AllForOneStrategy, OneForOneStrategy, F
import se.scalablesolutions.akka.config.ScalaConfig._
import com.google.protobuf.ByteString
+import se.scalablesolutions.akka.actor._
/**
* Type class definition for Actor Serialization
@@ -37,13 +37,14 @@ trait Format[T <: Actor] extends FromBinary[T] with ToBinary[T]
* Create a Format object with the client actor as the implementation of the type class
*
*
- * object BinaryFormatMyStatelessActor {
+ * object BinaryFormatMyStatelessActor {
* implicit object MyStatelessActorFormat extends StatelessActorFormat[MyStatelessActor]
* }
*
*/
trait StatelessActorFormat[T <: Actor] extends Format[T] {
def fromBinary(bytes: Array[Byte], act: T) = act
+
def toBinary(ac: T) = Array.empty[Byte]
}
@@ -54,16 +55,18 @@ trait StatelessActorFormat[T <: Actor] extends Format[T] {
* a serializer object
*
*
- * object BinaryFormatMyJavaSerializableActor {
- * implicit object MyJavaSerializableActorFormat extends SerializerBasedActorFormat[MyJavaSerializableActor] {
+ * object BinaryFormatMyJavaSerializableActor {
+ * implicit object MyJavaSerializableActorFormat extends SerializerBasedActorFormat[MyJavaSerializableActor] {
* val serializer = Serializer.Java
- * }
+ * }
* }
*
*/
trait SerializerBasedActorFormat[T <: Actor] extends Format[T] {
val serializer: Serializer
+
def fromBinary(bytes: Array[Byte], act: T) = serializer.fromBinary(bytes, Some(act.self.actorClass)).asInstanceOf[T]
+
def toBinary(ac: T) = serializer.toBinary(ac)
}
@@ -71,7 +74,6 @@ trait SerializerBasedActorFormat[T <: Actor] extends Format[T] {
* Module for local actor serialization.
*/
object ActorSerialization {
-
def fromBinary[T <: Actor](bytes: Array[Byte])(implicit format: Format[T]): ActorRef =
fromBinaryToLocalActorRef(bytes, format)
@@ -86,7 +88,7 @@ object ActorSerialization {
def toBinaryJ[T <: Actor](a: ActorRef, format: Format[T], srlMailBox: Boolean = true): Array[Byte] =
toBinary(a, srlMailBox)(format)
- private def toSerializedActorRefProtocol[T <: Actor](
+ private[akka] def toSerializedActorRefProtocol[T <: Actor](
actorRef: ActorRef, format: Format[T], serializeMailBox: Boolean = true): SerializedActorRefProtocol = {
val lifeCycleProtocol: Option[LifeCycleProtocol] = {
def setScope(builder: LifeCycleProtocol.Builder, scope: Scope) = scope match {
@@ -103,17 +105,17 @@ object ActorSerialization {
}
val originalAddress = AddressProtocol.newBuilder
- .setHostname(actorRef.homeAddress.getHostName)
- .setPort(actorRef.homeAddress.getPort)
- .build
+ .setHostname(actorRef.homeAddress.getHostName)
+ .setPort(actorRef.homeAddress.getPort)
+ .build
val builder = SerializedActorRefProtocol.newBuilder
- .setUuid(actorRef.uuid)
- .setId(actorRef.id)
- .setActorClassname(actorRef.actorClass.getName)
- .setOriginalAddress(originalAddress)
- .setIsTransactor(actorRef.isTransactor)
- .setTimeout(actorRef.timeout)
+ .setUuid(actorRef.uuid)
+ .setId(actorRef.id)
+ .setActorClassname(actorRef.actorClass.getName)
+ .setOriginalAddress(originalAddress)
+ .setIsTransactor(actorRef.isTransactor)
+ .setTimeout(actorRef.timeout)
if (serializeMailBox == true) {
val messages =
@@ -150,33 +152,33 @@ object ActorSerialization {
private def fromBinaryToLocalActorRef[T <: Actor](bytes: Array[Byte], format: Format[T]): ActorRef =
fromProtobufToLocalActorRef(SerializedActorRefProtocol.newBuilder.mergeFrom(bytes).build, format, None)
- private def fromProtobufToLocalActorRef[T <: Actor](
- protocol: SerializedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): ActorRef = {
+ private[akka] def fromProtobufToLocalActorRef[T <: Actor](
+ protocol: SerializedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): ActorRef = {
Actor.log.debug("Deserializing SerializedActorRefProtocol to LocalActorRef:\n" + protocol)
val serializer =
- if (format.isInstanceOf[SerializerBasedActorFormat[_]])
- Some(format.asInstanceOf[SerializerBasedActorFormat[_]].serializer)
- else None
+ if (format.isInstanceOf[SerializerBasedActorFormat[_]])
+ Some(format.asInstanceOf[SerializerBasedActorFormat[_]].serializer)
+ else None
val lifeCycle =
- if (protocol.hasLifeCycle) {
- val lifeCycleProtocol = protocol.getLifeCycle
- Some(if (lifeCycleProtocol.getLifeCycle == LifeCycleType.PERMANENT) LifeCycle(Permanent)
- else if (lifeCycleProtocol.getLifeCycle == LifeCycleType.TEMPORARY) LifeCycle(Temporary)
- else throw new IllegalActorStateException("LifeCycle type is not valid: " + lifeCycleProtocol.getLifeCycle))
- } else None
+ if (protocol.hasLifeCycle) {
+ val lifeCycleProtocol = protocol.getLifeCycle
+ Some(if (lifeCycleProtocol.getLifeCycle == LifeCycleType.PERMANENT) LifeCycle(Permanent)
+ else if (lifeCycleProtocol.getLifeCycle == LifeCycleType.TEMPORARY) LifeCycle(Temporary)
+ else throw new IllegalActorStateException("LifeCycle type is not valid: " + lifeCycleProtocol.getLifeCycle))
+ } else None
val supervisor =
- if (protocol.hasSupervisor)
- Some(RemoteActorSerialization.fromProtobufToRemoteActorRef(protocol.getSupervisor, loader))
- else None
+ if (protocol.hasSupervisor)
+ Some(RemoteActorSerialization.fromProtobufToRemoteActorRef(protocol.getSupervisor, loader))
+ else None
val hotswap =
- if (serializer.isDefined && protocol.hasHotswapStack) Some(serializer.get
+ if (serializer.isDefined && protocol.hasHotswapStack) Some(serializer.get
.fromBinary(protocol.getHotswapStack.toByteArray, Some(classOf[PartialFunction[Any, Unit]]))
.asInstanceOf[PartialFunction[Any, Unit]])
- else None
+ else None
val classLoader = loader.getOrElse(getClass.getClassLoader)
@@ -218,9 +220,9 @@ object RemoteActorSerialization {
def fromBinaryToRemoteActorRef(bytes: Array[Byte]): ActorRef =
fromProtobufToRemoteActorRef(RemoteActorRefProtocol.newBuilder.mergeFrom(bytes).build, None)
- /**
- * Deserializes a byte array (Array[Byte]) into an RemoteActorRef instance.
- */
+ /**
+ * Deserializes a byte array (Array[Byte]) into an RemoteActorRef instance.
+ */
def fromBinaryToRemoteActorRef(bytes: Array[Byte], loader: ClassLoader): ActorRef =
fromProtobufToRemoteActorRef(RemoteActorRefProtocol.newBuilder.mergeFrom(bytes).build, Some(loader))
@@ -249,26 +251,26 @@ object RemoteActorSerialization {
if (!registeredInRemoteNodeDuringSerialization) {
Actor.log.debug("Register serialized Actor [%s] as remote @ [%s:%s]", actorClass.getName, host, port)
RemoteServer.getOrCreateServer(homeAddress)
- RemoteServer.registerActor(homeAddress, uuid, ar)
+ RemoteServer.registerActorByUuid(homeAddress, uuid, ar)
registeredInRemoteNodeDuringSerialization = true
}
RemoteActorRefProtocol.newBuilder
- .setUuid(uuid)
- .setActorClassname(actorClass.getName)
- .setHomeAddress(AddressProtocol.newBuilder.setHostname(host).setPort(port).build)
- .setTimeout(timeout)
- .build
+ .setUuid(uuid)
+ .setActorClassname(actorClass.getName)
+ .setHomeAddress(AddressProtocol.newBuilder.setHostname(host).setPort(port).build)
+ .setTimeout(timeout)
+ .build
}
def createRemoteRequestProtocolBuilder(
- actorRef: ActorRef,
- message: Any,
- isOneWay: Boolean,
- senderOption: Option[ActorRef],
- typedActorInfo: Option[Tuple2[String, String]],
- actorType: ActorType):
- RemoteRequestProtocol.Builder = {
+ actorRef: ActorRef,
+ message: Any,
+ isOneWay: Boolean,
+ senderOption: Option[ActorRef],
+ typedActorInfo: Option[Tuple2[String, String]],
+ actorType: ActorType):
+ RemoteRequestProtocol.Builder = {
import actorRef._
val actorInfoBuilder = ActorInfoProtocol.newBuilder
@@ -277,12 +279,13 @@ object RemoteActorSerialization {
.setTarget(actorClassName)
.setTimeout(timeout)
- typedActorInfo.foreach { typedActor =>
- actorInfoBuilder.setTypedActorInfo(
- TypedActorInfoProtocol.newBuilder
- .setInterface(typedActor._1)
- .setMethod(typedActor._2)
- .build)
+ typedActorInfo.foreach {
+ typedActor =>
+ actorInfoBuilder.setTypedActorInfo(
+ TypedActorInfoProtocol.newBuilder
+ .setInterface(typedActor._1)
+ .setMethod(typedActor._2)
+ .build)
}
actorType match {
@@ -300,10 +303,110 @@ object RemoteActorSerialization {
val id = registerSupervisorAsRemoteActor
if (id.isDefined) requestBuilder.setSupervisorUuid(id.get)
- senderOption.foreach { sender =>
- RemoteServer.getOrCreateServer(sender.homeAddress).register(sender.uuid, sender)
- requestBuilder.setSender(toRemoteActorRefProtocol(sender))
+ senderOption.foreach {
+ sender =>
+ RemoteServer.getOrCreateServer(sender.homeAddress).register(sender.uuid, sender)
+ requestBuilder.setSender(toRemoteActorRefProtocol(sender))
}
requestBuilder
}
+
+
+}
+
+
+/**
+ * Module for local typed actor serialization.
+ */
+object TypedActorSerialization {
+
+ def fromBinary[T <: Actor, U <: AnyRef](bytes: Array[Byte])(implicit format: Format[T]): U =
+ fromBinaryToLocalTypedActorRef(bytes, format)
+
+ def toBinary[T <: Actor](proxy: AnyRef)(implicit format: Format[T]): Array[Byte] = {
+ toSerializedTypedActorRefProtocol(proxy, format).toByteArray
+ }
+
+ // wrapper for implicits to be used by Java
+ def fromBinaryJ[T <: Actor, U <: AnyRef](bytes: Array[Byte], format: Format[T]): U =
+ fromBinary(bytes)(format)
+
+ // wrapper for implicits to be used by Java
+ def toBinaryJ[T <: Actor](a: AnyRef, format: Format[T]): Array[Byte] =
+ toBinary(a)(format)
+
+ private def toSerializedTypedActorRefProtocol[T <: Actor](
+ proxy: AnyRef, format: Format[T]): SerializedTypedActorRefProtocol = {
+
+ val init = AspectInitRegistry.initFor(proxy)
+ if (init == null) throw new IllegalArgumentException("Proxy for typed actor could not be found in AspectInitRegistry.")
+
+ SerializedTypedActorRefProtocol.newBuilder
+ .setActorRef(ActorSerialization.toSerializedActorRefProtocol(init.actorRef, format))
+ .setInterfaceName(init.interfaceClass.getName)
+ .build
+ }
+
+ private def fromBinaryToLocalTypedActorRef[T <: Actor, U <: AnyRef](bytes: Array[Byte], format: Format[T]): U =
+ fromProtobufToLocalTypedActorRef(SerializedTypedActorRefProtocol.newBuilder.mergeFrom(bytes).build, format, None)
+
+ private def fromProtobufToLocalTypedActorRef[T <: Actor, U <: AnyRef](
+ protocol: SerializedTypedActorRefProtocol, format: Format[T], loader: Option[ClassLoader]): U = {
+ Actor.log.debug("Deserializing SerializedTypedActorRefProtocol to LocalActorRef:\n" + protocol)
+ val actorRef = ActorSerialization.fromProtobufToLocalActorRef(protocol.getActorRef, format, loader)
+ val intfClass = toClass(loader, protocol.getInterfaceName)
+ TypedActor.newInstance(intfClass, actorRef).asInstanceOf[U]
+ }
+
+ private[akka] def toClass[U <: AnyRef](loader: Option[ClassLoader], name: String): Class[U] = {
+ val classLoader = loader.getOrElse(getClass.getClassLoader)
+ val clazz = classLoader.loadClass(name)
+ clazz.asInstanceOf[Class[U]]
+ }
+}
+
+/**
+ * Module for remote typed actor serialization.
+ */
+object RemoteTypedActorSerialization {
+ /**
+ * Deserializes a byte array (Array[Byte]) into an RemoteActorRef instance.
+ */
+ def fromBinaryToRemoteTypedActorRef[T <: AnyRef](bytes: Array[Byte]): T =
+ fromProtobufToRemoteTypedActorRef(RemoteTypedActorRefProtocol.newBuilder.mergeFrom(bytes).build, None)
+
+ /**
+ * Deserializes a byte array (Array[Byte]) into a AW RemoteActorRef proxy.
+ */
+ def fromBinaryToRemoteTypedActorRef[T <: AnyRef](bytes: Array[Byte], loader: ClassLoader): T =
+ fromProtobufToRemoteTypedActorRef(RemoteTypedActorRefProtocol.newBuilder.mergeFrom(bytes).build, Some(loader))
+
+ /**
+ * Serialize as AW RemoteActorRef proxy.
+ */
+ def toBinary[T <: Actor](proxy: AnyRef): Array[Byte] = {
+ toRemoteTypedActorRefProtocol(proxy).toByteArray
+ }
+
+ /**
+ * Deserializes a RemoteTypedActorRefProtocol Protocol Buffers (protobuf) Message into AW RemoteActorRef proxy.
+ */
+ private[akka] def fromProtobufToRemoteTypedActorRef[T](protocol: RemoteTypedActorRefProtocol, loader: Option[ClassLoader]): T = {
+ Actor.log.debug("Deserializing RemoteTypedActorRefProtocol to AW RemoteActorRef proxy:\n" + protocol)
+ val actorRef = RemoteActorSerialization.fromProtobufToRemoteActorRef(protocol.getActorRef, loader)
+ val intfClass = TypedActorSerialization.toClass(loader, protocol.getInterfaceName)
+ TypedActor.createProxyForRemoteActorRef(intfClass, actorRef).asInstanceOf[T]
+ }
+
+ /**
+ * Serializes the AW TypedActor proxy into a Protocol Buffers (protobuf) Message.
+ */
+ def toRemoteTypedActorRefProtocol(proxy: AnyRef): RemoteTypedActorRefProtocol = {
+ val init = AspectInitRegistry.initFor(proxy)
+ RemoteTypedActorRefProtocol.newBuilder
+ .setActorRef(RemoteActorSerialization.toRemoteActorRefProtocol(init.actorRef))
+ .setInterfaceName(init.interfaceClass.getName)
+ .build
+ }
+
}
diff --git a/akka-remote/src/test/scala/remote/ServerInitiatedRemoteActorSpec.scala b/akka-remote/src/test/scala/remote/ServerInitiatedRemoteActorSpec.scala
index 59f122c656..fbf723ece5 100644
--- a/akka-remote/src/test/scala/remote/ServerInitiatedRemoteActorSpec.scala
+++ b/akka-remote/src/test/scala/remote/ServerInitiatedRemoteActorSpec.scala
@@ -79,7 +79,6 @@ class ServerInitiatedRemoteActorSpec extends JUnitSuite {
}
}
-
@Test
def shouldSendWithBang {
val actor = RemoteClient.actorFor(
@@ -178,5 +177,41 @@ class ServerInitiatedRemoteActorSpec extends JUnitSuite {
assert(actor2.id == actor3.id)
}
+ @Test
+ def shouldFindActorByUuid {
+ val actor1 = actorOf[RemoteActorSpecActorUnidirectional]
+ val actor2 = actorOf[RemoteActorSpecActorUnidirectional]
+ server.register("uuid:" + actor1.uuid, actor1)
+ server.register("my-service", actor2)
+
+ val ref1 = RemoteClient.actorFor("uuid:" + actor1.uuid, HOSTNAME, PORT)
+ val ref2 = RemoteClient.actorFor("my-service", HOSTNAME, PORT)
+
+ ref1 ! "OneWay"
+ assert(RemoteActorSpecActorUnidirectional.latch.await(1, TimeUnit.SECONDS))
+ ref1.stop
+ ref2 ! "OneWay"
+ ref2.stop
+
+ }
+
+ @Test
+ def shouldRegisterAndUnregister {
+ val actor1 = actorOf[RemoteActorSpecActorUnidirectional]
+ server.register("my-service-1", actor1)
+ assert(server.actors().get("my-service-1") != null, "actor registered")
+ server.unregister("my-service-1")
+ assert(server.actors().get("my-service-1") == null, "actor unregistered")
+ }
+
+ @Test
+ def shouldRegisterAndUnregisterByUuid {
+ val actor1 = actorOf[RemoteActorSpecActorUnidirectional]
+ server.register("uuid:" + actor1.uuid, actor1)
+ assert(server.actorsByUuid().get(actor1.uuid) != null, "actor registered")
+ server.unregister("uuid:" + actor1.uuid)
+ assert(server.actorsByUuid().get(actor1.uuid) == null, "actor unregistered")
+ }
+
}
diff --git a/akka-remote/src/test/scala/remote/ServerInitiatedRemoteTypedActorSpec.scala b/akka-remote/src/test/scala/remote/ServerInitiatedRemoteTypedActorSpec.scala
index b800fbf2c3..f50c3e6652 100644
--- a/akka-remote/src/test/scala/remote/ServerInitiatedRemoteTypedActorSpec.scala
+++ b/akka-remote/src/test/scala/remote/ServerInitiatedRemoteTypedActorSpec.scala
@@ -103,9 +103,34 @@ class ServerInitiatedRemoteTypedActorSpec extends
it("should register and unregister typed actors") {
val typedActor = TypedActor.newInstance(classOf[RemoteTypedActorOne], classOf[RemoteTypedActorOneImpl], 1000)
server.registerTypedActor("my-test-service", typedActor)
- assert(server.typedActors().get("my-test-service") != null)
+ assert(server.typedActors().get("my-test-service") != null, "typed actor registered")
server.unregisterTypedActor("my-test-service")
- assert(server.typedActors().get("my-test-service") == null)
+ assert(server.typedActors().get("my-test-service") == null, "typed actor unregistered")
+ }
+
+ it("should register and unregister typed actors by uuid") {
+ val typedActor = TypedActor.newInstance(classOf[RemoteTypedActorOne], classOf[RemoteTypedActorOneImpl], 1000)
+ val init = AspectInitRegistry.initFor(typedActor)
+ val uuid = "uuid:" + init.actorRef.uuid
+ server.registerTypedActor(uuid, typedActor)
+ assert(server.typedActorsByUuid().get(init.actorRef.uuid) != null, "typed actor registered")
+ server.unregisterTypedActor(uuid)
+ assert(server.typedActorsByUuid().get(init.actorRef.uuid) == null, "typed actor unregistered")
+ }
+
+ it("should find typed actors by uuid") {
+ val typedActor = TypedActor.newInstance(classOf[RemoteTypedActorOne], classOf[RemoteTypedActorOneImpl], 1000)
+ val init = AspectInitRegistry.initFor(typedActor)
+ val uuid = "uuid:" + init.actorRef.uuid
+ server.registerTypedActor(uuid, typedActor)
+ assert(server.typedActorsByUuid().get(init.actorRef.uuid) != null, "typed actor registered")
+
+ val actor = RemoteClient.typedActorFor(classOf[RemoteTypedActorOne], uuid, HOSTNAME, PORT)
+ expect("oneway") {
+ actor.oneWay
+ oneWayLog.poll(5, TimeUnit.SECONDS)
+ }
+
}
}
}
diff --git a/akka-remote/src/test/scala/serialization/TypedActorSerializationSpec.scala b/akka-remote/src/test/scala/serialization/TypedActorSerializationSpec.scala
new file mode 100644
index 0000000000..ccf4d05f7f
--- /dev/null
+++ b/akka-remote/src/test/scala/serialization/TypedActorSerializationSpec.scala
@@ -0,0 +1,166 @@
+/**
+ * Copyright (C) 2009-2010 Scalable Solutions AB
+ */
+package se.scalablesolutions.akka.actor.serialization
+
+import org.scalatest.Spec
+import org.scalatest.matchers.ShouldMatchers
+import org.scalatest.BeforeAndAfterAll
+import org.scalatest.junit.JUnitRunner
+import org.junit.runner.RunWith
+
+import se.scalablesolutions.akka.serialization._
+import se.scalablesolutions.akka.actor._
+
+import TypedActorSerialization._
+import Actor._
+import se.scalablesolutions.akka.remote.{RemoteClient, RemoteServer}
+import se.scalablesolutions.akka.actor.remote.ServerInitiatedRemoteActorSpec.RemoteActorSpecActorUnidirectional
+
+@RunWith(classOf[JUnitRunner])
+class TypedActorSerializationSpec extends
+ Spec with
+ ShouldMatchers with
+ BeforeAndAfterAll {
+
+ var server1: RemoteServer = null
+ var typedActor: MyTypedActor = null
+
+ override def beforeAll = {
+ server1 = new RemoteServer().start("localhost", 9991)
+ typedActor = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyTypedActorImpl], 1000)
+ server1.registerTypedActor("typed-actor-service", typedActor)
+ Thread.sleep(1000)
+ }
+
+ // make sure the servers shutdown cleanly after the test has finished
+ override def afterAll = {
+ try {
+ TypedActor.stop(typedActor)
+ server1.shutdown
+ RemoteClient.shutdownAll
+ Thread.sleep(1000)
+ } catch {
+ case e => ()
+ }
+ }
+
+ object MyTypedStatelessActorFormat extends StatelessActorFormat[MyStatelessTypedActorImpl]
+
+ class MyTypedActorFormat extends Format[MyTypedActorImpl] {
+ def fromBinary(bytes: Array[Byte], act: MyTypedActorImpl) = {
+ val p = Serializer.Protobuf.fromBinary(bytes, Some(classOf[ProtobufProtocol.Counter])).asInstanceOf[ProtobufProtocol.Counter]
+ act.count = p.getCount
+ act
+ }
+ def toBinary(ac: MyTypedActorImpl) =
+ ProtobufProtocol.Counter.newBuilder.setCount(ac.count).build.toByteArray
+ }
+
+ class MyTypedActorWithDualCounterFormat extends Format[MyTypedActorWithDualCounter] {
+ def fromBinary(bytes: Array[Byte], act: MyTypedActorWithDualCounter) = {
+ val p = Serializer.Protobuf.fromBinary(bytes, Some(classOf[ProtobufProtocol.DualCounter])).asInstanceOf[ProtobufProtocol.DualCounter]
+ act.count1 = p.getCount1
+ act.count2 = p.getCount2
+ act
+ }
+ def toBinary(ac: MyTypedActorWithDualCounter) =
+ ProtobufProtocol.DualCounter.newBuilder.setCount1(ac.count1).setCount2(ac.count2).build.toByteArray
+ }
+
+
+ describe("Serializable typed actor") {
+
+ it("should be able to serialize and de-serialize a stateless typed actor") {
+ val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyStatelessTypedActorImpl], 1000)
+ typedActor1.requestReply("hello") should equal("world")
+ typedActor1.requestReply("hello") should equal("world")
+
+ val bytes = toBinaryJ(typedActor1, MyTypedStatelessActorFormat)
+ val typedActor2: MyTypedActor = fromBinaryJ(bytes, MyTypedStatelessActorFormat)
+ typedActor2.requestReply("hello") should equal("world")
+ }
+
+ it("should be able to serialize and de-serialize a stateful typed actor") {
+ val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyTypedActorImpl], 1000)
+ typedActor1.requestReply("hello") should equal("world 1")
+ typedActor1.requestReply("scala") should equal("hello scala 2")
+
+ val f = new MyTypedActorFormat
+ val bytes = toBinaryJ(typedActor1, f)
+ val typedActor2: MyTypedActor = fromBinaryJ(bytes, f)
+ typedActor2.requestReply("hello") should equal("world 3")
+ }
+
+ it("should be able to serialize and de-serialize a stateful typed actor with compound state") {
+ val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyTypedActorWithDualCounter], 1000)
+ typedActor1.requestReply("hello") should equal("world 1 1")
+ typedActor1.requestReply("hello") should equal("world 2 2")
+
+ val f = new MyTypedActorWithDualCounterFormat
+ val bytes = toBinaryJ(typedActor1, f)
+ val typedActor2: MyTypedActor = fromBinaryJ(bytes, f)
+ typedActor2.requestReply("hello") should equal("world 3 3")
+ }
+
+ it("should be able to serialize a local yped actor ref to a remote typed actor ref proxy") {
+ val typedActor1 = TypedActor.newInstance(classOf[MyTypedActor], classOf[MyStatelessTypedActorImpl], 1000)
+ typedActor1.requestReply("hello") should equal("world")
+ typedActor1.requestReply("hello") should equal("world")
+
+ val bytes = RemoteTypedActorSerialization.toBinary(typedActor1)
+ val typedActor2: MyTypedActor = RemoteTypedActorSerialization.fromBinaryToRemoteTypedActorRef(bytes)
+ typedActor1.requestReply("hello") should equal("world")
+ }
+ }
+}
+
+
+trait MyTypedActor {
+ def requestReply(s: String) : String
+ def oneWay() : Unit
+}
+
+class MyTypedActorImpl extends TypedActor with MyTypedActor {
+ var count = 0
+
+ override def oneWay() {
+ println("got oneWay message")
+ }
+
+ override def requestReply(message: String) : String = {
+ count = count + 1
+ if (message == "hello") {
+ "world " + count
+ } else ("hello " + message + " " + count)
+ }
+}
+
+class MyTypedActorWithDualCounter extends TypedActor with MyTypedActor {
+ var count1 = 0
+ var count2 = 0
+
+ override def oneWay() {
+ println("got oneWay message")
+ }
+
+ override def requestReply(message: String) : String = {
+ count1 = count1 + 1
+ count2 = count2 + 1
+
+ if (message == "hello") {
+ "world " + count1 + " " + count2
+ } else ("hello " + message + " " + count1 + " " + count2)
+ }
+}
+
+class MyStatelessTypedActorImpl extends TypedActor with MyTypedActor {
+
+ override def oneWay() {
+ println("got oneWay message")
+ }
+
+ override def requestReply(message: String) : String = {
+ if (message == "hello") "world" else ("hello " + message)
+ }
+}
diff --git a/akka-typed-actor/src/main/scala/actor/TypedActor.scala b/akka-typed-actor/src/main/scala/actor/TypedActor.scala
index c3457cb43b..f6cf2e2337 100644
--- a/akka-typed-actor/src/main/scala/actor/TypedActor.scala
+++ b/akka-typed-actor/src/main/scala/actor/TypedActor.scala
@@ -390,11 +390,22 @@ object TypedActor extends Logging {
if (config._messageDispatcher.isDefined) actorRef.dispatcher = config._messageDispatcher.get
if (config._threadBasedDispatcher.isDefined) actorRef.dispatcher = Dispatchers.newThreadBasedDispatcher(actorRef)
if (config._host.isDefined) actorRef.makeRemote(config._host.get)
+ actorRef.timeout = config.timeout
AspectInitRegistry.register(proxy, AspectInit(intfClass, typedActor, actorRef, config._host, config.timeout))
actorRef.start
proxy.asInstanceOf[T]
}
+ private[akka] def newInstance[T](intfClass: Class[T], actorRef: ActorRef): T = {
+ if (!actorRef.actorInstance.get.isInstanceOf[TypedActor]) throw new IllegalArgumentException("ActorRef is not a ref to a typed actor")
+ val typedActor = actorRef.actorInstance.get.asInstanceOf[TypedActor]
+ val proxy = Proxy.newInstance(Array(intfClass), Array(typedActor), true, false)
+ typedActor.initialize(proxy)
+ AspectInitRegistry.register(proxy, AspectInit(intfClass, typedActor, actorRef, actorRef.remoteAddress, actorRef.timeout))
+ actorRef.start
+ proxy.asInstanceOf[T]
+ }
+
private[akka] def newInstance[T](intfClass: Class[T], targetClass: Class[_],
remoteAddress: Option[InetSocketAddress], timeout: Long): T = {
val actorRef = actorOf(newTypedActor(targetClass))
diff --git a/config/akka-reference.conf b/config/akka-reference.conf
index 859425a6c7..ff7b57d9d5 100644
--- a/config/akka-reference.conf
+++ b/config/akka-reference.conf
@@ -165,5 +165,9 @@ akka {
hostname = "127.0.0.1" # IP address or hostname of the Redis instance
port = 6379 # Port to Redis
}
+
+ hbase {
+ zookeeper.quorum = "localhost"
+ }
}
}
diff --git a/embedded-repo/org/apache/hbase/hbase-core/0.20.6/hbase-core-0.20.6.jar b/embedded-repo/org/apache/hbase/hbase-core/0.20.6/hbase-core-0.20.6.jar
new file mode 100644
index 0000000000..e74cf9017e
Binary files /dev/null and b/embedded-repo/org/apache/hbase/hbase-core/0.20.6/hbase-core-0.20.6.jar differ
diff --git a/embedded-repo/org/apache/hbase/hbase-test/0.20.6/hbase-test-0.20.6.jar b/embedded-repo/org/apache/hbase/hbase-test/0.20.6/hbase-test-0.20.6.jar
new file mode 100644
index 0000000000..34a65f908e
Binary files /dev/null and b/embedded-repo/org/apache/hbase/hbase-test/0.20.6/hbase-test-0.20.6.jar differ
diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index 90fc49afc2..bb468c7b9f 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -51,6 +51,8 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
lazy val JavaNetRepo = MavenRepository("java.net Repo", "http://download.java.net/maven/2")
lazy val SonatypeSnapshotRepo = MavenRepository("Sonatype OSS Repo", "http://oss.sonatype.org/content/repositories/releases")
lazy val SunJDMKRepo = MavenRepository("Sun JDMK Repo", "http://wp5.e-taxonomy.eu/cdmlib/mavenrepo")
+ lazy val CasbahRepoReleases = MavenRepository("Casbah Release Repo", "http://repo.bumnetworks.com/releases")
+ lazy val ZookeeperRepo = MavenRepository("Zookeeper Repo", "http://lilycms.org/maven/maven2/deploy/")
}
// -------------------------------------------------------------------------------------------------------------------
@@ -77,6 +79,8 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
lazy val scalaTestModuleConfig = ModuleConfiguration("org.scalatest", ScalaToolsSnapshots)
lazy val logbackModuleConfig = ModuleConfiguration("ch.qos.logback",sbt.DefaultMavenRepository)
lazy val atomikosModuleConfig = ModuleConfiguration("com.atomikos",sbt.DefaultMavenRepository)
+ lazy val casbahRelease = ModuleConfiguration("com.novus",CasbahRepoReleases)
+ lazy val zookeeperRelease = ModuleConfiguration("org.apache.hadoop.zookeeper",ZookeeperRepo)
lazy val casbahModuleConfig = ModuleConfiguration("com.novus", CasbahRepo)
lazy val timeModuleConfig = ModuleConfiguration("org.scala-tools", "time", CasbahSnapshotRepo)
lazy val embeddedRepo = EmbeddedRepo // This is the only exception, because the embedded repo is fast!
@@ -203,6 +207,12 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
lazy val werkz = "org.codehaus.aspectwerkz" % "aspectwerkz-nodeps-jdk5" % ASPECTWERKZ_VERSION % "compile"
lazy val werkz_core = "org.codehaus.aspectwerkz" % "aspectwerkz-jdk5" % ASPECTWERKZ_VERSION % "compile"
+ lazy val zookeeper = "org.apache.hadoop.zookeeper" % "zookeeper" % "3.2.2" % "compile"
+
+ lazy val hadoop_core = "org.apache.hadoop" % "hadoop-core" % "0.20.2" % "compile"
+
+ lazy val hbase_core = "org.apache.hbase" % "hbase-core" % "0.20.6" % "compile"
+
// Test
lazy val camel_spring = "org.apache.camel" % "camel-spring" % CAMEL_VERSION % "test"
@@ -216,6 +226,10 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
lazy val junit = "junit" % "junit" % "4.5" % "test"
lazy val mockito = "org.mockito" % "mockito-all" % "1.8.1" % "test"
lazy val scalatest = "org.scalatest" % "scalatest" % SCALATEST_VERSION % "test"
+ lazy val hadoop_test = "org.apache.hadoop" % "hadoop-test" % "0.20.2" % "test"
+ lazy val hbase_test = "org.apache.hbase" % "hbase-test" % "0.20.6" % "test"
+ lazy val log4j = "log4j" % "log4j" % "1.2.15" % "test"
+ lazy val jett_mortbay = "org.mortbay.jetty" % "jetty" % "6.1.14" % "test"
}
// -------------------------------------------------------------------------------------------------------------------
@@ -461,6 +475,8 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
new AkkaMongoProject(_), akka_persistence_common)
lazy val akka_persistence_cassandra = project("akka-persistence-cassandra", "akka-persistence-cassandra",
new AkkaCassandraProject(_), akka_persistence_common)
+ lazy val akka_persistence_hbase = project("akka-persistence-hbase", "akka-persistence-hbase",
+ new AkkaHbaseProject(_), akka_persistence_common)
}
// -------------------------------------------------------------------------------------------------------------------
@@ -510,6 +526,22 @@ class AkkaParentProject(info: ProjectInfo) extends DefaultProject(info) {
override def testOptions = TestFilter((name: String) => name.endsWith("Test")) :: Nil
}
+ // -------------------------------------------------------------------------------------------------------------------
+ // akka-persistence-hbase subproject
+ // -------------------------------------------------------------------------------------------------------------------
+
+ class AkkaHbaseProject(info: ProjectInfo) extends AkkaDefaultProject(info, distPath) {
+ val zookeeper = Dependencies.zookeeper
+ val hadoop_core = Dependencies.hadoop_core
+ val hbase_core = Dependencies.hbase_core
+
+ // testing
+ val hadoop_test = Dependencies.hadoop_test
+ val hbase_test = Dependencies.hbase_test
+ val jetty = Dependencies.jett_mortbay
+ val log4j = Dependencies.log4j
+ }
+
// -------------------------------------------------------------------------------------------------------------------
// akka-kernel subproject
// -------------------------------------------------------------------------------------------------------------------