コード例 #1
0
  private void createPersonTable(Set<String> tables) {
    if (!tables.contains("PERSON")) {
      SQL.insert(SQLs.PERSON_CREATE_TABLE);
      LOG.info("Database table 'PERSON' created");

      if (CONFIG.getPropertyValue(ConfigProperties.DatabaseAutoPopulateProperty.class)) {
        createPersonEntry(
            "Alice",
            null,
            "http://www.uergsel.de/uploads/Alice.png",
            DateUtility.parse("26.11.1865", "dd.MM.yyyy"),
            "F",
            "Daresbury, Cheshire",
            "GB",
            "The curious girl",
            ORGANISATION1);
        createPersonEntry(
            "Rabbit",
            "the White",
            "https://upload.wikimedia.org/wikipedia/commons/4/42/The_White_Rabbit_%28Tenniel%29_-_The_Nursery_Alice_%281890%29_-_BL.jpg",
            DateUtility.parse("26.11.1861", "dd.MM.yyyy"),
            "F",
            "Daresbury, Cheshire",
            "GB",
            "Follow me",
            ORGANISATION1);

        LOG.info("Database table 'PERSON' populated with sample data");
      }
    }
  }
コード例 #2
0
  public void autoCreateDatabase() {
    if (CONFIG.getPropertyValue(ConfigProperties.DatabaseAutoCreateProperty.class)) {

      try {
        BEANS
            .get(SuperUserRunContextProducer.class)
            .produce()
            .run(
                new IRunnable() {

                  @Override
                  public void run() throws Exception {
                    Set<String> tables = getExistingTables();
                    createOrganizationTable(tables);
                    createPersonTable(tables);
                  }
                });
      } catch (RuntimeException e) {
        BEANS.get(ExceptionHandler.class).handle(e);
      }
    }
  }
コード例 #3
0
  private void createOrganizationTable(Set<String> tables) {
    if (!tables.contains("ORGANIZATION")) {
      SQL.insert(SQLs.ORGANIZATION_CREATE_TABLE);
      LOG.info("Database table 'ORGANIZATION' created");

      if (CONFIG.getPropertyValue(ConfigProperties.DatabaseAutoPopulateProperty.class)) {
        createOrganizationEntry(
            ORGANISATION1,
            "London",
            "GB",
            "http://en.wikipedia.org/wiki/Alice%27s_Adventures_in_Wonderland",
            "https://upload.wikimedia.org/wikipedia/en/3/3f/Alice_in_Wonderland%2C_cover_1865.jpg");
        createOrganizationEntry(
            "BSI Business Systems Integration AG",
            "Daettwil, Baden",
            "CH",
            "https://www.bsi-software.com",
            "https://wiki.eclipse.org/images/4/4f/Bsiag.png");

        LOG.info("Database table 'ORGANIZATION' populated with sample data");
      }
    }
  }
コード例 #4
0
/**
 * Wraps a JAX-WS handler, so that the handler can be invoked from within {@link RunContext}. The
 * invocation is done via {@link IBeanManager}, meaning that the handler is to be annotated with
 * {@link ApplicationScoped} annotation. Also, this class adds support to inject <em>init
 * parameters</em> to the handler.
 *
 * <p>To be invoked in a {@link RunContext}, annotate the handler with {@link RunWithRunContext}
 * annotation.
 *
 * @since 5.1
 */
public class HandlerDelegate<CONTEXT extends MessageContext> implements Handler<CONTEXT> {

  private static final Logger LOG = LoggerFactory.getLogger(HandlerDelegate.class);

  private static final Subject HANDLER_SUBJECT =
      CONFIG.getPropertyValue(JaxWsHandlerSubjectProperty.class);

  private final Handler<CONTEXT> m_handler;

  private final RunContextProducer m_handlerRunContextProducer;

  @SuppressWarnings("unchecked")
  public HandlerDelegate(
      final org.eclipse.scout.rt.server.jaxws.provider.annotation.Handler handlerAnnotation) {
    m_handler =
        BEANS.get(ClazzUtil.resolve(handlerAnnotation.value(), Handler.class, "@Handler.value"));

    final RunWithRunContext runHandleWithRunContext =
        m_handler.getClass().getAnnotation(RunWithRunContext.class);
    m_handlerRunContextProducer =
        (runHandleWithRunContext != null ? BEANS.get(runHandleWithRunContext.value()) : null);

    injectInitParams(m_handler, toInitParamMap(handlerAnnotation.initParams()));
  }

  @Override
  public boolean handleMessage(final CONTEXT messageContext) {
    return handle(
        messageContext,
        "handleMessage",
        new Callable<Boolean>() {

          @Override
          public Boolean call() throws Exception {
            return m_handler.handleMessage(messageContext);
          }
        });
  }

  @Override
  public boolean handleFault(final CONTEXT messageContext) {
    return handle(
        messageContext,
        "handleFault",
        new Callable<Boolean>() {

          @Override
          public Boolean call() throws Exception {
            return m_handler.handleFault(messageContext);
          }
        });
  }

  @Override
  public void close(final MessageContext messageContext) {
    handle(
        messageContext,
        "close",
        new Callable<Void>() {

          @Override
          public Void call() throws Exception {
            m_handler.close(messageContext);
            return null;
          }
        });
  }

  /**
   * Method invoked to optionally run the given {@link Callable} on behalf of a {@link RunContext}.
   */
  @Internal
  protected <T> T handle(
      final MessageContext messageContext, final String method, final Callable<T> callable) {
    try {
      if (m_handlerRunContextProducer == null) {
        return callable.call();
      } else {
        final Subject subject = MessageContexts.getSubject(messageContext, HANDLER_SUBJECT);
        return m_handlerRunContextProducer
            .produce(subject)
            .call(
                new Callable<T>() {
                  @Override
                  public T call() throws Exception {
                    return callable.call();
                  }
                },
                DefaultExceptionTranslator.class);
      }
    } catch (final Exception e) {
      LOG.error(
          "Failed to handle message [handler={}, method={}, inbound={}]",
          m_handler.getClass().getName(),
          method,
          MessageContexts.isInboundMessage(messageContext),
          e);
      throw new HTTPException(
          HttpServletResponse.SC_INTERNAL_SERVER_ERROR); // do not send cause to the client
    }
  }

  /** @return original handler this handler delegates to. */
  protected Handler<CONTEXT> getHandlerDelegate() {
    return m_handler;
  }

  /** Injects the given 'init-params' into the given handler. */
  @Internal
  protected void injectInitParams(
      final Handler<CONTEXT> handler, final Map<String, String> initParams) {
    for (final Field field : handler.getClass().getDeclaredFields()) {
      if (field.getAnnotation(Resource.class) != null
          && field.getType().isAssignableFrom(initParams.getClass())) {
        try {
          LOG.info(
              "Inject 'initParams' to JAX-WS handler [path={}#{}]",
              handler.getClass().getName(),
              field.getName());
          field.setAccessible(true);
          field.set(handler, initParams);
          return;
        } catch (final ReflectiveOperationException e) {
          throw new PlatformException(
              "Failed to inject 'InitParams' for handler '{}'", handler.getClass().getName(), e);
        }
      }
    }

    if (!initParams.isEmpty()) {
      LOG.warn(
          "'InitParams' could not be injected into handler because no field found that is of type Map<String, String> and annotated with @Resource [handler={}, initParams={}]",
          handler.getClass().getName(),
          initParams);
    }
  }

  @Internal
  protected Map<String, String> toInitParamMap(final InitParam[] initParams) {
    final Map<String, String> map = new HashMap<>(initParams.length);
    for (final InitParam initParam : initParams) {
      map.put(initParam.key(), initParam.value());
    }
    return map;
  }
}