コード例 #1
0
    @Override
    public void run() {
      if (System.currentTimeMillis() > expiryTime) {
        scheduledExecutorService.shutdown();
        throw new RuntimeException(
            "failed to discover beans: " + managedTypes.getServiceEndpoints());
      }

      if (registered.isEmpty()) {
        scheduledExecutorService.shutdown();
        log.info("all services registered successfully");
        return;
      }

      for (final AnnotatedType<?> type : managedTypes.getServiceEndpoints()) {
        if (!registered.contains(type) || beanManager.getBeans(type.getJavaClass()).size() == 0) {
          continue;
        }

        final MessageCallback callback =
            (MessageCallback) CDIServerUtil.lookupBean(beanManager, type.getJavaClass());

        registered.remove(type);

        // Discriminate on @Command
        final Map<String, Method> commandPoints = new HashMap<String, Method>();
        for (final AnnotatedMethod method : type.getMethods()) {
          if (method.isAnnotationPresent(Command.class)) {
            final Command command = method.getAnnotation(Command.class);
            for (String cmdName : command.value()) {
              if (cmdName.equals("")) cmdName = method.getJavaMember().getName();
              commandPoints.put(cmdName, method.getJavaMember());
            }
          }
        }

        final String subjectName = CDIServerUtil.resolveServiceName(type.getJavaClass());

        if (commandPoints.isEmpty()) {
          bus.subscribe(subjectName, callback);
        } else {
          bus.subscribeLocal(
              subjectName, new CommandBindingsCallback(commandPoints, callback, bus));
        }
      }
    }
コード例 #2
0
  private void createRPCScaffolding(
      final Class remoteIface, final MessageBus bus, final BeanManager beanManager) {
    final Map<String, MessageCallback> epts = new HashMap<String, MessageCallback>();

    // beware of classloading issues. better reflect on the actual instance
    for (final Method method : remoteIface.getMethods()) {
      if (ProxyUtil.isMethodInInterface(remoteIface, method)) {

        epts.put(
            ProxyUtil.createCallSignature(remoteIface, method),
            new ConversationalEndpointCallback(
                new ServiceInstanceProvider() {
                  @SuppressWarnings("unchecked")
                  @Override
                  public Object get(final Message message) {
                    if (message.hasPart(CDIProtocol.Qualifiers)) {
                      final List<String> quals = message.get(List.class, CDIProtocol.Qualifiers);
                      final Annotation[] qualAnnos = new Annotation[quals.size()];
                      for (int i = 0; i < quals.size(); i++) {
                        qualAnnos[i] = beanQualifiers.get(quals.get(i));
                      }
                      return lookupRPCBean(beanManager, remoteIface, qualAnnos);
                    } else {
                      return lookupRPCBean(beanManager, remoteIface, null);
                    }
                  }
                },
                method,
                bus));
      }
    }

    final RemoteServiceCallback delegate = new RemoteServiceCallback(epts);
    bus.subscribe(
        remoteIface.getName() + ":RPC",
        new MessageCallback() {
          @Override
          public void callback(final Message message) {
            delegate.callback(message);
          }
        });

    log.debug("registered RPC service for: " + remoteIface.getName());

    // note: this method just exists because we want AbstractRemoteCallBuilder to be package
    // private.
    DefaultRemoteCallBuilder.setProxyFactory(
        Assert.notNull(
            new ProxyFactory() {
              @Override
              public <T> T getRemoteProxy(final Class<T> proxyType) {
                throw new RuntimeException(
                    "There is not yet an available Errai RPC implementation for the server-side environment.");
              }
            }));
  }
コード例 #3
0
 private void setup() {
   bus.unsubscribeAll(SUCCESS);
   bus.unsubscribeAll(FAILURE);
   bus.subscribe(
       SUCCESS,
       new MessageCallback() {
         @Override
         public void callback(Message message) {
           finishTest();
         }
       });
   bus.subscribe(
       FAILURE,
       new MessageCallback() {
         @Override
         public void callback(Message message) {
           fail();
         }
       });
 }
コード例 #4
0
  @SuppressWarnings({"UnusedDeclaration", "CdiInjectionPointsInspection"})
  public void afterBeanDiscovery(@Observes final AfterBeanDiscovery abd, final BeanManager bm) {
    final ErraiService service = ErraiServiceSingleton.getService();
    final MessageBus bus = service.getBus();
    final EventRoutingTable eventRoutingTable = new EventRoutingTable();

    if (bus.isSubscribed(CDI.SERVER_DISPATCHER_SUBJECT)) {
      return;
    }

    final byte[] randBytes = new byte[32];
    final Random random = new Random(System.currentTimeMillis());

    random.nextBytes(randBytes);

    abd.addBean(new ErraiServiceBean(bm, SecureHashUtil.hashToHexString(randBytes)));

    for (final MessageSender ms : messageSenders) {
      abd.addBean(new SenderBean(ms.getSenderType(), ms.getQualifiers(), bus));
    }

    // Errai bus injection
    abd.addBean(new MessageBusBean(bus));

    // Support to inject the request dispatcher.
    abd.addBean(new RequestDispatcherMetaData(bm, service.getDispatcher()));

    // Register observers
    abd.addObserverMethod(new ShutdownEventObserver(managedTypes, bus));

    // subscribe service and rpc endpoints
    subscribeServices(bm, bus);

    final EventDispatcher eventDispatcher =
        new EventDispatcher(bm, eventRoutingTable, bus, observableEvents, eventQualifiers, abd);

    // subscribe event dispatcher
    bus.subscribe(CDI.SERVER_DISPATCHER_SUBJECT, eventDispatcher);
  }
コード例 #5
0
  private void subscribeServices(final BeanManager beanManager, final MessageBus bus) {
    for (final Map.Entry<AnnotatedType, List<AnnotatedMethod>> entry :
        managedTypes.getServiceMethods().entrySet()) {
      final Class<?> type = entry.getKey().getJavaClass();

      for (final AnnotatedMethod method : entry.getValue()) {
        final Service svc = method.getAnnotation(Service.class);
        final String svcName =
            svc.value().equals("") ? method.getJavaMember().getName() : svc.value();

        final Method callMethod = method.getJavaMember();

        bus.subscribe(
            svcName,
            new MessageCallback() {

              @Override
              public void callback(final Message message) {
                final Object targetBean = CDIServerUtil.lookupBean(beanManager, type);

                try {
                  callMethod.invoke(targetBean, message);
                } catch (Exception e) {
                  ErrorHelper.sendClientError(bus, message, "Error dispatching service", e);
                }
              }
            });
      }
    }

    /**
     * Due to the lack of contract in CDI guaranteeing when beans will be available, we use an
     * executor to search for the beans every 100ms until it finds them. Or, after a 25 seconds,
     * blow up if they don't become available.
     */
    final ScheduledExecutorService startupScheduler = Executors.newScheduledThreadPool(1);
    startupScheduler.scheduleAtFixedRate(
        new StartupCallback(beanManager, bus, startupScheduler, 25), 0, 100, TimeUnit.MILLISECONDS);

    for (final Class<?> remoteInterfaceType : managedTypes.getRemoteInterfaces()) {
      createRPCScaffolding(remoteInterfaceType, bus, beanManager);
    }
  }
コード例 #6
0
  public static void startOTService(final MessageBus messageBus, final OTEngine engine) {
    messageBus.subscribe(
        "ClientOTEngineSyncService",
        new MessageCallback() {
          @Override
          public void callback(Message message) {
            final Integer value = message.getValue(Integer.class);
            final OTPeer peer = engine.getPeerState().getPeer("<ServerEngine>");
            peer.beginSyncRemoteEntity(
                "<ServerEngine>",
                value,
                new StateEntitySyncCompletionCallback(
                    engine,
                    value,
                    new EntitySyncCompletionCallback<State>() {
                      @Override
                      public void syncComplete(OTEntity<State> entity) {
                        engine.getPeerState().notifyResync(entity);
                      }
                    }));
          }
        });

    messageBus.subscribe(
        "ClientOTEngine",
        new MessageCallback() {
          @Override
          public void callback(Message message) {
            final OpDto opDto = message.getValue(OpDto.class);

            if (opDto == null && message.hasPart("PurgeHint")) {
              final Integer entityId = message.get(Integer.class, "EntityId");
              final Integer purgeHint = message.get(Integer.class, "PurgeHint");
              final int i =
                  engine
                      .getEntityStateSpace()
                      .getEntity(entityId)
                      .getTransactionLog()
                      .purgeTo(purgeHint - 100);

              LogUtil.log("purged " + i + " old entries from log.");
            } else {
              final OTPeer peer = engine.getPeerState().getPeer("<ServerEngine>");

              if (!engine.receive("<ServerEngine>", opDto.otOperation(engine))) {
                peer.beginSyncRemoteEntity(
                    "<ServerEngine>",
                    opDto.getEntityId(),
                    new StateEntitySyncCompletionCallback(
                        engine,
                        opDto.getEntityId(),
                        new EntitySyncCompletionCallback<State>() {
                          @Override
                          public void syncComplete(OTEntity<State> entity) {
                            engine.getPeerState().notifyResync(entity);
                          }
                        }));
              }
            }
          }
        });

    new Timer() {
      @Override
      public void run() {
        LogUtil.log("PURGE EVENT");
        for (OTEntity otEntity : engine.getEntityStateSpace().getEntities()) {
          engine
              .getPeerState()
              .getPeer("<ServerEngine>")
              .sendPurgeHint(otEntity.getId(), otEntity.getRevision());
        }
      }
    }.scheduleRepeating(30000);
  }