New Actor constructor

Author: sleipnir

README.md

@@ -254,36 +254,36 @@ package io.eigr.spawn.java.demo;
 
 import io.eigr.spawn.api.Value;
 import io.eigr.spawn.api.actors.ActorContext;
-import io.eigr.spawn.api.annotations.Action;
-import io.eigr.spawn.api.annotations.NamedActor;
+import io.eigr.spawn.api.actors.annotations.Action;
+import io.eigr.spawn.api.actors.annotations.NamedActor;
 import io.eigr.spawn.java.demo.domain.Domain;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @NamedActor(name = "joe", stateType = Domain.JoeState.class)
 public class Joe {
-    private static final Logger log = LoggerFactory.getLogger(Joe.class);
-
-    @Action(name = "hi", inputType = Domain.Request.class)
-    public Value hi(Domain.Request msg, ActorContext<Domain.JoeState> context) {
-        log.info("Received invocation. Message: {}. Context: {}", msg, context);
-        if (context.getState().isPresent()) {
-            log.info("State is present and value is {}", context.getState().get());
-        }
-
-        return Value.at()
-                .response(Domain.Reply.newBuilder()
-                        .setResponse("Hello From Java")
-                        .build())
-                .state(updateState("erlang"))
-                .reply();
-    }
-
-    private Domain.JoeState updateState(String language) {
-        return Domain.JoeState.newBuilder()
-                .addLanguages(language)
-                .build();
-    }
+   private static final Logger log = LoggerFactory.getLogger(Joe.class);
+
+   @Action(name = "hi", inputType = Domain.Request.class)
+   public Value hi(Domain.Request msg, ActorContext<Domain.JoeState> context) {
+      log.info("Received invocation. Message: {}. Context: {}", msg, context);
+      if (context.getState().isPresent()) {
+         log.info("State is present and value is {}", context.getState().get());
+      }
+
+      return Value.at()
+              .response(Domain.Reply.newBuilder()
+                      .setResponse("Hello From Java")
+                      .build())
+              .state(updateState("erlang"))
+              .reply();
+   }
+
+   private Domain.JoeState updateState(String language) {
+      return Domain.JoeState.newBuilder()
+              .addLanguages(language)
+              .build();
+   }
 }
 ```
 
@@ -293,20 +293,20 @@ to serve as your application's entrypoint and fill it with the following content
 ```Java
 package io.eigr.spawn.java.demo;
 
-import io.eigr.spawn.Spawn;
-import io.eigr.spawn.Spawn.SpawnSystem;
+import io.eigr.spawn.api.Spawn;
+import io.eigr.spawn.api.Spawn.SpawnSystem;
 
 public class App {
-    public static void main(String[] args) throws Exception {
-        Spawn spawnSystem = new SpawnSystem()
-                .create("spawn-system")
-                .withPort(8091)
-                .withProxyPort(9003)
-                .withActor(Joe.class)
-                .build();
-
-        spawnSystem.start();
-    }
+   public static void main(String[] args) throws Exception {
+      Spawn spawnSystem = new SpawnSystem()
+              .create("spawn-system")
+              .withPort(8091)
+              .withProxyPort(9003)
+              .withActor(Joe.class)
+              .build();
+
+      spawnSystem.start();
+   }
 }
 ```
 
@@ -401,35 +401,35 @@ To produce events in a topic, just use the Broadcast Workflow. The example below
 ```Java
 package io.eigr.spawn.java.demo;
 
-import io.eigr.spawn.api.workflows.Broadcast;
+import io.eigr.spawn.api.actors.workflows.Broadcast;
 // some imports omitted for brevity
 
 @NamedActor(name = "joe", stateful = true, stateType = Domain.JoeState.class, channel = "test")
 public class Joe {
-    @TimerAction(name = "hi", period = 60000)
-    public Value hi(ActorContext<Domain.JoeState> context) {
-        Domain.Request msg = Domain.Request.newBuilder()
-                .setLanguage("erlang")
-                .build();
-
-        return Value.at()
-                .flow(Broadcast.to("test", "setLanguage", msg))
-                .response(Domain.Reply.newBuilder()
-                        .setResponse("Hello From Erlang")
-                        .build())
-                .state(updateState("erlang"))
-                .reply();
-    }
-
-    @Action(inputType = Domain.Request.class)
-    public Value setLanguage(Domain.Request msg, ActorContext<Domain.JoeState> context) {
-        return Value.at()
-                .response(Domain.Reply.newBuilder()
-                        .setResponse("Hello From Java")
-                        .build())
-                .state(updateState("java"))
-                .reply();
-    }
+   @TimerAction(name = "hi", period = 60000)
+   public Value hi(ActorContext<Domain.JoeState> context) {
+      Domain.Request msg = Domain.Request.newBuilder()
+              .setLanguage("erlang")
+              .build();
+
+      return Value.at()
+              .flow(Broadcast.to("test", "setLanguage", msg))
+              .response(Domain.Reply.newBuilder()
+                      .setResponse("Hello From Erlang")
+                      .build())
+              .state(updateState("erlang"))
+              .reply();
+   }
+
+   @Action(inputType = Domain.Request.class)
+   public Value setLanguage(Domain.Request msg, ActorContext<Domain.JoeState> context) {
+      return Value.at()
+              .response(Domain.Reply.newBuilder()
+                      .setResponse("Hello From Java")
+                      .build())
+              .state(updateState("java"))
+              .reply();
+   }
    // ....
 }
 ```
@@ -540,32 +540,32 @@ More detailed in complete main class:
 ```java
 package io.eigr.spawn.java.demo;
 
-import io.eigr.spawn.Spawn;
-import io.eigr.spawn.Spawn.SpawnSystem;
+import io.eigr.spawn.api.Spawn;
+import io.eigr.spawn.api.Spawn.SpawnSystem;
 import io.eigr.spawn.api.actors.ActorRef;
 import io.eigr.spawn.java.demo.domain.Domain;
 
 import java.util.Optional;
 
 public class App {
-    public static void main(String[] args) throws Exception {
-        Spawn spawnSystem = new SpawnSystem()
-                .create("spawn-system")
-                .withPort(8091)
-                .withProxyPort(9003)
-                .withActor(Joe.class)
-                .build();
-
-        spawnSystem.start();
-
-        ActorRef joeActor = spawnSystem.createActorRef("spawn-system", "joe");
-
-        Domain.Request msg = Domain.Request.newBuilder()
-                .setLanguage("erlang")
-                .build();
-        Domain.Reply reply =
-                (Domain.Reply) joeActor.invoke("setLanguage", msg, Domain.Reply.class, Optional.empty());
-    }
+   public static void main(String[] args) throws Exception {
+      Spawn spawnSystem = new SpawnSystem()
+              .create("spawn-system")
+              .withPort(8091)
+              .withProxyPort(9003)
+              .withActor(Joe.class)
+              .build();
+
+      spawnSystem.start();
+
+      ActorRef joeActor = spawnSystem.createActorRef("spawn-system", "joe");
+
+      Domain.Request msg = Domain.Request.newBuilder()
+              .setLanguage("erlang")
+              .build();
+      Domain.Reply reply =
+              (Domain.Reply) joeActor.invoke("setLanguage", msg, Domain.Reply.class, Optional.empty());
+   }
 }
 ```
 

src/main/java/io/eigr/spawn/Spawn.java …c/main/java/io/eigr/spawn/api/Spawn.javasrc/main/java/io/eigr/spawn/Spawn.java renamed to src/main/java/io/eigr/spawn/api/Spawn.java src/main/java/io/eigr/spawn/Spawn.java renamed to src/main/java/io/eigr/spawn/api/Spawn.java

@@ -1,12 +1,13 @@
-package io.eigr.spawn;
+package io.eigr.spawn.api;
 
 import com.sun.net.httpserver.HttpServer;
 import io.eigr.functions.protocol.Protocol;
 import io.eigr.functions.protocol.actors.ActorOuterClass;
+import io.eigr.spawn.api.actors.ActorFactory;
 import io.eigr.spawn.api.actors.ActorRef;
-import io.eigr.spawn.api.annotations.NamedActor;
-import io.eigr.spawn.api.annotations.PooledActor;
-import io.eigr.spawn.api.annotations.UnNamedActor;
+import io.eigr.spawn.api.actors.annotations.NamedActor;
+import io.eigr.spawn.api.actors.annotations.PooledActor;
+import io.eigr.spawn.api.actors.annotations.UnNamedActor;
 import io.eigr.spawn.internal.Entity;
 import io.eigr.spawn.internal.client.OkHttpSpawnClient;
 import io.eigr.spawn.internal.client.SpawnClient;
@@ -62,11 +63,6 @@ public String getSystem() {
         return system;
     }
 
-    public void start() throws Exception {
-        startServer();
-        registerActorSystem();
-    }
-
     public ActorRef createActorRef(String system, String name) throws Exception {
         return ActorRef.of(this.client, system, name);
     }
@@ -75,9 +71,14 @@ public ActorRef createActorRef(String system, String name, String parent) throws
         return ActorRef.of(this.client, system, name, parent);
     }
 
+    public void start() throws Exception {
+        startServer();
+        registerActorSystem();
+    }
+
     private void startServer() throws IOException {
         HttpServer httpServer = HttpServer.create(new InetSocketAddress("127.0.0.1", this.port), 0);
-        httpServer.createContext("/api/v1/actors/actions", new ActorServiceHandler(this.system, this.entities));
+        httpServer.createContext("/api/v1/actors/actions", new ActorServiceHandler(this, this.entities));
         //httpServer.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
         httpServer.setExecutor(Executors.newCachedThreadPool());
         httpServer.start();
@@ -154,15 +155,15 @@ private Map<String, ActorOuterClass.Actor> getActors(List<Entity> entities) {
                     )
                     .setMetadata(metadata)
                     .setSettings(settings)
-                    .addAllActions(getCommands(actorEntity))
-                    .addAllTimerActions(getTimerCommands(actorEntity))
+                    .addAllActions(getActions(actorEntity))
+                    .addAllTimerActions(getTimerActions(actorEntity))
                     .setState(ActorOuterClass.ActorState.newBuilder().build())
                     .build();
 
         }).collect(Collectors.toMap(actor -> actor.getId().getName(), Function.identity()));
     }
 
-    private List<ActorOuterClass.Action> getCommands(Entity actorEntity) {
+    private List<ActorOuterClass.Action> getActions(Entity actorEntity) {
         return actorEntity.getActions()
                 .values()
                 .stream()
@@ -175,7 +176,7 @@ private List<ActorOuterClass.Action> getCommands(Entity actorEntity) {
                 .collect(Collectors.toList());
     }
 
-    private List<ActorOuterClass.FixedTimerAction> getTimerCommands(Entity actorEntity) {
+    private List<ActorOuterClass.FixedTimerAction> getTimerActions(Entity actorEntity) {
         List<ActorOuterClass.FixedTimerAction> timerActions = actorEntity.getTimerActions()
                 .values()
                 .stream()
@@ -195,6 +196,17 @@ private List<ActorOuterClass.FixedTimerAction> getTimerCommands(Entity actorEnti
         return timerActions;
     }
 
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", Spawn.class.getSimpleName() + "[", "]")
+                .add("system='" + system + "'")
+                .add("port=" + port)
+                .add("proxyHost='" + proxyHost + "'")
+                .add("proxyPort=" + proxyPort)
+                .add("host='" + host + "'")
+                .toString();
+    }
+
     public static final class SpawnSystem {
 
         private SpawnClient client;
@@ -224,30 +236,60 @@ public SpawnSystem withProxyPort(int port) {
             return this;
         }
 
-        public SpawnSystem withActor(Class<?> actorKlass) {
+        public SpawnSystem addActor(Class<?> actorKlass) {
             Optional<Entity> maybeEntity = getEntity(actorKlass);
             if (maybeEntity.isPresent()) {
                 this.entities.add(maybeEntity.get());
             }
             return this;
         }
 
+        public SpawnSystem addActorWithArgs(Class<?> actorKlass, Object arg, ActorFactory factory) {
+            Optional<Entity> maybeEntity = getEntity(actorKlass, arg, factory);
+            if (maybeEntity.isPresent()) {
+                this.entities.add(maybeEntity.get());
+            }
+            return this;
+        }
+
         public Spawn build() {
             this.client = new OkHttpSpawnClient(this.system, this.proxyHost, this.proxyPort);
             return new Spawn(this);
         }
 
         private Optional<Entity> getEntity(Class<?> actorKlass) {
             if (Objects.nonNull(actorKlass.getAnnotation(NamedActor.class))) {
-                return Optional.of(Entity.fromAnnotationToEntity(actorKlass, actorKlass.getAnnotation(NamedActor.class)));
+                return Optional.of(Entity.fromAnnotationToEntity(
+                        actorKlass, actorKlass.getAnnotation(NamedActor.class), null, null));
             }
 
             if (Objects.nonNull(actorKlass.getAnnotation(UnNamedActor.class))) {
-                return Optional.of(Entity.fromAnnotationToEntity(actorKlass, actorKlass.getAnnotation(UnNamedActor.class)));
+                return Optional.of(Entity.fromAnnotationToEntity(
+                        actorKlass, actorKlass.getAnnotation(UnNamedActor.class), null, null));
             }
 
             if (Objects.nonNull(actorKlass.getAnnotation(PooledActor.class))) {
-                return Optional.of(Entity.fromAnnotationToEntity(actorKlass, actorKlass.getAnnotation(PooledActor.class)));
+                return Optional.of(Entity.fromAnnotationToEntity(
+                        actorKlass, actorKlass.getAnnotation(PooledActor.class), null, null));
+            }
+
+            return Optional.empty();
+        }
+
+        private Optional<Entity> getEntity(Class<?> actorType, Object arg, ActorFactory factory) {
+            if (Objects.nonNull(actorType.getAnnotation(NamedActor.class))) {
+                NamedActor annotation = actorType.getAnnotation(NamedActor.class);
+                return Optional.of(Entity.fromAnnotationToEntity(actorType, annotation, arg, factory));
+            }
+
+            if (Objects.nonNull(actorType.getAnnotation(UnNamedActor.class))) {
+                UnNamedActor annotation = actorType.getAnnotation(UnNamedActor.class);
+                return Optional.of(Entity.fromAnnotationToEntity(actorType, annotation, arg, factory));
+            }
+
+            if (Objects.nonNull(actorType.getAnnotation(PooledActor.class))) {
+                PooledActor annotation = actorType.getAnnotation(PooledActor.class);
+                return Optional.of(Entity.fromAnnotationToEntity(actorType, annotation, arg, factory));
             }
 
             return Optional.empty();

src/main/java/io/eigr/spawn/api/Value.java

@@ -1,10 +1,10 @@
 package io.eigr.spawn.api;
 
 import com.google.protobuf.GeneratedMessageV3;
-import io.eigr.spawn.api.workflows.Broadcast;
-import io.eigr.spawn.api.workflows.Forward;
-import io.eigr.spawn.api.workflows.Pipe;
-import io.eigr.spawn.api.workflows.SideEffect;
+import io.eigr.spawn.api.actors.workflows.Broadcast;
+import io.eigr.spawn.api.actors.workflows.Forward;
+import io.eigr.spawn.api.actors.workflows.Pipe;
+import io.eigr.spawn.api.actors.workflows.SideEffect;
 
 import java.util.List;
 import java.util.Objects;