[GitHub] [camel-k] nicolaferraro commented on a change in pull request #2217: feat(kamelets): kamelet binding error handler

[GitBox <gi...@apache.org>]

nicolaferraro commented on a change in pull request #2217:
URL: https://github.com/apache/camel-k/pull/2217#discussion_r614698725



##########
File path: pkg/controller/kameletbinding/common.go
##########
@@ -129,21 +145,38 @@ func createIntegrationFor(ctx context.Context, c client.Client, kameletbinding *
 		"to": to.URI,
 	})
 
-	flow := map[string]interface{}{
+	flowFrom := map[string]interface{}{
 		"from": map[string]interface{}{
 			"uri":   from.URI,
 			"steps": dslSteps,
 		},
 	}
-	encodedFlow, err := json.Marshal(flow)
+	encodedFrom, err := json.Marshal(flowFrom)
 	if err != nil {
 		return nil, err
 	}
-	it.Spec.Flows = append(it.Spec.Flows, v1.Flow{RawMessage: encodedFlow})
+	it.Spec.Flows = append(it.Spec.Flows, v1.Flow{RawMessage: encodedFrom})
 
 	return &it, nil
 }
 
+func setErrorHandlerKamelet(errorHandler *bindings.Binding, kameletSpec v1alpha1.Endpoint) error {

Review comment:
       Ok, I think I got the way you're implementing this and I had a slightly different idea in mind. The runtime part should still be ok.
   
   In your model, the error hander is a special type of Kamelet, while I was thinking we don't need another type of Kamelet, we can potentially set any Kamelet of type sink as error handler. In the model I'm describing, the error handler is a source that the operator adds to the list of "generated sources" in the integration status, possibly pointing to a standard Kamelet from the catalog.
   
   This allows for example setting this binding:
   
   ```yaml
   # ...
   spec:
     source:
       # ...
     sink:
       # ...
     errorHandler:
       ref:
         type: Kamelet
         apiVersion: camel.apache.org/v1alpha1
         name: dropbox-sink
   ```
   
   From a user point of view, it means "store errors as files on dropbox", which seems natural.
   
   But also, this allows setting something like:
   
   ```yaml
   spec:
     # ...
     errorHandler:
       ref:
         type: Channel
         apiVersion: messaging.knative.dev/v1
         name: dead-letter-channel
   ```
   
   I.e. "redirect errors to a Knative channel as-they-are".
   
   This may work the following way, more or less:
   
   1. The kameletbinding controller detects we want to use an error handler
   2. The pkg/util/binding package contains methods for converting the `ref` + `properties` of the `errorHandler` definition into a Camel URI
   3. The kameletbinding controller adds a generated source of type error-handler that forwards data in the URI determined at previous step
   4. The pkg/metadata package should be instructed to detect URIs also in error handler definitions: this way the Kamelet trait will load the Kamelet as a standard sink-type kamelet (if you're using it, or do nothing if you're using e.g. a Knative channel as dead letter channel) and the error handler will point to it
   
   Wdyt?
   cc: @lburgazzoli 




-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org