private void setOperational(final ActorIdentity pingResponse) {

    if (mediaQueue == null && IDENTIFY_MEDIA_QUEUE_ID.equals(pingResponse.correlationId())) {
      mediaQueue = pingResponse.getRef();
    }

    if (mediaDecoder == null && IDENTIFY_MEDIA_DECODER_ID.equals(pingResponse.correlationId())) {
      mediaDecoder = pingResponse.getRef();
    }

    if (mediaQueue != null && mediaDecoder != null) {
      getContext()
          .become(
              ReceiveBuilder.match(ImageSegment.class, msg -> build(msg))
                  .match(ImageData.class, msg -> breakDown(msg))
                  .match(AudioData.class, msg -> handleCommon(msg, mediaQueue))
                  .match(FrameRate.class, msg -> handleCommon(msg, mediaQueue))
                  .match(Play.class, msg -> handleCommon(msg, mediaQueue, mediaDecoder))
                  .match(Pause.class, msg -> handleCommon(msg, mediaQueue, mediaDecoder))
                  .match(Connect.class, msg -> handleConnect(msg))
                  .match(JoinRequest.class, msg -> handleRequest(msg))
                  .match(JoinAck.class, msg -> handleAck(msg))
                  .match(NewMember.class, msg -> handleNewMember(msg))
                  .build());
    }
  }
Exemplo n.º 2
0
 public GenericActor() {
   receive(
       ReceiveBuilder.match(
               GenericMessage.class,
               (GenericMessage<String> msg) -> {
                 GenericMessage<String> message = msg;
                 sender().tell(message.value.toUpperCase(), self());
               })
           .build());
 }
Exemplo n.º 3
0
 public MessageInitExample() {
   // #messageInit
   receive(
       ReceiveBuilder.matchEquals(
               "init",
               m1 -> {
                 initializeMe = "Up and running";
                 context()
                     .become(
                         ReceiveBuilder.matchEquals(
                                 "U OK?",
                                 m2 -> {
                                   sender().tell(initializeMe, self());
                                 })
                             .build());
               })
           .build()
       // #messageInit
       );
 }
Exemplo n.º 4
0
    public GenericActorWithPredicate() {
      FI.TypedPredicate<GenericMessage<String>> typedPredicate = s -> !s.value.isEmpty();

      receive(
          ReceiveBuilder.match(
                  GenericMessage.class,
                  typedPredicate,
                  (GenericMessage<String> msg) -> {
                    sender().tell(msg.value.toUpperCase(), self());
                  })
              .build());
    }
Exemplo n.º 5
0
 public Terminator(ActorRef ref) {
   this.ref = ref;
   getContext().watch(ref);
   receive(
       ReceiveBuilder.match(
               Terminated.class,
               t -> {
                 log().info("{} has terminated, shutting down system", ref.path());
                 context().system().terminate();
               })
           .build());
 }
Exemplo n.º 6
0
 public EventEndpointActor(
     BrickStateEventDispatcher brickStateEventDispatcher, ProjectRepository projectRepository) {
   receive(
       ReceiveBuilder.match(EventMsg.class, msg -> {})
           .match(
               BrickStateEvent.class,
               msg -> {
                 LOGGER.debug("Receive  BrickStateEvent to BrickStateEventPersistenceActor.");
                 getContext()
                     .actorOf(BrickStateEventPersistenceActor.PROPS(projectRepository))
                     .forward(msg, getContext());
                 brickStateEventDispatcher.receive(
                     msg); // Legacy, must be removed when migrate WebsoketEntrypoint.
               })
           .matchAny(this::unhandled)
           .build());
 }
Exemplo n.º 7
0
 @Override
 public PartialFunction<Object, BoxedUnit> receive() {
   return ReceiveBuilder.match(NewNumberCalculationMessage.class, this::log, this::queueNewMessage)
       .match(RegisterForNotifications.class, this::log, this::registerNewSSESubscription)
       .match(
           Worker.CalculationStarted.class,
           this::log,
           m -> recordStateChange(m.getTaskId(), Status.STARTED))
       .match(
           Worker.CalculationFinished.class,
           this::log,
           m -> recordStateChange(m.getTaskId(), Status.FINISHED))
       .match(GetTaskStatusMessage.class, this::log, this::handleGet)
       .match(DistributedPubSubMediator.SubscribeAck.class, m -> logSubscribeAck())
       .matchAny(this::unhandled)
       .build();
 }
Exemplo n.º 8
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
  }
Exemplo n.º 9
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
  }
Exemplo n.º 10
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());
 }
  private MediaTransportWorker(final int instance) {

    this.instance = instance;

    segments = new HashMap<>();
    mediaQueue = null;
    mediaDecoder = null;
    others = new LinkedList<>();
    id = Integer.MIN_VALUE;

    getContext()
        .actorSelection("../../" + ActorConstants.MEDIA_QUEUE_NAME)
        .tell(new Identify(IDENTIFY_MEDIA_QUEUE_ID), self());
    getContext()
        .actorSelection("../../" + ActorConstants.MEDIA_DECODER_NAME)
        .tell(new Identify(IDENTIFY_MEDIA_DECODER_ID), self());

    receive(ReceiveBuilder.match(ActorIdentity.class, msg -> setOperational(msg)).build());
  }
Exemplo n.º 12
0
    public WorkerNode(InetAddress address, FiniteDuration checkInterval) {
      checkTimer =
          getContext()
              .system()
              .scheduler()
              .schedule(
                  checkInterval,
                  checkInterval,
                  self(),
                  DoHealthCheck.instance,
                  getContext().dispatcher(),
                  self());

      List<WorkerNodeMessage> msgs = new ArrayList<>();
      receive(
          ReceiveBuilder.match(WorkerNodeMessage.class, msgs::add)
              .match(
                  DoHealthCheck.class,
                  dhc -> {
                    /* perform check */
                  })
              .match(
                  Shutdown.class,
                  s -> {
                    msgs.stream()
                        .forEach(
                            msg ->
                                msg.replyTo()
                                    .tell(
                                        new WorkerCommandFailed("shutting down", msg.id()),
                                        self()));
                    /* ask Resource Pool to shut down this instance */
                  })
              .match(
                  WorkerNodeReady.class,
                  wnr -> {
                    /* send msgs to the worker */
                    getContext().become(initialized());
                  })
              .build());
    }
Exemplo n.º 13
0
 @Override
 public PartialFunction<Object, BoxedUnit> receiveCommand() {
   return ReceiveBuilder.match(
           String.class,
           s -> s.equals("boom"),
           s -> {
             throw new RuntimeException("boom");
           })
       .match(
           String.class, s -> s.equals("print"), s -> System.out.println("received " + received))
       .match(
           String.class,
           s -> {
             persist(
                 s,
                 evt -> {
                   received.add(evt);
                 });
           })
       .build();
 }
Exemplo n.º 14
0
 public Master() {
   final ActorRef reader = getContext().actorOf(Props.create(FileReader.class), "fileReader");
   final ActorRef writer = getContext().actorOf(Props.create(FileWriter.class), "fileWriter");
   receive(
       ReceiveBuilder.match(
               ReadFile.class,
               readFile -> {
                 reader.tell(new GetMap(), self());
               })
           .match(
               Result.class,
               result -> {
                 writer.tell(result, self());
               })
           .match(
               End.class,
               end -> {
                 context().system().shutdown();
               })
           .build());
 }
Exemplo n.º 15
0
 @Override
 public PartialFunction<Object, BoxedUnit> receive() {
   return ReceiveBuilder.match(
           Waiter.DrinkServered.class,
           ds -> {
             drinkCount += 1;
             log().info("Enjoying my {}. yummy {}!", drinkCount, favoriteDrink);
             System.out.println(">>>>>>>>> " + maxDrinkCount);
             scheduleCoffeeFinished();
           })
       .match(
           DrinkFinished.class,
           d -> {
             if (drinkCount > maxDrinkCount) {
               throw new DrunkException();
             } else {
               waiter.tell(new Waiter.ServeDrink(favoriteDrink), self());
             }
           })
       .build();
 }
Exemplo n.º 16
0
 public EmailSenderActor(EmailSender emailSender) {
   if (emailSender == null) {
     throw new IllegalArgumentException("emailSender must be defined.");
   }
   receive(
       ReceiveBuilder.match(
               EmailSenderMsg.class,
               msg -> {
                 try {
                   emailSender.send(
                       msg.to,
                       msg.cc,
                       msg.ci,
                       msg.object,
                       msg.content,
                       msg.htmlContent,
                       msg.attachments);
                 } catch (RuntimeException e) {
                   LOGGER.error(
                       "Unable to sent email to '{}', with subject '{}'",
                       Arrays.toString(msg.to.toArray()),
                       msg.object,
                       e);
                   sender().tell(Futures.failed(e), self());
                 }
                 if (LOGGER.isDebugEnabled()) {
                   LOGGER.debug(
                       "Email sent to '{}' with subject '{}'",
                       Arrays.toString(msg.to.toArray()),
                       msg.object);
                 }
                 getContext().stop(self());
               })
           .matchAny(this::unhandled)
           .build());
 }
Exemplo n.º 17
0
  /* (non-Javadoc)
   * @see akka.actor.AbstractActor#receive()
   */
  @Override
  public PartialFunction<Object, BoxedUnit> receive() {
    return ReceiveBuilder.match(
            BucketActionMessage.class,
            m ->
                !m.handling_clients().isEmpty()
                    && !m.handling_clients()
                        .contains(_context.getInformationService().getHostname()),
            __ -> {}) // (do nothing if it's not for me)
        .match(
            BucketActionOfferMessage.class,
            m -> {
              _logger.info(
                  ErrorUtils.get(
                      "Actor {0} received message {1} from {2} bucket {3}",
                      this.self(),
                      m.getClass().getSimpleName(),
                      this.sender(),
                      m.bucket().full_name()));

              final ActorRef closing_sender = this.sender();
              final ActorRef closing_self = this.self();

              final String hostname = _context.getInformationService().getHostname();

              // (this isn't async so doesn't require any futures)

              final boolean accept_or_ignore =
                  new File(_globals.local_yarn_config_dir() + File.separator + "storm.yaml")
                      .exists();

              final BucketActionReplyMessage reply =
                  accept_or_ignore
                      ? new BucketActionReplyMessage.BucketActionWillAcceptMessage(hostname)
                      : new BucketActionReplyMessage.BucketActionIgnoredMessage(hostname);

              closing_sender.tell(reply, closing_self);
            })
        .match(
            BucketActionMessage.class,
            m -> {
              _logger.info(
                  ErrorUtils.get(
                      "Actor {0} received message {1} from {2} bucket={3}",
                      this.self(),
                      m.getClass().getSimpleName(),
                      this.sender(),
                      m.bucket().full_name()));

              final ActorRef closing_sender = this.sender();
              final ActorRef closing_self = this.self();

              final String hostname = _context.getInformationService().getHostname();

              // (cacheJars can't throw checked or unchecked in this thread, only from within
              // exceptions)
              cacheJars(
                      m.bucket(),
                      _management_db,
                      _globals,
                      _fs,
                      _context.getServiceContext(),
                      hostname,
                      m)
                  .thenComposeAsync(
                      err_or_map -> {
                        final StreamingEnrichmentContext e_context =
                            _context.getNewStreamingEnrichmentContext();

                        final Validation<BasicMessageBean, IEnrichmentStreamingTopology>
                            err_or_tech_module =
                                getStreamingTopology(m.bucket(), m, hostname, err_or_map);

                        final CompletableFuture<BucketActionReplyMessage> ret =
                            talkToStream(
                                _storm_controller,
                                m.bucket(),
                                m,
                                err_or_tech_module,
                                err_or_map,
                                hostname,
                                e_context,
                                _globals.local_yarn_config_dir(),
                                _globals.local_cached_jar_dir());
                        return ret;
                      })
                  .thenAccept(
                      reply -> { // (reply can contain an error or successful reply, they're the
                        // same bean type)
                        // Some information logging:
                        Patterns.match(reply)
                            .andAct()
                            .when(
                                BucketActionHandlerMessage.class,
                                msg ->
                                    _logger.info(
                                        ErrorUtils.get(
                                            "Standard reply to message={0}, bucket={1}, success={2}",
                                            m.getClass().getSimpleName(),
                                            m.bucket().full_name(),
                                            msg.reply().success())))
                            .when(
                                BucketActionReplyMessage.BucketActionWillAcceptMessage.class,
                                msg ->
                                    _logger.info(
                                        ErrorUtils.get(
                                            "Standard reply to message={0}, bucket={1}",
                                            m.getClass().getSimpleName(), m.bucket().full_name())))
                            .otherwise(
                                msg ->
                                    _logger.info(
                                        ErrorUtils.get(
                                            "Unusual reply to message={0}, type={2}, bucket={1}",
                                            m.getClass().getSimpleName(),
                                            m.bucket().full_name(),
                                            msg.getClass().getSimpleName())));

                        closing_sender.tell(reply, closing_self);
                      })
                  .exceptionally(
                      e -> { // another bit of error handling that shouldn't ever be called but is a
                        // useful backstop
                        // Some information logging:
                        _logger.warn(
                            "Unexpected error replying to '{0}': error = {1}, bucket={2}",
                            BeanTemplateUtils.toJson(m).toString(),
                            ErrorUtils.getLongForm("{0}", e),
                            m.bucket().full_name());

                        final BasicMessageBean error_bean =
                            SharedErrorUtils.buildErrorMessage(
                                hostname,
                                m,
                                ErrorUtils.getLongForm(
                                    StreamErrorUtils.STREAM_UNKNOWN_ERROR,
                                    e,
                                    m.bucket().full_name()));
                        closing_sender.tell(
                            new BucketActionHandlerMessage(hostname, error_bean), closing_self);
                        return null;
                      });
            })
        .build();
  }
Exemplo n.º 18
0
 public PaintRedActor() {
   receive(
       ReceiveBuilder.match(Car.class, this::paint)
           .match(CountRequest.class, this::sendCount)
           .build());
 }
Exemplo n.º 19
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

  }
Exemplo n.º 20
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
  }
Exemplo n.º 21
0
  public WebsocketTransport(Messages.JoinWebsocket join) {
    this.out = join.out;
    this.in = join.in;
    this.context = join.context;

    final ActorRef self = getContext().self();

    in.onClose(
        () -> {
          signalJActor.tell(new Messages.Quit(context.connectionId), self);
          self.tell(PoisonPill.getInstance(), self);
        });
    in.onMessage(
        json -> {
          Logger.debug("Message from user: "******" : " + json);
          signalJActor.tell(new Messages.Execute(context, json), self);
        });

    context()
        .setReceiveTimeout(
            Duration.create(
                SignalJPlugin.getConfiguration().getKeepAliveTimeout() / 2, TimeUnit.SECONDS));

    receive(
        ReceiveBuilder.match(
                Messages.JoinWebsocket.class, r -> out.write(JsonHelper.writeConnect(prefix)))
            .match(
                Messages.MethodReturn.class,
                methodReturn -> {
                  out.write(JsonHelper.writeMethodReturn(methodReturn));
                  sendAck(methodReturn);
                })
            .match(
                Messages.ClientFunctionCall.class,
                clientFunctionCall -> {
                  out.write(JsonHelper.writeClientFunctionCall(clientFunctionCall, prefix));
                  sendAck(clientFunctionCall);
                })
            .match(
                Messages.ClientCallEnd.class,
                clientCallEnd -> {
                  out.write(JsonHelper.writeConfirm(clientCallEnd.context));
                  sendAck(clientCallEnd);
                })
            .match(ReceiveTimeout.class, r -> out.write(JsonHelper.writeHeartbeat()))
            .match(
                Messages.ReconnectWebsocket.class,
                r -> Logger.debug("Reconnect Websocket " + r.context.connectionId))
            .match(
                Messages.StateChange.class,
                state -> {
                  out.write(JsonHelper.writeState(state));
                  sendAck(state);
                })
            .match(
                Messages.Error.class,
                error -> {
                  out.write(JsonHelper.writeError(error));
                  sendAck(error);
                })
            .build());
  }
Exemplo n.º 22
0
 @Override
 public PartialFunction<Object, BoxedUnit> receiveRecover() {
   return ReceiveBuilder.match(String.class, s -> received.add(s)).build();
 }