Component Development

It is recommended to refer to existing components to develop a new component.

public interface

  1. // component lifecycle interface
  2. type Lifecycle interface {
  3.     // Initialize component, such as initializing the Kafka connection
  4.     Init(context Context)
  5.     // Start component. For example, start consuming Kafka
  6.     Start()
  7.     // Stop component.
  8.     Stop()
  9. }
  11. // component description interface
  12. type Describable interface {
  13.     // For example, source.
  14.     Category() Category
  15.     // For example, kafka.
  16.     Type() Type
  17.     // Customized description
  18.     String() string
  19. }
  21. // interface for getting configuration
  22. type Config interface {
  23.     // to get configuration
  24.     Config() interface{}
  25. }
  27. // Component
  28. type Component interface {
  29.     // component lifecycle interface
  30.     Lifecycle
  31.     // component description interface
  32.     Describable
  33.     // interface for getting configuration
  34.     Config
  35. }

Source Component

The source component is connected to the data source input. To develop a new source plug-in, you need to implement the following interfaces.

  1. // source component interface
  2. type Source interface {
  3.     Component
  4.     Producer
  5.     // Confirm that the sink is successful and then submit.
  6.     Commit(events []Event)
  7. }
  9. // Source component needs to implement this producer interface.
  10. type Producer interface {
  11.     // docking data source
  12.     ProductLoop(productFunc ProductFunc)
  13. }

Sink Component

The sink component is connected to the output end. To develop a new sink plug-in, you need to implement the following interfaces.

  1.  // sink component interface
  2. type Sink interface {
  3.     Component
  4.     Consumer
  5. }
  7. // Sink component needs to implement this consumer interface.
  8. type Consumer interface {
  9.     // docking output
  10.     Consume(batch Batch) Result
  11. }

Interceptor Component

The interceptor component intercepts events. To develop a new interceptor plug-in, you need to implement the following interfaces.

  1. // interceptor component interface
  2. type Interceptor interface {
  3.     Component
  4.     // Intercept processing
  5.     Intercept(invoker Invoker, invocation Invocation) api.Result
  6. }

Note

Please note that the newly added components need to be registered in the import of pkg/include/include.go.