@Override
 public ActorRef toActor(final ActorRefFactory context) {
   ActorRef ref = context.actorFor(stegklasse.getSimpleName());
   if (ref.isTerminated()) {
     if (understeg != null) {
       ref =
           context.actorOf(
               new Props(
                   new UntypedActorFactory() {
                     @Override
                     public Actor create() throws Exception {
                       return stegklasse
                           .getConstructor(ActorRef.class)
                           .newInstance(understeg.toActor(context));
                     }
                   }),
               stegklasse.getSimpleName());
     } else {
       ref = context.actorOf(new Props(stegklasse), stegklasse.getSimpleName());
     }
   }
   return ref;
 }
예제 #2
0
  public static void main(String[] args) throws Exception {

    ApplicationContext context = SpringApplication.run(App.class, args);

    ActorSystem system = context.getBean(ActorSystem.class);

    final LoggingAdapter log = Logging.getLogger(system, App.class.getSimpleName());

    log.info("Starting up");

    SpringExtension ext = context.getBean(SpringExtension.class);

    // Use the Spring Extension to create props for a named actor bean
    ActorRef calculator =
        system.actorOf(ext.props("calculator").withMailbox("akka.priority-mailbox"));

    /*
     * Create a completion service instance to await all futures
     */
    final ExecutionContext ec = system.dispatcher();

    Timeout timeout = new Timeout(120, TimeUnit.SECONDS);
    List<Long> ids = new ArrayList<>();

    ArrayList<Future<Object>> futures = new ArrayList<Future<Object>>();

    for (int i = 1; i <= 10; i++) {
      Future<Object> future = Patterns.ask(calculator, new CompilationRequest(i + " + 5"), timeout);
      future.onSuccess(
          new OnSuccess<Object>() {
            public void onSuccess(Object result) {
              if (result instanceof CompilationResult) {
                synchronized (ids) {
                  log.debug("Compilation result {} ", result.toString());
                  ids.add(((CompilationResult) result).getExpressionId());
                }
              } else {
                log.info("Compilation result is unknown type {} ", result.toString());
              }
            }
          },
          ec);
      futures.add(future);
    }

    Future<Iterable<Object>> seq = Futures.sequence(futures, ec);
    Await.result(seq, Duration.create(30, SECONDS));
    log.info("======================================================");
    log.info("Done waiting for compilations...{} ids", ids.size());
    log.info("======================================================");
    futures.clear();

    long start = System.nanoTime();
    List<Double> results = new ArrayList<>();

    Long count = 1_000_000L;
    for (long i = 1; i <= count; i++) {
      Future<Object> future =
          Patterns.ask(
              calculator,
              new CalculationRequest(i, ids.get((int) (i % ids.size())), null),
              timeout);
      future.onSuccess(
          new OnSuccess<Object>() {
            public void onSuccess(Object result) {
              if (result instanceof CalculationResult) {
                log.debug("Calculation result {} ", result.toString());
                //						synchronized(results)
                //						{
                //							results.add((Double) ((CalculationResult) result).getValue());
                //						}
              } else {
                log.info("Calculation result is unknown type {} ", result.toString());
              }
            }
          },
          ec);
      futures.add(future);
    }
    seq = Futures.sequence(futures, ec);
    Await.result(seq, Duration.create(600, SECONDS));
    calculator.tell(PoisonPill.getInstance(), null);

    while (!calculator.isTerminated()) {
      Thread.sleep(100);
    }

    long end = System.nanoTime();
    //        //int count = context.getBean(JdbcTemplate.class).queryForObject("SELECT COUNT(*) FROM
    // tasks", Integer.class);
    Long elapsed = TimeUnit.MILLISECONDS.convert((end - start), TimeUnit.NANOSECONDS);
    Double tps = count.doubleValue() / (elapsed.doubleValue() / Double.parseDouble("1000"));
    log.info("{} calculations in {}ms {}tps", count, elapsed, tps);
    log.info("Shutting down ------------------------------> {}", results.size());
    Thread.sleep(10000);
    system.shutdown();
    system.awaitTermination();
  }
예제 #3
0
  // FSM logic.
  @Override
  public void onReceive(final Object message) throws Exception {
    final Class<?> klass = message.getClass();
    final State state = fsm.state();
    final ActorRef sender = sender();

    if (logger.isInfoEnabled()) {
      logger.info(
          "********** Media Group " + self().path() + " Current State: \"" + state.toString());
      logger.info(
          "********** Media Group "
              + self().path()
              + " Processing Message: \""
              + klass.getName()
              + " sender : "
              + sender.getClass());
    }

    if (Observe.class.equals(klass)) {
      observe(message);
    } else if (StopObserving.class.equals(klass)) {
      stopObserving(message);
    } else if (MediaGroupStatus.class.equals(klass)) {
      if (active.equals(state)) {
        sender().tell(new MediaGroupStateChanged(MediaGroupStateChanged.State.ACTIVE), self());
      } else {
        sender().tell(new MediaGroupStateChanged(MediaGroupStateChanged.State.INACTIVE), self());
      }
    } else if (StartMediaGroup.class.equals(klass)) {
      if (logger.isInfoEnabled()) {
        logger.info(
            "MediaGroup: "
                + self().path()
                + " got StartMediaGroup from: "
                + sender().path()
                + " endpoint: "
                + endpoint.path()
                + " isTerminated: "
                + endpoint.isTerminated());
      }
      fsm.transition(message, acquiringIvr);
    } else if (Join.class.equals(klass)) {
      fsm.transition(message, acquiringInternalLink);
    } else if (MediaGatewayResponse.class.equals(klass)) {
      if (acquiringIvr.equals(state)) {
        fsm.transition(message, acquiringLink);
      } else if (acquiringLink.equals(state)) {
        fsm.transition(message, initializingLink);
      } else if (acquiringInternalLink.equals(state)) {
        fsm.transition(message, initializingInternalLink);
      }
    } else if (LinkStateChanged.class.equals(klass)) {
      final LinkStateChanged response = (LinkStateChanged) message;
      if (LinkStateChanged.State.CLOSED == response.state()) {
        if (initializingLink.equals(state)) {
          fsm.transition(message, openingLink);
        } else if (openingLink.equals(state)
            || deactivating.equals(state)
            || updatingLink.equals(state)) {
          fsm.transition(message, inactive);
        }
        if (initializingInternalLink.equals(state)) {
          fsm.transition(message, openingInternalLink);
        }
      } else if (LinkStateChanged.State.OPEN == response.state()) {
        if (openingLink.equals(state)) {
          fsm.transition(message, updatingLink);
        } else if (updatingLink.equals(state)) {
          fsm.transition(message, active);
        }
        if (openingInternalLink.equals(state)) {
          fsm.transition(message, updatingInternalLink);
        }
        if (updatingInternalLink.equals(state)) {
          fsm.transition(message, active);
        }
      }
    } else if (StopMediaGroup.class.equals(klass)) {
      if (acquiringLink.equals(state) || initializingLink.equals(state)) {
        fsm.transition(message, inactive);
      } else if (active.equals(state) || openingLink.equals(state) || updatingLink.equals(state)) {
        fsm.transition(message, deactivating);
      }
    } else if (EndpointStateChanged.class.equals(klass)) {
      onEndpointStateChanged((EndpointStateChanged) message, self(), sender);
    } else if (active.equals(state)) {
      if (Play.class.equals(klass)) {
        play(message);
      } else if (Collect.class.equals(klass)) {
        collect(message);
      } else if (Record.class.equals(klass)) {
        record(message);
      } else if (Stop.class.equals(klass)) {
        stop(lastEvent);
        // Send message to originator telling media group has been stopped
        // Needed for call bridging scenario, where inbound call must stop
        // ringing before attempting to perform join operation.
        sender().tell(new MediaGroupResponse<String>("stopped"), self());
      } else if (IvrEndpointResponse.class.equals(klass)) {
        notification(message);
      }
    } else if (ivrInUse) {
      if (Stop.class.equals(klass)) {
        stop(lastEvent);
      }
    }
  }