@Override
  protected void configurePollingConsumer(PollingConsumer consumer) throws Exception {
    Map<String, Object> copy = new HashMap<String, Object>(getConsumerProperties());
    Map<String, Object> throwaway = new HashMap<String, Object>();

    // filter out unwanted options which is intended for the scheduled poll consumer
    // as these options are not supported on the polling consumer
    configureScheduledPollConsumerProperties(copy, throwaway);

    // set reference properties first as they use # syntax that fools the regular properties setter
    EndpointHelper.setReferenceProperties(getCamelContext(), consumer, copy);
    EndpointHelper.setProperties(getCamelContext(), consumer, copy);

    if (!isLenientProperties() && copy.size() > 0) {
      throw new ResolveEndpointFailedException(
          this.getEndpointUri(),
          "There are "
              + copy.size()
              + " parameters that couldn't be set on the endpoint polling consumer."
              + " Check the uri if the parameters are spelt correctly and that they are properties of the endpoint."
              + " Unknown consumer parameters=["
              + copy
              + "]");
    }
  }
Esempio n. 2
0
 private static boolean isExcludePatternMatch(String key, String... excludePatterns) {
   for (String pattern : excludePatterns) {
     if (EndpointHelper.matchPattern(key, pattern)) {
       return true;
     }
   }
   return false;
 }
Esempio n. 3
0
  protected void configureConsumer(Consumer consumer) throws Exception {
    if (consumerProperties != null) {
      // use a defensive copy of the consumer properties as the methods below will remove the used
      // properties
      // and in case we restart routes, we need access to the original consumer properties again
      Map<String, Object> copy = new HashMap<String, Object>(consumerProperties);

      // set reference properties first as they use # syntax that fools the regular properties
      // setter
      EndpointHelper.setReferenceProperties(getCamelContext(), consumer, copy);
      EndpointHelper.setProperties(getCamelContext(), consumer, copy);

      // special consumer.bridgeErrorHandler option
      Object bridge = copy.remove("bridgeErrorHandler");
      if (bridge != null && "true".equals(bridge)) {
        if (consumer instanceof DefaultConsumer) {
          DefaultConsumer defaultConsumer = (DefaultConsumer) consumer;
          defaultConsumer.setExceptionHandler(
              new BridgeExceptionHandlerToErrorHandler(defaultConsumer));
        } else {
          throw new IllegalArgumentException(
              "Option consumer.bridgeErrorHandler is only supported by endpoints,"
                  + " having their consumer extend DefaultConsumer. The consumer is a "
                  + consumer.getClass().getName()
                  + " class.");
        }
      }

      if (!this.isLenientProperties() && copy.size() > 0) {
        throw new ResolveEndpointFailedException(
            this.getEndpointUri(),
            "There are "
                + copy.size()
                + " parameters that couldn't be set on the endpoint consumer."
                + " Check the uri if the parameters are spelt correctly and that they are properties of the endpoint."
                + " Unknown consumer parameters=["
                + copy
                + "]");
      }
    }
  }
Esempio n. 4
0
  public boolean removeProperties(String pattern, String... excludePatterns) {
    if (!hasProperties()) {
      return false;
    }

    boolean matches = false;
    for (Map.Entry<String, Object> entry : properties.entrySet()) {
      String key = entry.getKey();
      if (EndpointHelper.matchPattern(key, pattern)) {
        if (excludePatterns != null && isExcludePatternMatch(key, excludePatterns)) {
          continue;
        }
        matches = true;
        properties.remove(entry.getKey());
      }
    }
    return matches;
  }
Esempio n. 5
0
 @SuppressWarnings("unchecked")
 private void doFilter(String pattern, Navigate<Processor> nav, List<Processor> match) {
   List<Processor> list = nav.next();
   if (list != null) {
     for (Processor proc : list) {
       String id = null;
       if (proc instanceof IdAware) {
         id = ((IdAware) proc).getId();
       }
       if (EndpointHelper.matchPattern(id, pattern)) {
         match.add(proc);
       }
       if (proc instanceof Navigate) {
         Navigate<Processor> child = (Navigate<Processor>) proc;
         doFilter(pattern, child, match);
       }
     }
   }
 }
Esempio n. 6
0
/**
 * A default endpoint useful for implementation inheritance.
 *
 * <p>Components which leverages <a
 * href="http://camel.apache.org/asynchronous-routing-engine.html">asynchronous processing model</a>
 * should check the {@link #isSynchronous()} to determine if asynchronous processing is allowed. The
 * <tt>synchronous</tt> option on the endpoint allows Camel end users to dictate whether they want
 * the asynchronous model or not. The option is default <tt>false</tt> which means asynchronous
 * processing is allowed.
 *
 * @version
 */
public abstract class DefaultEndpoint extends ServiceSupport
    implements Endpoint, HasId, CamelContextAware {

  private static final Logger LOG = LoggerFactory.getLogger(DefaultEndpoint.class);
  private String endpointUri;
  private EndpointConfiguration endpointConfiguration;
  private CamelContext camelContext;
  private Component component;

  @UriParam(
      defaultValue = "InOnly",
      description = "Sets the default exchange pattern when creating an exchange")
  private ExchangePattern exchangePattern = ExchangePattern.InOnly;
  // option to allow end user to dictate whether async processing should be
  // used or not (if possible)
  @UriParam(
      defaultValue = "false",
      description =
          "Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported).")
  private boolean synchronous;

  private final String id = EndpointHelper.createEndpointId();
  private Map<String, Object> consumerProperties;
  private int pollingConsumerQueueSize = 1000;
  private boolean pollingConsumerBlockWhenFull = true;

  /**
   * Constructs a fully-initialized DefaultEndpoint instance. This is the preferred method of
   * constructing an object from Java code (as opposed to Spring beans, etc.).
   *
   * @param endpointUri the full URI used to create this endpoint
   * @param component the component that created this endpoint
   */
  protected DefaultEndpoint(String endpointUri, Component component) {
    this.camelContext = component == null ? null : component.getCamelContext();
    this.component = component;
    this.setEndpointUri(endpointUri);
  }

  /**
   * Constructs a DefaultEndpoint instance which has <b>not</b> been created using a {@link
   * Component}.
   *
   * <p><b>Note:</b> It is preferred to create endpoints using the associated component.
   *
   * @param endpointUri the full URI used to create this endpoint
   * @param camelContext the Camel Context in which this endpoint is operating
   */
  @Deprecated
  protected DefaultEndpoint(String endpointUri, CamelContext camelContext) {
    this(endpointUri);
    this.camelContext = camelContext;
  }

  /**
   * Constructs a partially-initialized DefaultEndpoint instance.
   *
   * <p><b>Note:</b> It is preferred to create endpoints using the associated component.
   *
   * @param endpointUri the full URI used to create this endpoint
   */
  @Deprecated
  protected DefaultEndpoint(String endpointUri) {
    this.setEndpointUri(endpointUri);
  }

  /**
   * Constructs a partially-initialized DefaultEndpoint instance. Useful when creating endpoints
   * manually (e.g., as beans in Spring).
   *
   * <p>Please note that the endpoint URI must be set through properties (or overriding {@link
   * #createEndpointUri()} if one uses this constructor.
   *
   * <p><b>Note:</b> It is preferred to create endpoints using the associated component.
   */
  protected DefaultEndpoint() {}

  public int hashCode() {
    return getEndpointUri().hashCode() * 37 + 1;
  }

  @Override
  public boolean equals(Object object) {
    if (object instanceof DefaultEndpoint) {
      DefaultEndpoint that = (DefaultEndpoint) object;
      return ObjectHelper.equal(this.getEndpointUri(), that.getEndpointUri());
    }
    return false;
  }

  @Override
  public String toString() {
    String value = null;
    try {
      value = getEndpointUri();
    } catch (RuntimeException e) {
      // ignore any exception and use null for building the string value
    }
    return String.format("Endpoint[%s]", URISupport.sanitizeUri(value));
  }

  /**
   * Returns a unique String ID which can be used for aliasing without having to use the whole URI
   * which is not unique
   */
  public String getId() {
    return id;
  }

  public String getEndpointUri() {
    if (endpointUri == null) {
      endpointUri = createEndpointUri();
      if (endpointUri == null) {
        throw new IllegalArgumentException(
            "endpointUri is not specified and "
                + getClass().getName()
                + " does not implement createEndpointUri() to create a default value");
      }
    }
    return endpointUri;
  }

  public EndpointConfiguration getEndpointConfiguration() {
    if (endpointConfiguration == null) {
      endpointConfiguration = createEndpointConfiguration(getEndpointUri());
    }
    return endpointConfiguration;
  }

  /**
   * Sets a custom {@link EndpointConfiguration}
   *
   * @param endpointConfiguration a custom endpoint configuration to be used.
   */
  public void setEndpointConfiguration(EndpointConfiguration endpointConfiguration) {
    this.endpointConfiguration = endpointConfiguration;
  }

  public String getEndpointKey() {
    if (isLenientProperties()) {
      // only use the endpoint uri without parameters as the properties is
      // lenient
      String uri = getEndpointUri();
      if (uri.indexOf('?') != -1) {
        return ObjectHelper.before(uri, "?");
      } else {
        return uri;
      }
    } else {
      // use the full endpoint uri
      return getEndpointUri();
    }
  }

  public CamelContext getCamelContext() {
    return camelContext;
  }

  /**
   * Returns the component that created this endpoint.
   *
   * @return the component that created this endpoint, or <tt>null</tt> if none set
   */
  public Component getComponent() {
    return component;
  }

  public void setCamelContext(CamelContext camelContext) {
    this.camelContext = camelContext;
  }

  public PollingConsumer createPollingConsumer() throws Exception {
    // should not call configurePollingConsumer when its EventDrivenPollingConsumer
    LOG.debug(
        "Creating EventDrivenPollingConsumer with queueSize: {} and blockWhenFull: {}",
        getPollingConsumerQueueSize(),
        isPollingConsumerBlockWhenFull());
    EventDrivenPollingConsumer consumer =
        new EventDrivenPollingConsumer(this, getPollingConsumerQueueSize());
    consumer.setBlockWhenFull(isPollingConsumerBlockWhenFull());
    return consumer;
  }

  public Exchange createExchange(Exchange exchange) {
    return exchange.copy();
  }

  public Exchange createExchange() {
    return createExchange(getExchangePattern());
  }

  public Exchange createExchange(ExchangePattern pattern) {
    return new DefaultExchange(this, pattern);
  }

  /** Returns the default exchange pattern to use when creating an exchange. */
  public ExchangePattern getExchangePattern() {
    return exchangePattern;
  }

  /** Sets the default exchange pattern when creating an exchange. */
  public void setExchangePattern(ExchangePattern exchangePattern) {
    this.exchangePattern = exchangePattern;
  }

  /** Returns whether synchronous processing should be strictly used. */
  public boolean isSynchronous() {
    return synchronous;
  }

  /**
   * Sets whether synchronous processing should be strictly used, or Camel is allowed to use
   * asynchronous processing (if supported).
   *
   * @param synchronous <tt>true</tt> to enforce synchronous processing
   */
  public void setSynchronous(boolean synchronous) {
    this.synchronous = synchronous;
  }

  /**
   * Gets the {@link org.apache.camel.PollingConsumer} queue size, when {@link
   * org.apache.camel.impl.EventDrivenPollingConsumer} is being used. Notice some Camel components
   * may have their own implementation of {@link org.apache.camel.PollingConsumer} and therefore not
   * using the default {@link org.apache.camel.impl.EventDrivenPollingConsumer} implementation.
   *
   * <p>The default value is <tt>1000</tt>
   */
  public int getPollingConsumerQueueSize() {
    return pollingConsumerQueueSize;
  }

  /**
   * Sets the {@link org.apache.camel.PollingConsumer} queue size, when {@link
   * org.apache.camel.impl.EventDrivenPollingConsumer} is being used. Notice some Camel components
   * may have their own implementation of {@link org.apache.camel.PollingConsumer} and therefore not
   * using the default {@link org.apache.camel.impl.EventDrivenPollingConsumer} implementation.
   *
   * <p>The default value is <tt>1000</tt>
   */
  public void setPollingConsumerQueueSize(int pollingConsumerQueueSize) {
    this.pollingConsumerQueueSize = pollingConsumerQueueSize;
  }

  /**
   * Whether to block when adding to the internal queue off when {@link
   * org.apache.camel.impl.EventDrivenPollingConsumer} is being used. Notice some Camel components
   * may have their own implementation of {@link org.apache.camel.PollingConsumer} and therefore not
   * using the default {@link org.apache.camel.impl.EventDrivenPollingConsumer} implementation.
   *
   * <p>Setting this option to <tt>false</tt>, will result in an {@link
   * java.lang.IllegalStateException} being thrown when trying to add to the queue, and its full.
   *
   * <p>The default value is <tt>true</tt> which will block the producer queue until the queue has
   * space.
   */
  public boolean isPollingConsumerBlockWhenFull() {
    return pollingConsumerBlockWhenFull;
  }

  /**
   * Set whether to block when adding to the internal queue off when {@link
   * org.apache.camel.impl.EventDrivenPollingConsumer} is being used. Notice some Camel components
   * may have their own implementation of {@link org.apache.camel.PollingConsumer} and therefore not
   * using the default {@link org.apache.camel.impl.EventDrivenPollingConsumer} implementation.
   *
   * <p>Setting this option to <tt>false</tt>, will result in an {@link
   * java.lang.IllegalStateException} being thrown when trying to add to the queue, and its full.
   *
   * <p>The default value is <tt>true</tt> which will block the producer queue until the queue has
   * space.
   */
  public void setPollingConsumerBlockWhenFull(boolean pollingConsumerBlockWhenFull) {
    this.pollingConsumerBlockWhenFull = pollingConsumerBlockWhenFull;
  }

  public void configureProperties(Map<String, Object> options) {
    Map<String, Object> consumerProperties =
        IntrospectionSupport.extractProperties(options, "consumer.");
    if (consumerProperties != null && !consumerProperties.isEmpty()) {
      setConsumerProperties(consumerProperties);
    }
  }

  /**
   * Sets the bean properties on the given bean.
   *
   * <p>This is the same logical implementation as {@link DefaultComponent#setProperties(Object,
   * java.util.Map)}
   *
   * @param bean the bean
   * @param parameters properties to set
   */
  protected void setProperties(Object bean, Map<String, Object> parameters) throws Exception {
    // set reference properties first as they use # syntax that fools the regular properties setter
    EndpointHelper.setReferenceProperties(getCamelContext(), bean, parameters);
    EndpointHelper.setProperties(getCamelContext(), bean, parameters);
  }

  /** A factory method to lazily create the endpointUri if none is specified */
  protected String createEndpointUri() {
    return null;
  }

  /** A factory method to lazily create the endpoint configuration if none is specified */
  protected EndpointConfiguration createEndpointConfiguration(String uri) {
    // using this factory method to be backwards compatible with the old code
    if (getComponent() != null) {
      // prefer to use component endpoint configuration
      try {
        return getComponent().createConfiguration(uri);
      } catch (Exception e) {
        throw ObjectHelper.wrapRuntimeCamelException(e);
      }
    } else if (getCamelContext() != null) {
      // fallback and use a mapped endpoint configuration
      return new MappedEndpointConfiguration(getCamelContext(), uri);
    }
    // not configuration possible
    return null;
  }

  /**
   * Sets the endpointUri if it has not been specified yet via some kind of dependency injection
   * mechanism. This allows dependency injection frameworks such as Spring or Guice to set the
   * default endpoint URI in cases where it has not been explicitly configured using the
   * name/context in which an Endpoint is created.
   */
  public void setEndpointUriIfNotSpecified(String value) {
    if (endpointUri == null) {
      setEndpointUri(value);
    }
  }

  /** Sets the URI that created this endpoint. */
  protected void setEndpointUri(String endpointUri) {
    this.endpointUri = endpointUri;
  }

  public boolean isLenientProperties() {
    // default should be false for most components
    return false;
  }

  public Map<String, Object> getConsumerProperties() {
    if (consumerProperties == null) {
      // must create empty if none exists
      consumerProperties = new HashMap<String, Object>();
    }
    return consumerProperties;
  }

  public void setConsumerProperties(Map<String, Object> consumerProperties) {
    // append consumer properties
    if (consumerProperties != null && !consumerProperties.isEmpty()) {
      if (this.consumerProperties == null) {
        this.consumerProperties = new HashMap<String, Object>(consumerProperties);
      } else {
        this.consumerProperties.putAll(consumerProperties);
      }
    }
  }

  protected void configureConsumer(Consumer consumer) throws Exception {
    if (consumerProperties != null) {
      // use a defensive copy of the consumer properties as the methods below will remove the used
      // properties
      // and in case we restart routes, we need access to the original consumer properties again
      Map<String, Object> copy = new HashMap<String, Object>(consumerProperties);

      // set reference properties first as they use # syntax that fools the regular properties
      // setter
      EndpointHelper.setReferenceProperties(getCamelContext(), consumer, copy);
      EndpointHelper.setProperties(getCamelContext(), consumer, copy);

      // special consumer.bridgeErrorHandler option
      Object bridge = copy.remove("bridgeErrorHandler");
      if (bridge != null && "true".equals(bridge)) {
        if (consumer instanceof DefaultConsumer) {
          DefaultConsumer defaultConsumer = (DefaultConsumer) consumer;
          defaultConsumer.setExceptionHandler(
              new BridgeExceptionHandlerToErrorHandler(defaultConsumer));
        } else {
          throw new IllegalArgumentException(
              "Option consumer.bridgeErrorHandler is only supported by endpoints,"
                  + " having their consumer extend DefaultConsumer. The consumer is a "
                  + consumer.getClass().getName()
                  + " class.");
        }
      }

      if (!this.isLenientProperties() && copy.size() > 0) {
        throw new ResolveEndpointFailedException(
            this.getEndpointUri(),
            "There are "
                + copy.size()
                + " parameters that couldn't be set on the endpoint consumer."
                + " Check the uri if the parameters are spelt correctly and that they are properties of the endpoint."
                + " Unknown consumer parameters=["
                + copy
                + "]");
      }
    }
  }

  protected void configurePollingConsumer(PollingConsumer consumer) throws Exception {
    configureConsumer(consumer);
  }

  @Override
  protected void doStart() throws Exception {
    // noop
  }

  @Override
  protected void doStop() throws Exception {
    // noop
  }
}
Esempio n. 7
0
 /**
  * Sets the bean properties on the given bean.
  *
  * <p>This is the same logical implementation as {@link DefaultComponent#setProperties(Object,
  * java.util.Map)}
  *
  * @param bean the bean
  * @param parameters properties to set
  */
 protected void setProperties(Object bean, Map<String, Object> parameters) throws Exception {
   // set reference properties first as they use # syntax that fools the regular properties setter
   EndpointHelper.setReferenceProperties(getCamelContext(), bean, parameters);
   EndpointHelper.setProperties(getCamelContext(), bean, parameters);
 }