pekko/akka-docs/src/test/java/jdocs/stream/FlowStreamRefsDocTest.java

/*
 * Copyright (C) 2015-2019 Lightbend Inc. <https://www.lightbend.com>
 */

package jdocs.stream;

import akka.NotUsed;
import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.pattern.Patterns;
import akka.stream.*;
import akka.stream.javadsl.*;
import akka.testkit.javadsl.TestKit;
import jdocs.AbstractJavaTest;
import org.junit.Test;
import scala.concurrent.duration.FiniteDuration;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.CompletionStage;

public class FlowStreamRefsDocTest extends AbstractJavaTest {

  static ActorSystem system = null;
  static Materializer mat = null;

  @Test
  public void compileOnlySpec() {
    // do nothing
  }

  //#offer-source
  static class RequestLogs {
    public final long streamId;

    public RequestLogs(long streamId) {
      this.streamId = streamId;
    }
  }

  static class LogsOffer {
    final SourceRef<String> sourceRef;

    public LogsOffer(SourceRef<String> sourceRef) {
      this.sourceRef = sourceRef;
    }
  }

  static class DataSource extends AbstractActor {
    @Override
    public Receive createReceive() {
      return receiveBuilder()
          .match(RequestLogs.class, this::handleRequestLogs)
          .build();
    }

    private void handleRequestLogs(RequestLogs requestLogs) {
      Source<String, NotUsed> logs = streamLogs(requestLogs.streamId);
      CompletionStage<SourceRef<String>> logsRef = logs.runWith(StreamRefs.sourceRef(), mat);

      Patterns.pipe(logsRef.thenApply(ref -> new LogsOffer(ref)), context().dispatcher())
          .to(sender());
    }

    private Source<String, NotUsed> streamLogs(long streamId) {
      return Source.repeat("[INFO] some interesting logs here (for id: " + streamId + ")");
    }
  }
  //#offer-source

  public void offerSource() {
    new TestKit(system) {{

      //#offer-source-use
      ActorRef sourceActor = system.actorOf(Props.create(DataSource.class), "dataSource");

      sourceActor.tell(new RequestLogs(1337), getTestActor());
      LogsOffer offer = expectMsgClass(LogsOffer.class);

      offer.sourceRef.getSource()
          .runWith(Sink.foreach(log -> System.out.println(log)), mat);

      //#offer-source-use
    }};
  }

  //#offer-sink
  static class PrepareUpload {
    final String id;

    public PrepareUpload(String id) {
      this.id = id;
    }
  }
  static class MeasurementsSinkReady {
    final String id;
    final SinkRef<String> sinkRef;

    public MeasurementsSinkReady(String id, SinkRef<String> ref) {
      this.id = id;
      this.sinkRef = ref;
    }
  }

  static class DataReceiver extends AbstractActor {
    @Override
    public Receive createReceive() {
      return receiveBuilder()
          .match(PrepareUpload.class, prepare -> {
            Sink<String, NotUsed> sink = logsSinkFor(prepare.id);
            CompletionStage<SinkRef<String>> sinkRef = StreamRefs.<String>sinkRef().to(sink).run(mat);

            Patterns.pipe(sinkRef.thenApply(ref -> new MeasurementsSinkReady(prepare.id, ref)), context().dispatcher())
                .to(sender());
          })
          .build();
    }

    private Sink<String, NotUsed> logsSinkFor(String id) {
      return Sink.<String>ignore().mapMaterializedValue(done -> NotUsed.getInstance());
    }
  }
  //#offer-sink

  public void offerSink() {
    new TestKit(system) {{

      //#offer-sink-use
      ActorRef receiver = system.actorOf(Props.create(DataReceiver.class), "dataReceiver");

      receiver.tell(new PrepareUpload("system-42-tmp"), getTestActor());
      MeasurementsSinkReady ready = expectMsgClass(MeasurementsSinkReady.class);

      Source.repeat("hello")
          .runWith(ready.sinkRef.getSink(), mat);
      //#offer-sink-use
    }};
  }

  public void configureTimeouts() {
    new TestKit(system) {{

      //#attr-sub-timeout
      FiniteDuration timeout = FiniteDuration.create(5, TimeUnit.SECONDS);
      Attributes timeoutAttributes = StreamRefAttributes.subscriptionTimeout(timeout);

      // configuring Sink.sourceRef (notice that we apply the attributes to the Sink!):
      Source.repeat("hello")
          .runWith(StreamRefs.<String>sourceRef().addAttributes(timeoutAttributes), mat);

      // configuring SinkRef.source:
      StreamRefs.<String>sinkRef().addAttributes(timeoutAttributes)
          .runWith(Sink.<String>ignore(), mat); // not very interesting sink, just an example

      //#attr-sub-timeout
    }};
  }

}