コード例 #1
0
  @SuppressWarnings("unchecked")
  abstract class MyActor {
    // #subscribe
    final ActorRef replicator = DistributedData.get(system).replicator();
    final Key<PNCounter> counter1Key = PNCounterKey.create("counter1");

    BigInteger currentValue = BigInteger.valueOf(0);

    public MyActor() {
      receive(
          ReceiveBuilder.match(
                  Changed.class,
                  a -> a.key().equals(counter1Key),
                  a -> {
                    Changed<PNCounter> g = a;
                    currentValue = g.dataValue().getValue();
                  })
              .match(
                  String.class,
                  a -> a.equals("get-count"),
                  a -> {
                    // incoming request to retrieve current value of the counter
                    sender().tell(currentValue, sender());
                  })
              .build());
    }

    public void preStart() {
      // subscribe to changes of the Counter1Key value
      replicator.tell(new Subscribe<PNCounter>(counter1Key, self()), ActorRef.noSender());
    }

    // #subscribe
  }
コード例 #2
0
  @Test
  public void demonstrateDelete() {
    probe = new JavaTestKit(system);

    // #delete
    final ActorRef replicator = DistributedData.get(system).replicator();
    final Key<PNCounter> counter1Key = PNCounterKey.create("counter1");
    final Key<ORSet<String>> set2Key = ORSetKey.create("set2");

    replicator.tell(new Delete<PNCounter>(counter1Key, Replicator.writeLocal()), self());

    final WriteConsistency writeMajority = new WriteMajority(Duration.create(5, SECONDS));
    replicator.tell(new Delete<PNCounter>(counter1Key, writeMajority), self());
    // #delete
  }
コード例 #3
0
  @SuppressWarnings("unchecked")
  @Test
  public void demonstrateGetWithRequestContext() {
    probe = new JavaTestKit(system);

    // #get-request-context
    final ActorRef replicator = DistributedData.get(system).replicator();
    final ReadConsistency readTwo = new ReadFrom(2, Duration.create(3, SECONDS));
    final Key<PNCounter> counter1Key = PNCounterKey.create("counter1");

    receive(
        ReceiveBuilder.match(
                String.class,
                a -> a.equals("get-count"),
                a -> {
                  // incoming request to retrieve current value of the counter
                  Optional<Object> reqContext = Optional.of(sender());
                  replicator.tell(new Replicator.Get<PNCounter>(counter1Key, readTwo), self());
                })
            .match(
                GetSuccess.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  ActorRef replyTo = (ActorRef) a.getRequest().get();
                  GetSuccess<PNCounter> g = a;
                  long value = g.dataValue().getValue().longValue();
                  replyTo.tell(value, self());
                })
            .match(
                GetFailure.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  ActorRef replyTo = (ActorRef) a.getRequest().get();
                  replyTo.tell(-1L, self());
                })
            .match(
                NotFound.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  ActorRef replyTo = (ActorRef) a.getRequest().get();
                  replyTo.tell(0L, self());
                })
            .build());
    // #get-request-context
  }
コード例 #4
0
  @Test
  public void demonstrateUpdateWithRequestContext() {
    probe = new JavaTestKit(system);

    // #update-request-context
    final Cluster node = Cluster.get(system);
    final ActorRef replicator = DistributedData.get(system).replicator();

    final WriteConsistency writeTwo = new WriteTo(2, Duration.create(3, SECONDS));
    final Key<PNCounter> counter1Key = PNCounterKey.create("counter1");

    receive(
        ReceiveBuilder.match(
                String.class,
                a -> a.equals("increment"),
                a -> {
                  // incoming command to increase the counter
                  Optional<Object> reqContext = Optional.of(sender());
                  Replicator.Update<PNCounter> upd =
                      new Replicator.Update<PNCounter>(
                          counter1Key,
                          PNCounter.create(),
                          writeTwo,
                          reqContext,
                          curr -> curr.increment(node, 1));
                  replicator.tell(upd, self());
                })
            .match(
                UpdateSuccess.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  ActorRef replyTo = (ActorRef) a.getRequest().get();
                  replyTo.tell("ack", self());
                })
            .match(
                UpdateTimeout.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  ActorRef replyTo = (ActorRef) a.getRequest().get();
                  replyTo.tell("nack", self());
                })
            .build());

    // #update-request-context
  }
コード例 #5
0
  @Test
  public void demonstrateUpdate() {
    probe = new JavaTestKit(system);

    // #update
    final Cluster node = Cluster.get(system);
    final ActorRef replicator = DistributedData.get(system).replicator();

    final Key<PNCounter> counter1Key = PNCounterKey.create("counter1");
    final Key<GSet<String>> set1Key = GSetKey.create("set1");
    final Key<ORSet<String>> set2Key = ORSetKey.create("set2");
    final Key<Flag> activeFlagKey = FlagKey.create("active");

    replicator.tell(
        new Replicator.Update<PNCounter>(
            counter1Key,
            PNCounter.create(),
            Replicator.writeLocal(),
            curr -> curr.increment(node, 1)),
        self());

    final WriteConsistency writeTo3 = new WriteTo(3, Duration.create(1, SECONDS));
    replicator.tell(
        new Replicator.Update<GSet<String>>(
            set1Key, GSet.create(), writeTo3, curr -> curr.add("hello")),
        self());

    final WriteConsistency writeMajority = new WriteMajority(Duration.create(5, SECONDS));
    replicator.tell(
        new Replicator.Update<ORSet<String>>(
            set2Key, ORSet.create(), writeMajority, curr -> curr.add(node, "hello")),
        self());

    final WriteConsistency writeAll = new WriteAll(Duration.create(5, SECONDS));
    replicator.tell(
        new Replicator.Update<Flag>(
            activeFlagKey, Flag.create(), writeAll, curr -> curr.switchOn()),
        self());
    // #update

    probe.expectMsgClass(UpdateSuccess.class);
    // #update-response1
    receive(
        ReceiveBuilder.match(
                UpdateSuccess.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  // ok
                })
            .build());
    // #update-response1

    // #update-response2
    receive(
        ReceiveBuilder.match(
                UpdateSuccess.class,
                a -> a.key().equals(set1Key),
                a -> {
                  // ok
                })
            .match(
                UpdateTimeout.class,
                a -> a.key().equals(set1Key),
                a -> {
                  // write to 3 nodes failed within 1.second
                })
            .build());
    // #update-response2
  }
コード例 #6
0
  @SuppressWarnings({"unused", "unchecked"})
  @Test
  public void demonstrateGet() {
    probe = new JavaTestKit(system);

    // #get
    final ActorRef replicator = DistributedData.get(system).replicator();
    final Key<PNCounter> counter1Key = PNCounterKey.create("counter1");
    final Key<GSet<String>> set1Key = GSetKey.create("set1");
    final Key<ORSet<String>> set2Key = ORSetKey.create("set2");
    final Key<Flag> activeFlagKey = FlagKey.create("active");

    replicator.tell(new Replicator.Get<PNCounter>(counter1Key, Replicator.readLocal()), self());

    final ReadConsistency readFrom3 = new ReadFrom(3, Duration.create(1, SECONDS));
    replicator.tell(new Replicator.Get<GSet<String>>(set1Key, readFrom3), self());

    final ReadConsistency readMajority = new ReadMajority(Duration.create(5, SECONDS));
    replicator.tell(new Replicator.Get<ORSet<String>>(set2Key, readMajority), self());

    final ReadConsistency readAll = new ReadAll(Duration.create(5, SECONDS));
    replicator.tell(new Replicator.Get<Flag>(activeFlagKey, readAll), self());
    // #get

    // #get-response1
    receive(
        ReceiveBuilder.match(
                GetSuccess.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  GetSuccess<PNCounter> g = a;
                  BigInteger value = g.dataValue().getValue();
                })
            .match(
                NotFound.class,
                a -> a.key().equals(counter1Key),
                a -> {
                  // key counter1 does not exist
                })
            .build());
    // #get-response1

    // #get-response2
    receive(
        ReceiveBuilder.match(
                GetSuccess.class,
                a -> a.key().equals(set1Key),
                a -> {
                  GetSuccess<GSet<String>> g = a;
                  Set<String> value = g.dataValue().getElements();
                })
            .match(
                GetFailure.class,
                a -> a.key().equals(set1Key),
                a -> {
                  // read from 3 nodes failed within 1.second
                })
            .match(
                NotFound.class,
                a -> a.key().equals(set1Key),
                a -> {
                  // key set1 does not exist
                })
            .build());
    // #get-response2

  }