ActorContext.getParent for Java API #22413

akka-docs/rst/java/code/jdocs/camel/ActivationTestBase.java

@@ -0,0 +1,54 @@
+package jdocs.camel;
+//#CamelActivation
+    import akka.actor.ActorRef;
+    import akka.actor.ActorSystem;
+    import akka.actor.Props;
+    import akka.camel.Camel;
+    import akka.camel.CamelExtension;
+    import akka.camel.javaapi.UntypedConsumerActor;
+    import akka.testkit.JavaTestKit;
+    import akka.util.Timeout;
+    import jdocs.AbstractJavaTest;
+    import scala.concurrent.Future;
+    import scala.concurrent.duration.Duration;
+    import static java.util.concurrent.TimeUnit.SECONDS;
+//#CamelActivation
+
+import org.junit.Test;
+
+public class ActivationTestBase extends AbstractJavaTest {
+
+  @SuppressWarnings("unused")
+  @Test
+  public void testActivation() {
+    //#CamelActivation
+
+    // ..
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = Props.create(MyConsumer.class);
+    ActorRef producer = system.actorOf(props,"myproducer");
+    Camel camel = CamelExtension.get(system);
+    // get a future reference to the activation of the endpoint of the Consumer Actor
+    Timeout timeout = new Timeout(Duration.create(10, SECONDS));
+    Future<ActorRef> activationFuture = camel.activationFutureFor(producer,
+      timeout, system.dispatcher());
+    //#CamelActivation
+    //#CamelDeactivation
+    // ..
+    system.stop(producer);
+    // get a future reference to the deactivation of the endpoint of the Consumer Actor
+    Future<ActorRef> deactivationFuture = camel.deactivationFutureFor(producer,
+      timeout, system.dispatcher());
+    //#CamelDeactivation
+    JavaTestKit.shutdownActorSystem(system);
+  }
+
+  public static class MyConsumer extends UntypedConsumerActor {
+    public String getEndpointUri() {
+      return "direct:test";
+    }
+
+    public void onReceive(Object message) {
+    }
+  }
+}

akka-docs/rst/java/code/jdocs/camel/CamelExtensionTest.java

@@ -0,0 +1,34 @@
+package jdocs.camel;
+
+import akka.actor.ActorSystem;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import akka.testkit.JavaTestKit;
+import jdocs.AbstractJavaTest;
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.junit.Test;
+
+public class CamelExtensionTest extends AbstractJavaTest {
+  @Test
+  public void getCamelExtension() {
+    //#CamelExtension
+    ActorSystem system = ActorSystem.create("some-system");
+    Camel camel = CamelExtension.get(system);
+    CamelContext camelContext = camel.context();
+    ProducerTemplate producerTemplate = camel.template();
+    //#CamelExtension
+    JavaTestKit.shutdownActorSystem(system);
+  }
+  public void addActiveMQComponent() {
+    //#CamelExtensionAddComponent
+    ActorSystem system = ActorSystem.create("some-system");
+    Camel camel = CamelExtension.get(system);
+    CamelContext camelContext = camel.context();
+    // camelContext.addComponent("activemq", ActiveMQComponent.activeMQComponent(
+    //   "vm://localhost?broker.persistent=false"));
+    //#CamelExtensionAddComponent
+      JavaTestKit.shutdownActorSystem(system);
+  }
+
+}

akka-docs/rst/java/code/jdocs/camel/Consumer1.java

@@ -0,0 +1,24 @@
+package jdocs.camel;
+//#Consumer1
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class Consumer1 extends UntypedConsumerActor {
+  LoggingAdapter log = Logging.getLogger(getContext().system(), this);
+
+  public String getEndpointUri() {
+    return "file:data/input/actor";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      log.info("Received message: {}", body);
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer1

akka-docs/rst/java/code/jdocs/camel/Consumer2.java

@@ -0,0 +1,20 @@
+package jdocs.camel;
+//#Consumer2
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class Consumer2 extends UntypedConsumerActor {
+  public String getEndpointUri() {
+    return "jetty:http://localhost:8877/camel/default";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      getSender().tell(String.format("Received message: %s",body), getSelf());
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer2

akka-docs/rst/java/code/jdocs/camel/Consumer3.java

@@ -0,0 +1,31 @@
+package jdocs.camel;
+//#Consumer3
+import akka.actor.Status;
+import akka.camel.Ack;
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class Consumer3 extends UntypedConsumerActor{
+
+  @Override
+  public boolean autoAck() {
+    return false;
+  }
+
+  public String getEndpointUri() {
+    return "jms:queue:test";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      getSender().tell(Ack.getInstance(), getSelf());
+      // on success
+      // ..
+      Exception someException = new Exception("e1");
+      // on failure
+      getSender().tell(new Status.Failure(someException), getSelf());
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer3

akka-docs/rst/java/code/jdocs/camel/Consumer4.java

@@ -0,0 +1,32 @@
+package jdocs.camel;
+//#Consumer4
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+import scala.concurrent.duration.Duration;
+import scala.concurrent.duration.FiniteDuration;
+
+import java.util.concurrent.TimeUnit;
+
+public class Consumer4 extends UntypedConsumerActor {
+  private final static FiniteDuration timeout =
+    Duration.create(500, TimeUnit.MILLISECONDS);
+
+  @Override
+  public FiniteDuration replyTimeout() {
+    return timeout;
+  }
+
+  public String getEndpointUri() {
+    return "jetty:http://localhost:8877/camel/default";
+  }
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      getSender().tell(String.format("Hello %s",body), getSelf());
+    } else
+      unhandled(message);
+  }
+}
+//#Consumer4

akka-docs/rst/java/code/jdocs/camel/CustomRouteBuilder.java

@@ -0,0 +1,18 @@
+package jdocs.camel;
+//#CustomRoute
+import akka.actor.ActorRef;
+import akka.camel.internal.component.CamelPath;
+import org.apache.camel.builder.RouteBuilder;
+
+public class CustomRouteBuilder extends RouteBuilder{
+  private String uri;
+
+  public CustomRouteBuilder(ActorRef responder) {
+    uri = CamelPath.toUri(responder);
+  }
+
+  public void configure() throws Exception {
+    from("jetty:http://localhost:8877/camel/custom").to(uri);
+  }
+}
+//#CustomRoute

akka-docs/rst/java/code/jdocs/camel/CustomRouteTestBase.java

@@ -0,0 +1,23 @@
+package jdocs.camel;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import akka.testkit.JavaTestKit;
+
+public class CustomRouteTestBase {
+  public void customRoute() throws Exception{
+    //#CustomRoute
+    ActorSystem system = ActorSystem.create("some-system");
+    try {
+      Camel camel = CamelExtension.get(system);
+      ActorRef responder = system.actorOf(Props.create(Responder.class), "TestResponder");
+      camel.context().addRoutes(new CustomRouteBuilder(responder));
+      //#CustomRoute
+    } finally {
+      JavaTestKit.shutdownActorSystem(system);
+    }
+  }
+}

akka-docs/rst/java/code/jdocs/camel/ErrorThrowingConsumer.java

@@ -0,0 +1,53 @@
+package jdocs.camel;
+//#ErrorThrowingConsumer
+import akka.actor.Status;
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+import akka.dispatch.Mapper;
+import org.apache.camel.builder.Builder;
+import org.apache.camel.model.ProcessorDefinition;
+import org.apache.camel.model.RouteDefinition;
+import scala.Option;
+
+public class ErrorThrowingConsumer extends UntypedConsumerActor{
+  private String uri;
+
+  private static Mapper<RouteDefinition, ProcessorDefinition<?>> mapper =
+    new Mapper<RouteDefinition, ProcessorDefinition<?>>() {
+      public ProcessorDefinition<?> apply(RouteDefinition rd) {
+        // Catch any exception and handle it by returning the exception message
+        // as response
+        return rd.onException(Exception.class).handled(true).
+          transform(Builder.exceptionMessage()).end();
+      }
+    };
+
+  public ErrorThrowingConsumer(String uri){
+    this.uri = uri;
+  }
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  public void onReceive(Object message) throws Exception{
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      String body = camelMessage.getBodyAs(String.class, getCamelContext());
+      throw new Exception(String.format("error: %s",body));
+    } else
+      unhandled(message);
+  }
+
+  @Override
+  public Mapper<RouteDefinition,
+    ProcessorDefinition<?>> getRouteDefinitionHandler() {
+    return mapper;
+  }
+
+  @Override
+  public void preRestart(Throwable reason, Option<Object> message) {
+    getSender().tell(new Status.Failure(reason), getSelf());
+  }
+}
+//#ErrorThrowingConsumer

akka-docs/rst/java/code/jdocs/camel/FirstProducer.java

@@ -0,0 +1,10 @@
+package jdocs.camel;
+
+//#Producer1
+import akka.camel.javaapi.UntypedProducerActor;
+public class FirstProducer extends UntypedProducerActor {
+  public String getEndpointUri() {
+    return "http://localhost:8080/news";
+  }
+}
+//#Producer1

akka-docs/rst/java/code/jdocs/camel/Forwarder.java

@@ -0,0 +1,24 @@
+package jdocs.camel;
+//#RouteResponse
+import akka.actor.ActorRef;
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Forwarder extends UntypedProducerActor {
+  private String uri;
+  private ActorRef target;
+
+  public Forwarder(String uri, ActorRef target) {
+    this.uri = uri;
+    this.target = target;
+  }
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  @Override
+  public void onRouteResponse(Object message) {
+    target.forward(message, getContext());
+  }
+}
+//#RouteResponse

akka-docs/rst/java/code/jdocs/camel/MyActor.java

@@ -0,0 +1,15 @@
+package jdocs.camel;
+//#ProducerTemplate
+import akka.actor.UntypedAbstractActor;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import org.apache.camel.ProducerTemplate;
+
+public class MyActor extends UntypedAbstractActor {
+  public void onReceive(Object message) {
+    Camel camel = CamelExtension.get(getContext().getSystem());
+    ProducerTemplate template = camel.template();
+    template.sendBody("direct:news", message);
+  }
+}
+//#ProducerTemplate

akka-docs/rst/java/code/jdocs/camel/MyEndpoint.java

@@ -0,0 +1,31 @@
+package jdocs.camel;
+
+//#Consumer-mina
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedConsumerActor;
+
+public class MyEndpoint extends UntypedConsumerActor{
+  private String uri;
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  public void onReceive(Object message) throws Exception {
+    if (message instanceof CamelMessage) {
+      /* ... */
+    } else
+      unhandled(message);
+  }
+
+  // Extra constructor to change the default uri,
+  // for instance to "jetty:http://localhost:8877/example"
+  public MyEndpoint(String uri) {
+    this.uri = uri;
+  }
+
+  public MyEndpoint() {
+    this.uri = "mina2:tcp://localhost:6200?textline=true";
+  }
+}
+//#Consumer-mina

akka-docs/rst/java/code/jdocs/camel/OnRouteResponseTestBase.java

@@ -0,0 +1,23 @@
+package jdocs.camel;
+
+import akka.actor.*;
+import akka.testkit.JavaTestKit;
+
+public class OnRouteResponseTestBase {
+
+  public void onRouteResponse(){
+    //#RouteResponse
+    ActorSystem system = ActorSystem.create("some-system");
+    Props receiverProps = Props.create(ResponseReceiver.class);
+    final ActorRef receiver = system.actorOf(receiverProps,"responseReceiver");
+    ActorRef forwardResponse = system.actorOf(Props.create(
+        Forwarder.class, "http://localhost:8080/news/akka", receiver));
+    // the Forwarder sends out a request to the web page and forwards the response to
+    // the ResponseReceiver
+    forwardResponse.tell("some request", ActorRef.noSender());
+    //#RouteResponse
+    system.stop(receiver);
+    system.stop(forwardResponse);
+    JavaTestKit.shutdownActorSystem(system);
+  }
+}

akka-docs/rst/java/code/jdocs/camel/OnewaySender.java

@@ -0,0 +1,20 @@
+package jdocs.camel;
+//#Oneway
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class OnewaySender extends UntypedProducerActor{
+  private String uri;
+
+  public OnewaySender(String uri) {
+    this.uri = uri;
+  }
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  @Override
+  public boolean isOneway() {
+    return true;
+  }
+}
+//#Oneway

akka-docs/rst/java/code/jdocs/camel/Orders.java

@@ -0,0 +1,10 @@
+package jdocs.camel;
+//#Producer
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Orders extends UntypedProducerActor {
+  public String getEndpointUri() {
+    return "jms:queue:Orders";
+  }
+}
+//#Producer

akka-docs/rst/java/code/jdocs/camel/Producer1.java

@@ -0,0 +1,10 @@
+package jdocs.camel;
+//#Producer1
+import akka.camel.javaapi.UntypedProducerActor;
+
+public class Producer1 extends UntypedProducerActor {
+  public String getEndpointUri() {
+    return "http://localhost:8080/news";
+  }
+}
+//#Producer1

akka-docs/rst/java/code/jdocs/camel/ProducerTestBase.java

@@ -0,0 +1,51 @@
+package jdocs.camel;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CompletionStage;
+
+import akka.testkit.JavaTestKit;
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.camel.CamelMessage;
+import akka.pattern.PatternsCS;
+
+public class ProducerTestBase {
+  public void tellJmsProducer() {
+    //#TellProducer
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = Props.create(Orders.class);
+    ActorRef producer = system.actorOf(props, "jmsproducer");
+    producer.tell("<order amount=\"100\" currency=\"PLN\" itemId=\"12345\"/>",
+        ActorRef.noSender());
+    //#TellProducer
+    JavaTestKit.shutdownActorSystem(system);
+  }
+
+  @SuppressWarnings("unused")
+  public void askProducer() {
+    //#AskProducer
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = Props.create(FirstProducer.class);
+    ActorRef producer = system.actorOf(props,"myproducer");
+    CompletionStage<Object> future = PatternsCS.ask(producer, "some request", 1000);
+    //#AskProducer
+    system.stop(producer);
+    JavaTestKit.shutdownActorSystem(system);
+  }
+
+  public void correlate(){
+    //#Correlate
+    ActorSystem system = ActorSystem.create("some-system");
+    Props props = Props.create(Orders.class);
+    ActorRef producer = system.actorOf(props,"jmsproducer");
+    Map<String,Object> headers = new HashMap<String, Object>();
+    headers.put(CamelMessage.MessageExchangeId(),"123");
+    producer.tell(new CamelMessage("<order amount=\"100\" currency=\"PLN\" " +
+      "itemId=\"12345\"/>",headers), ActorRef.noSender());
+    //#Correlate
+    system.stop(producer);
+    JavaTestKit.shutdownActorSystem(system);
+  }
+}

akka-docs/rst/java/code/jdocs/camel/RequestBodyActor.java

@@ -0,0 +1,20 @@
+package jdocs.camel;
+//#RequestProducerTemplate
+import akka.actor.AbstractActor;
+import akka.camel.Camel;
+import akka.camel.CamelExtension;
+import org.apache.camel.ProducerTemplate;
+
+public class RequestBodyActor extends AbstractActor {
+  @Override
+  public Receive createReceive() {
+    return receiveBuilder()
+      .matchAny(message -> {
+        Camel camel = CamelExtension.get(getContext().getSystem());
+        ProducerTemplate template = camel.template();
+        getSender().tell(template.requestBody("direct:news", message), getSelf());
+      })
+      .build();
+  }
+}
+//#RequestProducerTemplate

akka-docs/rst/java/code/jdocs/camel/Responder.java

@@ -0,0 +1,26 @@
+package jdocs.camel;
+//#CustomRoute
+import akka.actor.UntypedAbstractActor;
+import akka.camel.CamelMessage;
+import akka.dispatch.Mapper;
+
+public class Responder extends UntypedAbstractActor{
+
+  public void onReceive(Object message) {
+    if (message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      getSender().tell(createResponse(camelMessage), getSelf());
+    } else
+      unhandled(message);
+  }
+
+  private CamelMessage createResponse(CamelMessage msg) {
+    return msg.mapBody(new Mapper<String,String>() {
+      @Override
+      public String apply(String body) {
+        return String.format("received %s", body);
+      }
+    });
+  }
+}
+//#CustomRoute

akka-docs/rst/java/code/jdocs/camel/ResponseReceiver.java

@@ -0,0 +1,13 @@
+package jdocs.camel;
+//#RouteResponse
+import akka.actor.UntypedAbstractActor;
+import akka.camel.CamelMessage;
+
+public class ResponseReceiver extends UntypedAbstractActor{
+  public void onReceive(Object message) {
+     if(message instanceof CamelMessage) {
+       // do something with the forwarded response
+     }
+  }
+}
+//#RouteResponse

akka-docs/rst/java/code/jdocs/camel/Transformer.java

@@ -0,0 +1,37 @@
+package jdocs.camel;
+//#TransformOutgoingMessage
+import akka.camel.CamelMessage;
+import akka.camel.javaapi.UntypedProducerActor;
+import akka.dispatch.Mapper;
+
+public class Transformer extends UntypedProducerActor{
+  private String uri;
+
+  public Transformer(String uri) {
+    this.uri = uri;
+  }
+
+  public String getEndpointUri() {
+    return uri;
+  }
+
+  private CamelMessage upperCase(CamelMessage msg) {
+    return msg.mapBody(new Mapper<String,String>() {
+      @Override
+      public String apply(String body) {
+        return body.toUpperCase();
+      }
+    });
+  }
+
+  @Override
+  public Object onTransformOutgoingMessage(Object message) {
+    if(message instanceof CamelMessage) {
+      CamelMessage camelMessage = (CamelMessage) message;
+      return upperCase(camelMessage);
+    } else {
+      return message;
+    }
+  }
+}
+//#TransformOutgoingMessage