--- apiVersion: v1 kind: List items: - apiVersion: v1 kind: ConfigMap metadata: labels: funktion.fabric8.io/kind: Connector provider: fabric8 project: connector-context version: 1.1.23 group: io.fabric8.funktion.connector name: context data: deployment.yml: | --- apiVersion: extensions/v1beta1 kind: Deployment metadata: labels: funktion.fabric8.io/kind: Subscription connector: context spec: replicas: 1 template: metadata: labels: funktion.fabric8.io/kind: Subscription connector: context spec: containers: - image: fabric8/connector-context:1.1.23 name: connector schema.yml: | --- component: kind: component scheme: context syntax: context:contextId:localEndpointUrl title: Camel Context description: The context component allows to send/receive messages between Camel routes in a black box way. label: endpoint deprecated: true async: false javaType: org.apache.camel.component.context.QualifiedContextComponent groupId: org.apache.camel artifactId: camel-context version: 2.18.1 componentProperties: {} properties: contextId: kind: path group: common required: true type: string javaType: java.lang.String deprecated: false secret: false description: Is the ID you used to register the CamelContext into the Registry. localEndpointUrl: kind: path group: common required: true type: string javaType: java.lang.String deprecated: false secret: false description: Can be a valid Camel URI evaluated within the black box CamelContext. Or it can be a logical name which is mapped to any local endpoints. For example if you locally have endpoints like direct:invoices and seda:purchaseOrders inside a CamelContext of id supplyChain then you can just use the URIs supplyChain:invoices or supplyChain:purchaseOrders to omit the physical endpoint kind and use pure logical URIs. 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: "[[Context-ContextComponent]]\nContext Component\n~~~~~~~~~~~~~~~~~\n\ \n*Available as of Camel 2.7*\n\nThe *context* component allows you to create\ \ new Camel Components from a\nCamelContext with a number of routes which is\ \ then treated as a black\nbox, allowing you to refer to the local endpoints\ \ within the component\nfrom other CamelContexts.\n\nIt is similar to the link:routebox.html[Routebox]\ \ component in idea,\nthough the Context component tries to be really simple\ \ for end users;\njust a simple convention over configuration approach to refer\ \ to local\nendpoints inside the CamelContext Component.\n\nMaven users will\ \ need to add the following dependency to their `pom.xml`\nfor this component:\n\ \n[source,xml]\n------------------------------------------------------------\n\ \n org.apache.camel\n camel-context\n\ \ x.x.x\n \n\n------------------------------------------------------------\n\ \n[[Context-URIformat]]\nURI format\n^^^^^^^^^^\n\n[source,java]\n--------------------------------------------------\n\ context:camelContextId:localEndpointName[?options]\n--------------------------------------------------\n\ \nOr you can omit the \"context:\" prefix.\n\n[source,java]\n------------------------------------------\n\ camelContextId:localEndpointName[?options]\n------------------------------------------\n\ \n\n\n// component options: START\nThe Camel Context component has no options.\n\ // component options: END\n\n\n\n// endpoint options: START\nThe Camel Context\ \ component supports 6 endpoint options which are listed below:\n\n{% raw %}\n\ [width=\"100%\",cols=\"2,1,1m,1m,5\",options=\"header\"]\n|=======================================================================\n\ | Name | Group | Default | Java Type | Description\n| contextId | common | \ \ | String | *Required* Is the ID you used to register the CamelContext into\ \ the Registry.\n| localEndpointUrl | common | | String | *Required* Can be\ \ a valid Camel URI evaluated within the black box CamelContext. Or it can be\ \ a logical name which is mapped to any local endpoints. For example if you\ \ locally have endpoints like direct:invoices and seda:purchaseOrders inside\ \ a CamelContext of id supplyChain then you can just use the URIs supplyChain:invoices\ \ or supplyChain:purchaseOrders to omit the physical endpoint kind and use pure\ \ logical URIs.\n| 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.\n\ | 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.\n| exchangePattern\ \ | consumer (advanced) | | ExchangePattern | Sets the exchange pattern when\ \ the consumer creates an exchange.\n| synchronous | advanced | false | boolean\ \ | Sets whether synchronous processing should be strictly used or Camel is\ \ allowed to use asynchronous processing (if supported).\n|=======================================================================\n\ {% endraw %}\n// endpoint options: END\n\n\nYou can append query options to\ \ the URI in the following format,\n`?option=value&option=value&...`\n\n[[Context-Example]]\n\ Example\n^^^^^^^\n\nIn this example we'll create a black box context, then we'll\ \ use it from\nanother CamelContext.\n\n[[Context-Definingthecontextcomponent]]\n\ Defining the context component\n++++++++++++++++++++++++++++++\n\nFirst you\ \ need to create a CamelContext, add some routes in it, start it\nand then register\ \ the CamelContext into the link:registry.html[Registry]\n(JNDI, Spring, Guice\ \ or OSGi etc).\n\nThis can be done in the usual Camel way from this\nhttp://svn.apache.org/viewvc/camel/trunk/components/camel-context/src/test/java/org/apache/camel/component/context/JavaDslBlackBoxTest.java?revision=1069442&view=markup[test\n\ case] (see the createRegistry() method); this example shows Java and\nJNDI being\ \ used...\n\n[source,java]\n------------------------------------------------------------------------------------\n\ // lets create our black box as a camel context and a set of routes\nDefaultCamelContext\ \ blackBox = new DefaultCamelContext(registry);\nblackBox.setName(\"blackBox\"\ );\nblackBox.addRoutes(new RouteBuilder() {\n @Override\n public void\ \ configure() throws Exception {\n // receive purchase orders, lets process\ \ it in some way then send an invoice\n // to our invoice endpoint\n\ \ from(\"direct:purchaseOrder\").\n setHeader(\"received\").constant(\"\ true\").\n to(\"direct:invoice\");\n }\n});\nblackBox.start();\n\ \nregistry.bind(\"accounts\", blackBox);\n------------------------------------------------------------------------------------\n\ \nNotice in the above route we are using pure local endpoints (*direct*\nand\ \ *seda*). Also note we expose this CamelContext using the *accounts*\nID. We\ \ can do the same thing in Spring via\n\n[source,xml]\n--------------------------------------------------------------------------\n\ \n \n \n ...\n \n \n\n--------------------------------------------------------------------------\n\ \n[[Context-Usingthecontextcomponent]]\nUsing the context component\n+++++++++++++++++++++++++++\n\ \nThen in another CamelContext we can then refer to this \"accounts black\n\ box\" by just sending to *accounts:purchaseOrder* and consuming from\n*accounts:invoice*.\n\ \nIf you prefer to be more verbose and explicit you could use\n*context:accounts:purchaseOrder*\ \ or even\n*context:accounts:direct://purchaseOrder* if you prefer. But using\n\ logical endpoint URIs is preferred as it hides the implementation detail\nand\ \ provides a simple logical naming scheme.\n\nFor example if we wish to then\ \ expose this accounts black box on some\nmiddleware (outside of the black box)\ \ we can do things like...\n\n[source,xml]\n--------------------------------------------------------------------------------\n\ \n \n\ \ \n \n \n \n \n \n \n \ \ \n \n\n\ --------------------------------------------------------------------------------\n\ \n[[Context-Namingendpoints]]\nNaming endpoints\n++++++++++++++++\n\nA context\ \ component instance can have many public input and output\nendpoints that can\ \ be accessed from outside it's CamelContext. When\nthere are many it is recommended\ \ that you use logical names for them to\nhide the middleware as shown above.\n\ \nHowever when there is only one input, output or error/dead letter\nendpoint\ \ in a component we recommend using the common posix shell names\n*in*, *out*\ \ and *err*\n"