pekko/akka-docs/rst/java/code/docs/io/UdpDocTest.java

/**
 * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
 */

package docs.io;

//#imports
import akka.actor.ActorRef;
import akka.actor.PoisonPill;
import akka.actor.AbstractActor;
import akka.io.Udp;
import akka.io.UdpConnected;
import akka.io.UdpConnectedMessage;
import akka.io.UdpMessage;
import akka.japi.Procedure;
import akka.util.ByteString;

import java.net.InetSocketAddress;
//#imports

public class UdpDocTest {

  //#sender
  public static class SimpleSender extends AbstractActor {
    final InetSocketAddress remote;

    public SimpleSender(InetSocketAddress remote) {
      this.remote = remote;
      
      // request creation of a SimpleSender
      final ActorRef mgr = Udp.get(getContext().system()).getManager();
      mgr.tell(UdpMessage.simpleSender(), self());
    }
    
    @Override
    public Receive createReceive() {
      return receiveBuilder()
        .match(Udp.SimpleSenderReady.class, message -> {
          getContext().become(ready(sender()));
          //#sender
          sender().tell(UdpMessage.send(ByteString.fromString("hello"), remote), self());
          //#sender
        })
        .build();
    }

    private Receive ready(final ActorRef send) {
      return receiveBuilder()
        .match(String.class, message -> {
          send.tell(UdpMessage.send(ByteString.fromString(message), remote), self());
          //#sender
          if (message.equals("world")) {
            send.tell(PoisonPill.getInstance(), self());
          }
          //#sender
        })
        .build();
    }
  }
  //#sender
  
  //#listener
  public static class Listener extends AbstractActor {
    final ActorRef nextActor;

    public Listener(ActorRef nextActor) {
      this.nextActor = nextActor;
      
      // request creation of a bound listen socket
      final ActorRef mgr = Udp.get(getContext().system()).getManager();
      mgr.tell(
          UdpMessage.bind(self(), new InetSocketAddress("localhost", 0)),
          self());
    }

    @Override
    public Receive createReceive() {
      return receiveBuilder()
        .match(Udp.Bound.class, bound -> {
          //#listener
          nextActor.tell(bound.localAddress(), sender());
          //#listener
          getContext().become(ready(sender()));
        })
        .build();
    }

    private Receive ready(final ActorRef socket) {
      return receiveBuilder()
        .match(Udp.Received.class, r -> {
          // echo server example: send back the data
          socket.tell(UdpMessage.send(r.data(), r.sender()), self());
          // or do some processing and forward it on
          final Object processed = // parse data etc., e.g. using PipelineStage
          // #listener
          r.data().utf8String();
          //#listener
          nextActor.tell(processed, self());
        })
        .matchEquals(UdpMessage.unbind(), message -> {
          socket.tell(message, self());
        })
        .match(Udp.Unbound.class, message -> {
          getContext().stop(self());
        })
        .build();
    }
  }
  //#listener
  
  //#connected
  public static class Connected extends AbstractActor  {
    final InetSocketAddress remote;

    public Connected(InetSocketAddress remote) {
      this.remote = remote;
      
      // create a restricted a.k.a. “connected” socket
      final ActorRef mgr = UdpConnected.get(getContext().system()).getManager();
      mgr.tell(UdpConnectedMessage.connect(self(), remote), self());
    }

    @Override
    public Receive createReceive() {
      return receiveBuilder()
        .match(UdpConnected.Connected.class, message -> {
          getContext().become(ready(sender()));
          //#connected
          sender()
            .tell(UdpConnectedMessage.send(ByteString.fromString("hello")),
              self());
          //#connected
        })
        .build();
    }

    private Receive ready(final ActorRef connection) {
      return receiveBuilder()
        .match(UdpConnected.Received.class, r -> {
          // process data, send it on, etc.
          // #connected
          if (r.data().utf8String().equals("hello")) {
            connection.tell(
              UdpConnectedMessage.send(ByteString.fromString("world")),
              self());
          }
          // #connected
        })
        .match(String.class, str -> {
          connection
            .tell(UdpConnectedMessage.send(ByteString.fromString(str)),
              self());
        })
        .matchEquals(UdpConnectedMessage.disconnect(), message -> {
          connection.tell(message, self());
        })
        .match(UdpConnected.Disconnected.class, x -> {
          getContext().stop(self());
        })
        .build();
    }
  }
  //#connected

}