---
apiVersion: v1
kind: List
items:
- apiVersion: v1
  kind: ConfigMap
  metadata:
    labels:
      funktion.fabric8.io/kind: Connector
      provider: fabric8
      project: connector-guava-eventbus
      version: 1.1.21
      group: io.fabric8.funktion.connector
    name: guava-eventbus
  data:
    deployment.yml: |
      ---
      apiVersion: extensions/v1beta1
      kind: Deployment
      metadata:
        labels:
          funktion.fabric8.io/kind: Subscription
          connector: guava-eventbus
      spec:
        replicas: 1
        template:
          metadata:
            labels:
              funktion.fabric8.io/kind: Subscription
              connector: guava-eventbus
          spec:
            containers:
            - image: fabric8/connector-guava-eventbus:1.1.21
              name: connector
    schema.yml: |
      ---
      component:
        kind: component
        scheme: guava-eventbus
        syntax: guava-eventbus:eventBusRef
        title: Guava EventBus
        description: The guava-eventbus component provides integration bridge between Camel and Google Guava EventBus.
        label: eventbus
        deprecated: false
        async: false
        javaType: org.apache.camel.component.guava.eventbus.GuavaEventBusComponent
        groupId: org.apache.camel
        artifactId: camel-guava-eventbus
        version: 2.18.1
      componentProperties:
        eventBus:
          kind: property
          type: object
          javaType: com.google.common.eventbus.EventBus
          deprecated: false
          secret: false
          description: To use the given Guava EventBus instance
        listenerInterface:
          kind: property
          type: string
          javaType: java.lang.Class<?>
          deprecated: false
          secret: false
          description: The interface with method(s) marked with the Subscribe annotation. Dynamic proxy will be created over the interface so it could be registered as the EventBus listener. Particularly useful when creating multi-event listeners and for handling DeadEvent properly. This option cannot be used together with eventClass option.
      properties:
        eventBusRef:
          kind: path
          group: common
          type: string
          javaType: java.lang.String
          deprecated: false
          secret: false
          description: To lookup the Guava EventBus from the registry with the given name
        eventClass:
          kind: parameter
          group: common
          type: string
          javaType: java.lang.Class<?>
          deprecated: false
          secret: false
          description: If used on the consumer side of the route will filter events received from the EventBus to the instances of the class and superclasses of eventClass. Null value of this option is equal to setting it to the java.lang.Object i.e. the consumer will capture all messages incoming to the event bus. This option cannot be used together with listenerInterface option.
        listenerInterface:
          kind: parameter
          group: common
          type: string
          javaType: java.lang.Class<?>
          deprecated: false
          secret: false
          description: The interface with method(s) marked with the Subscribe annotation. Dynamic proxy will be created over the interface so it could be registered as the EventBus listener. Particularly useful when creating multi-event listeners and for handling DeadEvent properly. This option cannot be used together with eventClass option.
        bridgeErrorHandler:
          kind: parameter
          group: consumer
          label: consumer
          type: boolean
          javaType: boolean
          optionalPrefix: consumer.
          deprecated: false
          secret: false
          defaultValue: false
          description: Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
        exceptionHandler:
          kind: parameter
          group: consumer (advanced)
          label: consumer,advanced
          type: object
          javaType: org.apache.camel.spi.ExceptionHandler
          optionalPrefix: consumer.
          deprecated: false
          secret: false
          description: To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
        exchangePattern:
          kind: parameter
          group: consumer (advanced)
          label: consumer,advanced
          type: string
          javaType: org.apache.camel.ExchangePattern
          enum:
          - InOnly
          - RobustInOnly
          - InOut
          - InOptionalOut
          - OutOnly
          - RobustOutOnly
          - OutIn
          - OutOptionalIn
          deprecated: false
          secret: false
          description: Sets the exchange pattern when the consumer creates an exchange.
        synchronous:
          kind: parameter
          group: advanced
          label: advanced
          type: boolean
          javaType: boolean
          deprecated: false
          secret: false
          defaultValue: false
          description: Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
    documentation.adoc: |
      [[GuavaEventBus-GuavaEventBusComponent]]
      Guava EventBus Component
      ~~~~~~~~~~~~~~~~~~~~~~~~

      *Available since Camel 2.10.0*

      The
      http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/eventbus/package-summary.html[Google
      Guava EventBus] allows publish-subscribe-style communication between
      components without requiring the components to explicitly register with
      one another (and thus be aware of each other). The *guava-eventbus:*
      component provides integration bridge between Camel and
      http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/eventbus/package-summary.html[Google
      Guava EventBus] infrastructure. With the latter component, messages
      exchanged with the Guava `EventBus` can be transparently forwarded to
      the Camel routes. EventBus component allows also to route body of Camel
      exchanges to the Guava `EventBus`.

      Maven users will need to add the following dependency to their `pom.xml`
      for this component:

      [source,xml]
      ------------------------------------------------------------
      <dependency>
          <groupId>org.apache.camel</groupId>
          <artifactId>camel-guava-eventbus</artifactId>
          <version>x.x.x</version>
          <!-- use the same version as your Camel core version -->
      </dependency>
      ------------------------------------------------------------

      [[GuavaEventBus-URIformat]]
      URI format
      ^^^^^^^^^^

      [source,java]
      --------------------------------
      guava-eventbus:busName[?options]
      --------------------------------

      Where *busName* represents the name of the
      `com.google.common.eventbus.EventBus` instance located in the Camel
      registry.

      [[GuavaEventBus-Options]]
      Options
      ^^^^^^^





      // component options: START
      The Guava EventBus component supports 2 options which are listed below.



      {% raw %}
      [width="100%",cols="2,1m,7",options="header"]
      |=======================================================================
      | Name | Java Type | Description
      | eventBus | EventBus | To use the given Guava EventBus instance
      | listenerInterface | Class<?> | The interface with method(s) marked with the Subscribe annotation. Dynamic proxy will be created over the interface so it could be registered as the EventBus listener. Particularly useful when creating multi-event listeners and for handling DeadEvent properly. This option cannot be used together with eventClass option.
      |=======================================================================
      {% endraw %}
      // component options: END





      // endpoint options: START
      The Guava EventBus component supports 7 endpoint options which are listed below:

      {% raw %}
      [width="100%",cols="2,1,1m,1m,5",options="header"]
      |=======================================================================
      | Name | Group | Default | Java Type | Description
      | eventBusRef | common |  | String | To lookup the Guava EventBus from the registry with the given name
      | eventClass | common |  | Class<?> | If used on the consumer side of the route will filter events received from the EventBus to the instances of the class and superclasses of eventClass. Null value of this option is equal to setting it to the java.lang.Object i.e. the consumer will capture all messages incoming to the event bus. This option cannot be used together with listenerInterface option.
      | listenerInterface | common |  | Class<?> | The interface with method(s) marked with the Subscribe annotation. Dynamic proxy will be created over the interface so it could be registered as the EventBus listener. Particularly useful when creating multi-event listeners and for handling DeadEvent properly. This option cannot be used together with eventClass option.
      | bridgeErrorHandler | consumer | false | boolean | Allows for bridging the consumer to the Camel routing Error Handler which mean any exceptions occurred while the consumer is trying to pickup incoming messages or the likes will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions that will be logged at WARN/ERROR level and ignored.
      | exceptionHandler | consumer (advanced) |  | ExceptionHandler | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options is not in use. By default the consumer will deal with exceptions that will be logged at WARN/ERROR level and ignored.
      | exchangePattern | consumer (advanced) |  | ExchangePattern | Sets the exchange pattern when the consumer creates an exchange.
      | synchronous | advanced | false | boolean | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported).
      |=======================================================================
      {% endraw %}
      // endpoint options: END



      [[GuavaEventBus-Usage]]
      Usage
      ^^^^^

      Using `guava-eventbus` component on the consumer side of the route will
      capture messages sent to the Guava `EventBus` and forward them to the
      Camel route. Guava EventBus consumer processes incoming messages
      http://camel.apache.org/asynchronous-routing-engine.html[asynchronously].

      [source,java]
      -------------------------------------------------------
      SimpleRegistry registry = new SimpleRegistry();
      EventBus eventBus = new EventBus();
      registry.put("busName", eventBus);
      CamelContext camel = new DefaultCamelContext(registry);

      from("guava-eventbus:busName").to("seda:queue");

      eventBus.post("Send me to the SEDA queue.");
      -------------------------------------------------------

      Using `guava-eventbus` component on the producer side of the route will
      forward body of the Camel exchanges to the Guava `EventBus` instance.

      [source,java]
      ----------------------------------------------------------------------
      SimpleRegistry registry = new SimpleRegistry();
      EventBus eventBus = new EventBus();
      registry.put("busName", eventBus);
      CamelContext camel = new DefaultCamelContext(registry);

      from("direct:start").to("guava-eventbus:busName");

      ProducerTemplate producerTemplate = camel.createProducerTemplate();
      producer.sendBody("direct:start", "Send me to the Guava EventBus.");

      eventBus.register(new Object(){
        @Subscribe
        public void messageHander(String message) {
          System.out.println("Message received from the Camel: " + message);
        }
      });
      ----------------------------------------------------------------------

      [[GuavaEventBus-DeadEventconsiderations]]
      DeadEvent considerations
      ^^^^^^^^^^^^^^^^^^^^^^^^

      Keep in mind that due to the limitations caused by the design of the
      Guava EventBus, you cannot specify event class to be received by the
      listener without creating class annotated with `@Subscribe` method. This
      limitation implies that endpoint with `eventClass` option specified
      actually listens to all possible events (`java.lang.Object`) and filter
      appropriate messages programmatically at runtime. The snipped below
      demonstrates an appropriate excerpt from the Camel code base.

      [source,java]
      ----------------------------------------------------------------------------
      @Subscribe
      public void eventReceived(Object event) {
        if (eventClass == null || eventClass.isAssignableFrom(event.getClass())) {
          doEventReceived(event);
      ...
      ----------------------------------------------------------------------------

      This drawback of this approach is that `EventBus` instance used by Camel
      will never generate `com.google.common.eventbus.DeadEvent`
      notifications. If you want Camel to listen only to the precisely
      specified event (and therefore enable `DeadEvent` support), use
      `listenerInterface` endpoint option. Camel will create dynamic proxy
      over the interface you specify with the latter option and listen only to
      messages specified by the interface handler methods. The example of the
      listener interface with single method handling only `SpecificEvent`
      instances is demonstrated below.

      [source,java]
      ------------------------------------------
      package com.example;

      public interface CustomListener {

        @Subscribe
        void eventReceived(SpecificEvent event);

      }
      ------------------------------------------

      The listener presented above could be used in the endpoint definition as
      follows.

      [source,java]
      ---------------------------------------------------------------------------------------------
      from("guava-eventbus:busName?listenerInterface=com.example.CustomListener").to("seda:queue");
      ---------------------------------------------------------------------------------------------

      [[GuavaEventBus-Consumingmultipletypeofevents]]
      Consuming multiple type of events
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

      In order to define multiple type of events to be consumed by Guava
      EventBus consumer use `listenerInterface` endpoint option, as listener
      interface could provide multiple methods marked with the `@Subscribe`
      annotation.

      [source,java]
      ------------------------------------------------
      package com.example;

      public interface MultipleEventsListener {

        @Subscribe
        void someEventReceived(SomeEvent event);

        @Subscribe
        void anotherEventReceived(AnotherEvent event);

      }
      ------------------------------------------------

      The listener presented above could be used in the endpoint definition as
      follows.

      [source,java]
      -----------------------------------------------------------------------------------------------------
      from("guava-eventbus:busName?listenerInterface=com.example.MultipleEventsListener").to("seda:queue");
      -----------------------------------------------------------------------------------------------------
