This tutorial shows how to correctly mask the sensitive data of a component configuration. It is very common to define credentials when configuring a component. Most common cases can include passwords, secrets, keys (it is also common to show them in plain text in a textarea), and tokens. For example, this REST client configuration specifies that a username, a password and a token are needed to connect to the REST API: This configuration defines that these credentials are three simple String, represented as plain inputs, which causes severe security concerns: The password and token are clearly readable in all Talend user interfaces (Studio or Web), The password and token are potentially stored in clear. To avoid this behavior, you need to mark sensitive data as @Credential. Talend Component Kit provides you with the @Credential marker, that you can use on any @Option. This marker has two effects: It Replaces the default input widget by a password oriented widget It Requests the Studio or the Talend Cloud products to store the data as sensitive data (as encrypted values). In order to ensure that the password and token are never stored in clear or shown in the code, add the @Credential marker to the sensitive data. For example: Your password and token (or any other sensitive data that you need to mask) are not accessible by error anymore.

This gallery shows how widgets and validations are rendered in both Studio and web environments, along with sample implementation code. You can also find sample working components for each of the configuration cases below: ActiveIf: Add visibility conditions on some configurations. Checkbox: Add checkboxes or toggles to your component. Code: Allow users to enter their own code. Credential: Mark a configuration as sensitive data to avoid displaying it as plain text. Datastore: Add a button allowing to check the connection to a datastore. Datalist: Two ways of implementing a dropdown list with predefined choices. Integer: Add numeric fields to your component configuration. Min/Max: Specify a minimum or a maximum value for a numeric configuration. Multiselect: Add a list and allow users to select multiple elements of that list. Pattern: Enforce rules based on a specific a pattern to prevent users from entering invalid values. Required: Make a configuration mandatory. Suggestions: Suggest possible values in a field based on what the users are entering. Table: Add a table to your component configuration. Textarea: Add a text area for configurations expecting long texts or values. Input: Add a simple text input field to the component configuration Update: Provide a button allowing to fill a part of the component configuration based on a service. Validation: Specify constraints to make sure that a URL is well formed. Widgets allow to easily implement different types of input fields to your components. Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering Datetime fields rely on the Java Date Time API, including LocalTime, LocalDate, LocalDateTime and ZonedDateTime classes. Studio Rendering Web Rendering or Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering Validations help restricting what can be entered or selected in an input field, to make sure that the value complies with the expected type of information. Studio Rendering Web Rendering Studio Rendering Web Rendering Studio Rendering Web Rendering You can also use other types of validation that are similar to @Pattern: @Min, @Max to specify a minimum and maximum value for numerical fields. @Uniques for collection values. @Required for a required configuration.

You can reuse Maven settings.xml server files, including the encrypted ones. org.talend.sdk.component.maven.MavenDecrypter allows yo to find a username/password from a server identifier: It is very useful to avoid storing secrets and to perform tests on real systems on a continuous integration platform. Even if you do not use Maven on the platform, you can generate the settings.xml and`settings-security.xml` files to use that feature. See maven.apache.org/guides/mini/guide-encryption.html for more details.

From the version 7.0 of Talend Studio, Talend Component Kit becomes the recommended framework to use to develop components. This framework is being introduced to ensure that newly developed components can be deployed and executed both in on-premise/local and cloud/big data environments. From that new approach comes the need to provide a complete yet unique and compatible way of developing components. With the Component Kit, custom components are entirely implemented in Java. To help you get started with a new custom component development project, a Starter is available. Using it, you will be able to generate the skeleton of your project. By importing this skeleton in a development tool, you can then implement the components layout and execution logic in Java. With the previous Javajet framework, metadata, widgets and configurable parts of a custom component were specified in XML. With the Component Kit, they are now defined in the Configuration (for example, LoggerProcessorConfiguration) Java class of your development project. Note that most of this configuration is transparent if you specified the Configuration Model of your components right before generating the project from the Starter. Any undocumented feature or option is considered not supported by the Component Kit framework. You can find examples of output in Studio or Cloud environments in the Gallery. Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit or Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Javajet Component Kit Return variables availability (1.51+) deprecates After Variables. Javajet AVAILABILITY can be : AFTER : set after component finished. FLOW : changed on row level. Component Kit Return variables can be nested as below: Javajet Component Kit or Previously, the execution of a custom component was described through several Javajet files: _begin.javajet, containing the code required to initialize the component. _main.javajet, containing the code required to process each line of the incoming data. _end.javajet, containing the code required to end the processing and go to the following step of the execution. With the Component Kit, the entire execution flow of a component is described through its main Java class (for example, LoggerProcessor) and through services for reusable parts. Each type of component has its own execution logic. The same basic logic is applied to all components of the same type, and is then extended to implement each component specificities. The project generated from the starter already contains the basic logic for each component. Talend Component Kit framework relies on several primitive components. All components can use @PostConstruct and @PreDestroy annotations to initialize or release some underlying resource at the beginning and the end of a processing. In distributed environments, class constructor are called on cluster manager nodes. Methods annotated with @PostConstruct and @PreDestroy are called on worker nodes. Thus, partition plan computation and pipeline tasks are performed on different nodes. All the methods managed by the framework must be public. Private methods are ignored. The framework is designed to be as declarative as possible but also to stay extensible by not using fixed interfaces or method signatures. This allows to incrementally add new features of the underlying implementations. To ensure that the Cloud-compatible approach of the Component Kit framework is respected, some changes were introduced on the implementation side, including: The File mode is no longer supported. You can still work with URIs and remote storage systems to use files. The file collection must be handled at the component implementation level. The input and output connections between two components can only be of the Flow or Reject types. Other types of connections are not supported. Every Output component must have a corresponding Input component and use a dataset. All datasets must use a datastore. To get started with the Component Kit framework, you can go through the following documents: Learn the basics about Talend Component Kit Create and deploy your first Component Kit component Learn about the Starter Start implementing components Integrate a component to Talend Studio Check some examples of components built with Talend Component Kit

This tutorial shows how to adapt the test configuration of the Zendesk search component that was done in this previous tutorial to make it work in a Continuous Integration environment. In the test, the Zendesk credentials are used directly in the code to perform a first capture of the API response. Then, fake credentials are used in the simulation mode because the real API is not called anymore. However, in some cases, you can require to continue calling the real API on a CI server or on a specific environment. To do that, you can adapt the test to get the credentials depending on the execution mode (simulation/passthrough). These instructions concern the CI server or on any environment that requires real credentials. This tutorial uses: A Maven server that supports password encryption as a credential provider. Encryption is optional but recommended. The MavenDecrypterRule test rule provided by the framework. This rule lets you get credentials from Maven settings using a server ID. To create encrypted server credentials for the Zendesk instance: Create a master password using the command: mvn --encrypt-master-password <password>. Store this master password in the settings-security.xml file of the ~/.m2 folder. Encrypt the Zendesk instance password using the command: mvn --encrypt-password password>. Create a server entry under servers in Maven settings.xml file located in the ~/.m2 folder. You can store the settings-security.xml and settings.xml files elsewhere that the default location (~/.m2). To do that, set the path of the directory containing the files in the talend.maven.decrypter.m2.location environment variable. Add the MavenDecrypterRule rule to the test class. This rule allows to inject server information stored in Maven settings.xml file to the test. The rule also decrypts credentials if they are encrypted. Inject the Zendesk server to the test. To do that, add a new field to the class with the @DecryptedServer annotation, that holds the server ID to be injected. The MavenDecrypterRule is able to inject the server instance into this class at runtime. The server instance contains the username and the decrypted password. Use the server instance in the test to get the real credentials in a secured manner. Once modified, the complete test class looks as follows: This test will continue to work in simulation mode, because the API simulation proxy is activated. This tutorial shows how to set up a CI server in passthrough mode using Jenkins. Log in to Jenkins. Click New Item to create a new build job. Enter an Item name (Job name) and choose the freestyle job. Then click OK. In the Source Code Management section, enter your project repository URL. A GitHub repository is used in this tutorial. Specify the master branch as Branches to build. In the Build section, click Add build step and choose Invoke top-level Maven targets. Choose your Maven version and enter the Maven build command. In this case: clean install. Then, click Save. The -Dtalend.junit.http.passthrough=true option is part of the build command. This option tells the API simulation proxy to run in passthrough mode. This way, all the HTTP requests made in the test are forwarded to the real API server. The MavenDecrypterRule rule allows to get the real credentials. You can configure the passthrough mode globally on your CI server by setting the talend.junit.http.passthrough environment variable to true. Test the job by selecting Build now, and check that the job has built correctly. Now your tests run in a simulation mode on your development environment and in a passthrough mode on your CI server.

The Component Kit Starter lets you design your components configuration and generates a ready-to-implement project structure. The Starter is available on the web or as an IntelliJ plugin. This tutorial shows you how to use the Component Kit Starter to generate new components for MySQL databases. Before starting, make sure that you have correctly setup your environment. See this section. When defining a project using the Starter, do not refresh the page to avoid losing your configuration. Before being able to create components, you need to define the general settings of the project: Create a folder on your local machine to store the resource files of the component you want to create. For example, C:/my_components. Open the Starter in the web browser of your choice. Select your build tool. This tutorial uses Maven, but you can select Gradle instead. Add any facet you need. For example, add the Talend Component Kit Testing facet to your project to automatically generate unit tests for the components created in the project. Enter the Component Family of the components you want to develop in the project. This name must be a valid java name and is recommended to be capitalized, for example 'MySQL'. Once you have implemented your components in the Studio, this name is displayed in the Palette to group all of the MySQL-related components you develop, and is also part of your component name. Select the Category of the components you want to create in the current project. As MySQL is a kind of database, select Databases in this tutorial. This Databases category is used and displayed as the parent family of the MySQL group in the Palette of the Studio. Complete the project metadata by entering the Group, Artifact and Package. By default, you can only create processors. If you need to create Input or Output components, select Activate IO. By doing this: Two new menu entries let you add datasets and datastores to your project, as they are required for input and output components. Input and Output components without dataset (itself containing a datastore) will not pass the validation step when building the components. Learn more about datasets and datastores in this document. An Input component and an Output component are automatically added to your project and ready to be configured. Components added to the project using Add A Component can now be processors, input or output components. A datastore represents the data needed by an input or output component to connect to a database. When building a component, the validateDataSet validation checks that each input or output (processor without output branch) component uses a dataset and that this dataset has a datastore. You can define one or several datastores if you have selected the Activate IO step. Select Datastore. The list of datastores opens. By default, a datastore is already open but not configured. You can configure it or create a new one using Add new Datastore. Specify the name of the datastore. Modify the default value to a meaningful name for your project. This name must be a valid Java name as it will represent the datastore class in your project. It is a good practice to start it with an uppercase letter. Edit the datastore configuration. Parameter names must be valid Java names. Use lower case as much as possible. A typical configuration includes connection details to a database: url username password. Save the datastore configuration. A dataset represents the data coming from or sent to a database and needed by input and output components to operate. The validateDataSet validation checks that each input or output (processor without output branch) component uses a dataset and that this dataset has a datastore. You can define one or several datasets if you have selected the Activate IO step. Select Dataset. The list of datasets opens. By default, a dataset is already open but not configured. You can configure it or create a new one using the Add new Dataset button. Specify the name of the dataset. Modify the default value to a meaningful name for your project. This name must be a valid Java name as it will represent the dataset class in your project. It is a good practice to start it with an uppercase letter. Edit the dataset configuration. Parameter names must be valid Java names. Use lower case as much as possible. A typical configuration includes details of the data to retrieve: Datastore to use (that contains the connection details to the database) table name data Save the dataset configuration. To create an input component, make sure you have selected Activate IO. When clicking Add A Component in the Starter, a new step allows you to define a new component in your project. The intent in this tutorial is to create an input component that connects to a MySQL database, executes a SQL query and gets the result. Choose the component type. Input in this case. Enter the component name. For example, MySQLInput. Click Configuration model. This button lets you specify the required configuration for the component. By default, a dataset is already specified. For each parameter that you need to add, click the (+) button on the right panel. Enter the parameter name and choose its type then click the tick button to save the changes. In this tutorial, to be able to execute a SQL query on the Input MySQL database, the configuration requires the following parameters:+ a dataset (which contains the datastore with the connection information) a timeout parameter. Closing the configuration panel on the right does not delete your configuration. However, refreshing the page resets the configuration. Specify whether the component issues a stream or not. In this tutorial, the MySQL input component created is an ordinary (non streaming) component. In this case, leave the Stream option disabled. Select the Record Type generated by the component. In this tutorial, select Generic because the component is designed to generate records in the default Record format. You can also select Custom to define a POJO that represents your records. Your input component is now defined. You can add another component or generate and download your project. When clicking Add A Component in the Starter, a new step allows you to define a new component in your project. The intent in this tutorial is to create a simple processor component that receives a record, logs it and returns it at it is. If you did not select Activate IO, all new components you add to the project are processors by default. If you selected Activate IO, you can choose the component type. In this case, to create a Processor component, you have to manually add at least one output. If required, choose the component type: Processor in this case. Enter the component name. For example, RecordLogger, as the processor created in this tutorial logs the records. Specify the Configuration Model of the component. In this tutorial, the component doesn’t need any specific configuration. Skip this step. Define the Input(s) of the component. For each input that you need to define, click Add Input. In this tutorial, only one input is needed to receive the record to log. Click the input name to access its configuration. You can change the name of the input and define its structure using a POJO. If you added several inputs, repeat this step for each one of them. The input in this tutorial is a generic record. Enable the Generic option and click Save. Define the Output(s) of the component. For each output that you need to define, click Add Output. The first output must be named MAIN. In this tutorial, only one generic output is needed to return the received record. Outputs can be configured the same way as inputs (see previous steps). You can define a reject output connection by naming it REJECT. This naming is used by Talend applications to automatically set the connection type to Reject. Your processor component is now defined. You can add another component or generate and download your project. To create an output component, make sure you have selected Activate IO. When clicking Add A Component in the Starter, a new step allows you to define a new component in your project. The intent in this tutorial is to create an output component that receives a record and inserts it into a MySQL database table. Output components are Processors without any output. In other words, the output is a processor that does not produce any records. Choose the component type. Output in this case. Enter the component name. For example, MySQLOutput. Click Configuration Model. This button lets you specify the required configuration for the component. By default, a dataset is already specified. For each parameter that you need to add, click the (+) button on the right panel. Enter the name and choose the type of the parameter, then click the tick button to save the changes. In this tutorial, to be able to insert a record in the output MySQL database, the configuration requires the following parameters:+ a dataset (which contains the datastore with the connection information) a timeout parameter. Closing the configuration panel on the right does not delete your configuration. However, refreshing the page resets the configuration. Define the Input(s) of the component. For each input that you need to define, click Add Input. In this tutorial, only one input is needed. Click the input name to access its configuration. You can change the name of the input and define its structure using a POJO. If you added several inputs, repeat this step for each one of them. The input in this tutorial is a generic record. Enable the Generic option and click Save. Do not create any output because the component does not produce any record. This is the only difference between an output an a processor component. Your output component is now defined. You can add another component or generate and download your project. Once your project is configured and all the components you need are created, you can generate and download the final project. In this tutorial, the project was configured and three components of different types (input, processor and output) have been defined. Click Finish on the left panel. You are redirected to a page that summarizes the project. On the left panel, you can also see all the components that you added to the project. Generate the project using one of the two options available: Download it locally as a ZIP file using the Download as ZIP button. Create a GitHub repository and push the project to it using the Create on Github button. In this tutorial, the project is downloaded to the local machine as a ZIP file. Once the package is available on your machine, you can compile it using the build tool selected when configuring the project. In the tutorial, Maven is the build tool selected for the project. In the project directory, execute the mvn package command. If you don’t have Maven installed on your machine, you can use the Maven wrapper provided in the generated project, by executing the ./mvnw package command. If you have created a Gradle project, you can compile it using the gradle build command or using the Gradle wrapper: ./gradlew build. The generated project code contains documentation that can guide and help you implementing the component logic. Import the project to your favorite IDE to start the implementation. The Component Kit Starter allows you to generate a component development project from an OpenAPI JSON descriptor. Open the Starter in the web browser of your choice. Enable the OpenAPI mode using the toggle in the header. Go to the API menu. Paste the OpenAPI JSON descriptor in the right part of the screen. All the described endpoints are detected. Unselect the endpoints that you do not want to use in the future components. By default, all detected endpoints are selected. Go to the Finish menu. Download the project. When exploring the project generated from an OpenAPI descriptor, you can notice the following elements: sources the API dataset an HTTP client for the API a connection folder containing the component configuration. By default, the configuration is only made of a simple datastore with a baseUrl parameter.

The component configuration is defined in the Configuration.java file of the package. It consists in defining the configurable part of the component that will be displayed in the UI. To do that, you can specify parameters. When you import the project in your IDE, the parameters that you have specified in the starter are already present. All input and output components must reference a dataset in their configuration. Refer to Defining datasets and datastores. Components are configured using their constructor parameters. All parameters can be marked with the @Option property, which lets you give a name to them. For the name to be correct, you must follow these guidelines: Use a valid Java name. Do not include any . character in it. Do not start the name with a $. Defining a name is optional. If you don’t set a specific name, it defaults to the bytecode name. This can require you to compile with a -parameter flag to avoid ending up with names such as arg0, arg1, and so on. Examples of option name: Option name Valid myName my_name my.name $myName Parameter types can be primitives or complex objects with fields decorated with @Option exactly like method parameters. It is recommended to use simple models which can be serialized in order to ease serialized component implementations. For example: Using this kind of API makes the configuration extensible and component-oriented, which allows you to define all you need. The instantiation of the parameters is done from the properties passed to the component. A primitive is a class which can be directly converted from a String to the expected type. It includes all Java primitives, like the String type itself, but also all types with a org.apache.xbean.propertyeditor.Converter: BigDecimal BigInteger File InetAddress ObjectName URI URL Pattern LocalDateTime ZonedDateTime The conversion from property to object uses the Dot notation. For example, assuming the method parameter was configured with @Option("file"): matches Lists rely on an indexed syntax to define their elements. For example, assuming that the list parameter is named files and that the elements are of the FileOptions type, you can define a list of two elements as follows: if you desire to override a config to truncate an array, use the index length, for example to truncate previous example to only CSV, you can set: Similarly to the list case, the map uses .key[index] and .value[index] to represent its keys and values: Avoid using the Map type. Instead, prefer configuring your component with an object if this is possible. You can use metadata to specify that a field is required or has a minimum size, and so on. This is done using the validation metadata in the org.talend.sdk.component.api.configuration.constraint package: Ensure the decorated option size is validated with a higher bound. API: @org.talend.sdk.component.api.configuration.constraint.Max Name: maxLength Parameter Type: double Supported Types: — java.lang.CharSequence Sample: Ensure the decorated option size is validated with a lower bound. API: @org.talend.sdk.component.api.configuration.constraint.Min Name: minLength Parameter Type: double Supported Types: — java.lang.CharSequence Sample: Validate the decorated string with a javascript pattern (even into the Studio). API: @org.talend.sdk.component.api.configuration.constraint.Pattern Name: pattern Parameter Type: java.lang.string Supported Types: — java.lang.CharSequence Sample: Ensure the decorated option size is validated with a higher bound. API: @org.talend.sdk.component.api.configuration.constraint.Max Name: max Parameter Type: double Supported Types: — java.lang.Number — int — short — byte — long — double — float Sample: Ensure the decorated option size is validated with a lower bound. API: @org.talend.sdk.component.api.configuration.constraint.Min Name: min Parameter Type: double Supported Types: — java.lang.Number — int — short — byte — long — double — float Sample: Mark the field as being mandatory. API: @org.talend.sdk.component.api.configuration.constraint.Required Name: required Parameter Type: - Supported Types: — java.lang.Object Sample: Ensure the decorated option size is validated with a higher bound. API: @org.talend.sdk.component.api.configuration.constraint.Max Name: maxItems Parameter Type: double Supported Types: — java.util.Collection Sample: Ensure the decorated option size is validated with a lower bound. API: @org.talend.sdk.component.api.configuration.constraint.Min Name: minItems Parameter Type: double Supported Types: — java.util.Collection Sample: Ensure the elements of the collection must be distinct (kind of set). API: @org.talend.sdk.component.api.configuration.constraint.Uniques Name: uniqueItems Parameter Type: - Supported Types: — java.util.Collection Sample: When using the programmatic API, metadata is prefixed by tcomp::. This prefix is stripped in the web for convenience, and the table above uses the web keys. Also note that these validations are executed before the runtime is started (when loading the component instance) and that the execution will fail if they don’t pass. If it breaks your application, you can disable that validation on the JVM by setting the system property talend.component.configuration.validation.skip to true. Datasets and datastores are configuration types that define how and where to pull the data from. They are used at design time to create shared configurations that can be stored and used at runtime. All connectors (input and output components) created using Talend Component Kit must reference a valid dataset. Each dataset must reference a datastore. Datastore: The data you need to connect to the backend. Dataset: A datastore coupled with the data you need to execute an action. Make sure that: a datastore is used in each dataset. each dataset has a corresponding input component (mapper or emitter). This input component must be able to work with only the dataset part filled by final users. Any other property implemented for that component must be optional. These rules are enforced by the validateDataSet validation. If the conditions are not met, the component builds will fail. Make sure that: a datastore is used in each dataset. each dataset has a corresponding input component (mapper or emitter). This input component must be able to work with only the dataset part filled by final users. Any other property implemented for that component must be optional. These rules are enforced by the validateDataSet validation. If the conditions are not met, the component builds will fail. A datastore defines the information required to connect to a data source. For example, it can be made of: a URL a username a password. You can specify a datastore and its context of use (in which dataset, etc.) from the Component Kit Starter. Make sure to modelize the data your components are designed to handle before defining datasets and datastores in the Component Kit Starter. Once you generate and import the project into an IDE, you can find datastores under a specific datastore node. Example of datastore: A dataset represents the inbound data. It is generally made of: A datastore that defines the connection information needed to access the data. A query. You can specify a dataset and its context of use (in which input and output component it is used) from the Component Kit Starter. Make sure to modelize the data your components are designed to handle before defining datasets and datastores in the Component Kit Starter. Once you generate and import the project into an IDE, you can find datasets under a specific dataset node. Example of dataset referencing the datastore shown above: The display name of each dataset and datastore must be referenced in the message.properties file of the family package. The key for dataset and datastore display names follows a defined pattern: ${family}.${configurationType}.${name}._displayName. For example: These keys are automatically added for datasets and datastores defined from the Component Kit Starter. When deploying a component or set of components that include datasets and datastores to Talend Studio, a new node is created under Metadata. This node has the name of the component family that was deployed. It allows users to create reusable configurations for datastores and datasets. With predefined datasets and datastores, users can then quickly fill the component configuration in their jobs. They can do so by selecting Repository as Property Type and by browsing to the predefined dataset or datastore. Studio will generate connection and close components auto for reusing connection function in input and output components, just need to do like this example: Then the runtime mapper and processor only need to use @Connection to get the connection like this: The component server scans all configuration types and returns a configuration type index. This index can be used for the integration into the targeted platforms (Studio, web applications, and so on). Mark a model (complex object) as being a dataset. API: @org.talend.sdk.component.api.configuration.type.DataSet Sample: Mark a model (complex object) as being a datastore (connection to a backend). API: @org.talend.sdk.component.api.configuration.type.DataStore Sample: Mark a model (complex object) as being a dataset discovery configuration. API: @org.talend.sdk.component.api.configuration.type.DatasetDiscovery Sample: The component family associated with a configuration type (datastore/dataset) is always the one related to the component using that configuration. The configuration type index is represented as a flat tree that contains all the configuration types, which themselves are represented as nodes and indexed by ID. Every node can point to other nodes. This relation is represented as an array of edges that provides the child IDs. As an illustration, a configuration type index for the example above can be defined as follows: If you need to define a binding between properties, you can use a set of annotations: If the evaluation of the element at the location matches value then the element is considered active, otherwise it is deactivated. API: @org.talend.sdk.component.api.configuration.condition.ActiveIf Type: if Sample: Allows to set multiple visibility conditions on the same property. API: @org.talend.sdk.component.api.configuration.condition.ActiveIfs Type: ifs Sample: Where: target is the element to evaluate. value is the value to compare against. strategy (optional) is the evaluation criteria. Possible values are: CONTAINS: Checks if a string or list of strings contains the defined value. DEFAULT: Compares against the raw value. LENGTH: For an array or string, evaluates the size of the value instead of the value itself. negate (optional) defines if the test must be positive (default, set to false) or negative (set to true). operator (optional) is the comparison operator used to combine several conditions, if applicable. Possible values are AND and OR. The target element location is specified as a relative path to the current location, using Unix path characters. The configuration class delimiter is /. The parent configuration class is specified by ... Thus, ../targetProperty denotes a property, which is located in the parent configuration class and is named targetProperty. When using the programmatic API, metadata is prefixed with tcomp::. This prefix is stripped in the web for convenience, and the previous table uses the web keys. For more details, refer to the related Javadocs. A common use of the ActiveIf condition consists in testing if a target property has a value. To do that, it is possible to test if the length of the property value is different from 0: target: foo - the path to the property to evaluate. strategy: LENGTH - the strategy consists here in testing the length of the property value. value: 0 - the length of the property value is compared to 0. negate: true - setting negate to true means that the strategy of the target must be different from the value defined. In this case, the LENGTH of the value of the foo property must be different from 0. The following example shows how to implement visibility conditions on several fields based on several checkbox configurations: If the first checkbox is selected, an additional input field is displayed. if the second or the third checkbox is selected, an additional input field is displayed. if both second and third checkboxes are selected, an additional input field is displayed. In some cases, you may need to add metadata about the configuration to let the UI render that configuration properly. For example, a password value that must be hidden and not a simple clear input box. For these cases - if you want to change the UI rendering - you can use a particular set of annotations: Provide a default value the UI can use - only for primitive fields. API: @org.talend.sdk.component.api.configuration.ui.DefaultValue Allows to sort a class properties. API: @org.talend.sdk.component.api.configuration.ui.OptionsOrder Request the rendered to do what it thinks is best. API: @org.talend.sdk.component.api.configuration.ui.layout.AutoLayout Advanced layout to place properties by row, this is exclusive with @OptionsOrder. the logic to handle forms (gridlayout names) is to use the only layout if there is only one defined, else to check if there are Main and Advanced and if at least Main exists, use them, else use all available layouts. API: @org.talend.sdk.component.api.configuration.ui.layout.GridLayout Allow to configure multiple grid layouts on the same class, qualified with a classifier (name) API: @org.talend.sdk.component.api.configuration.ui.layout.GridLayouts Put on a configuration class it notifies the UI an horizontal layout is preferred. API: @org.talend.sdk.component.api.configuration.ui.layout.HorizontalLayout Put on a configuration class it notifies the UI a vertical layout is preferred. API: @org.talend.sdk.component.api.configuration.ui.layout.VerticalLayout Mark a field as being represented by some code widget (vs textarea for instance). API: @org.talend.sdk.component.api.configuration.ui.widget.Code Mark a field as being a credential. It is typically used to hide the value in the UI. API: @org.talend.sdk.component.api.configuration.ui.widget.Credential Mark a field as being a date. It supports and is implicit - which means you don’t need to put that annotation on the option - for java.time.ZonedDateTime, java.time.LocalDate and java.time.LocalDateTime and is unspecified for other types. API: @org.talend.sdk.component.api.configuration.ui.widget.DateTime Mark a string field as being represented by selected module list widget, only for studio API: @org.talend.sdk.component.api.configuration.ui.widget.ModuleList Mark a List or List

Datasets and datastores are configuration types that define how and where to pull the data from. They are used at design time to create shared configurations that can be stored and used at runtime. All connectors (input and output components) created using Talend Component Kit must reference a valid dataset. Each dataset must reference a datastore. Datastore: The data you need to connect to the backend. Dataset: A datastore coupled with the data you need to execute an action. Make sure that: a datastore is used in each dataset. each dataset has a corresponding input component (mapper or emitter). This input component must be able to work with only the dataset part filled by final users. Any other property implemented for that component must be optional. These rules are enforced by the validateDataSet validation. If the conditions are not met, the component builds will fail. Make sure that: a datastore is used in each dataset. each dataset has a corresponding input component (mapper or emitter). This input component must be able to work with only the dataset part filled by final users. Any other property implemented for that component must be optional. These rules are enforced by the validateDataSet validation. If the conditions are not met, the component builds will fail. A datastore defines the information required to connect to a data source. For example, it can be made of: a URL a username a password. You can specify a datastore and its context of use (in which dataset, etc.) from the Component Kit Starter. Make sure to modelize the data your components are designed to handle before defining datasets and datastores in the Component Kit Starter. Once you generate and import the project into an IDE, you can find datastores under a specific datastore node. Example of datastore: A dataset represents the inbound data. It is generally made of: A datastore that defines the connection information needed to access the data. A query. You can specify a dataset and its context of use (in which input and output component it is used) from the Component Kit Starter. Make sure to modelize the data your components are designed to handle before defining datasets and datastores in the Component Kit Starter. Once you generate and import the project into an IDE, you can find datasets under a specific dataset node. Example of dataset referencing the datastore shown above: The display name of each dataset and datastore must be referenced in the message.properties file of the family package. The key for dataset and datastore display names follows a defined pattern: ${family}.${configurationType}.${name}._displayName. For example: These keys are automatically added for datasets and datastores defined from the Component Kit Starter. When deploying a component or set of components that include datasets and datastores to Talend Studio, a new node is created under Metadata. This node has the name of the component family that was deployed. It allows users to create reusable configurations for datastores and datasets. With predefined datasets and datastores, users can then quickly fill the component configuration in their jobs. They can do so by selecting Repository as Property Type and by browsing to the predefined dataset or datastore. Studio will generate connection and close components auto for reusing connection function in input and output components, just need to do like this example: Then the runtime mapper and processor only need to use @Connection to get the connection like this: The component server scans all configuration types and returns a configuration type index. This index can be used for the integration into the targeted platforms (Studio, web applications, and so on). Mark a model (complex object) as being a dataset. API: @org.talend.sdk.component.api.configuration.type.DataSet Sample: Mark a model (complex object) as being a datastore (connection to a backend). API: @org.talend.sdk.component.api.configuration.type.DataStore Sample: Mark a model (complex object) as being a dataset discovery configuration. API: @org.talend.sdk.component.api.configuration.type.DatasetDiscovery Sample: The component family associated with a configuration type (datastore/dataset) is always the one related to the component using that configuration. The configuration type index is represented as a flat tree that contains all the configuration types, which themselves are represented as nodes and indexed by ID. Every node can point to other nodes. This relation is represented as an array of edges that provides the child IDs. As an illustration, a configuration type index for the example above can be defined as follows:

Some recommendations apply to the way component packages are organized: Make sure to create a package-info.java file with the component family/categories at the root of your component package: Create a package for the configuration. Create a package for the actions. Create a package for the component and one sub-package by type of component (input, output, processors, and so on). It is recommended to serialize your configuration in order to be able to pass it through other components. When building a new component, the first step is to identify the way it must be configured. The two main concepts are: The DataStore which is the way you can access the backend. The DataSet which is the way you interact with the backend. For example: Example description DataStore DataSet Accessing a relational database like MySQL JDBC driver, URL, username, password Query to execute, row mapper, and so on. Accessing a file system File pattern (or directory + file extension/prefix/…) File format, buffer size, and so on. It is common to have the dataset including the datastore, because both are required to work. However, it is recommended to replace this pattern by defining both dataset and datastore in a higher level configuration model. For example: Input and output components are particular because they can be linked to a set of actions. It is recommended to wire all the actions you can apply to ensure the consumers of your component can provide a rich experience to their users. The most common actions are the following ones: This action exposes a way to ensure the datastore/connection works. Configuration example: Action example: Until the studio integration is complete, it is recommended to limit processors to one input. Configuring processor components is simpler than configuring input and output components because it is specific for each component. For example, a mapper takes the mapping between the input and output models: It is recommended to provide as much information as possible to let the UI work with the data during its edition. Light validations are all the validations you can execute on the client side. They are listed in the UI hint section. Use light validations first before going with custom validations because they are more efficient. Custom validations enforce custom code to be executed, but are heavier to execute. Prefer using light validations when possible. Define an action with the parameters needed for the validation and link the option you want to validate to this action. For example, to validate a dataset for a JDBC driver: You can also define a Validable class and use it to validate a form by setting it on your whole configuration: The parameter binding of the validation method uses the same logic as the component configuration injection. Therefore, the @Option method specifies the prefix to use to reference a parameter. It is recommended to use @Option("value") until you know exactly why you don’t use it. This way, the consumer can match the configuration model and just prefix it with value. to send the instance to validate. Validations are triggers based on "events". If you mark part of a configuration as @Validable but this configuration is translated to a widget without any interaction, then no validation will happen. The rule of thumb is to mark only primitives and simple types (list of primitives) as @Validable. It can be handy and user-friendly to provide completion on some fields. For example, to define completion for available drivers: Each component must have its own icon: You can use talend.surge.sh/icons/ to find the icon you want to use. It is recommended to enforce the version of your component, event though it is not mandatory for the first version. If you break a configuration entry in a later version; make sure to: Upgrade the version. Support a migration of the configuration. Testing your components is critical. You can use unit and simple standalone JUnit tests, but it is also highly recommended to have Beam tests in order to make sure that your component works in Big Data.

This tutorial walks you through the creation, from scratch, of a complete Talend input component for Hazelcast using the Talend Component Kit (TCK) framework. Hazelcast is an in-memory distributed system that can store data, which makes it a good example of input component for distributed systems. This is enough for you to get started with this tutorial, but you can find more information about it here: hazelcast.org/. A TCK project is a simple Java project with specific configurations and dependencies. You can choose your preferred build tool from Maven or Gradle as TCK supports both. In this tutorial, Maven is used. The first step consists in generating the project structure using Talend Starter Toolkit . Go to starter-toolkit.talend.io/ and fill in the project information as shown in the screenshots below, then click Finish and Download as ZIP. image::tutorial_hazelcast_generateproject_1.png[] image::tutorial_hazelcast_generateproject_2.png[] Extract the ZIP file into your workspace and import it to your preferred IDE. This tutorial uses Intellij IDE, but you can use Eclipse or any other IDE that you are comfortable with. You can use the Starter Toolkit to define the full configuration of the component, but in this tutorial some parts are configured manually to explain key concepts of TCK. The generated pom.xml file of the project looks as follows: Change the name tag to a more relevant value, for example: Component Hazelcast. The component-api dependency provides the necessary API to develop the components. talend-component-maven-plugin provides build and validation tools for the component development. The Java compiler also needs a Talend specific configuration for the components to work correctly. The most important is the -parameters option that preserves the parameter names needed for introspection features that TCK relies on. Download the mvn dependencies declared in the pom.xml file: You should get a BUILD SUCCESS at this point: Create the project structure: Create the component Java packages. Packages are mandatory in the component model and you cannot use the default one (no package). It is recommended to create a unique package per component to be able to reuse it as dependency in other components, for example to guarantee isolation while writing unit tests. The project is now correctly set up. The next steps consist in registering the component family and setting up some properties. Registering every component family allows the component server to properly load the components and to ensure they are available in Talend Studio. The family registration happens via a package-info.java file that you have to create. Move to the src/main/java/org/talend/components/hazelcast package and create a package-info.java file: @Components: Declares the family name and the categories to which the component belongs. @Icon: Defines the component family icon. This icon is visible in the Studio metadata tree. Talend Component Kit supports internationalization (i18n) via Java properties files. Using these files, you can customize and translate the display name of properties such as the name of a component family or, as shown later in this tutorial, labels displayed in the component configuration. Go to src/main/resources/org/talend/components/hazelcast and create an i18n Messages.properties file as below: You can define the component family icon in the package-info.java file. The icon image must exist in the resources/icons folder. TCK supports both SVG and PNG formats for the icons. Create the icons folder and add an icon image for the Hazelcast family. This tutorial uses the Hazelcast icon from the official GitHub repository that you can get from: avatars3.githubusercontent.com/u/1453152?s=200&v=4 Download the image and rename it to Hazelcast_icon32.png. The name syntax is important and should match _icon.32.png. The component registration is now complete. The next step consists in defining the component configuration. All Input and Output (I/O) components follow a predefined model of configuration. The configuration requires two parts: Datastore: Defines all properties that let the component connect to the targeted system. Dataset: Defines the data to be read or written from/to the targeted system. Connecting to the Hazelcast cluster requires the IP address, group name and password of the targeted cluster. In the component, the datastore is represented by a simple POJO. Create a HazelcastDatastore.java class file in the src/main/java/org/talend/components/hazelcast folder. Define the i18n properties of the datastore. In the Messages.properties file let add the following lines: The Hazelcast datastore is now defined. Hazelcast includes different types of datastores. You can manipulate maps, lists, sets, caches, locks, queues, topics and so on. This tutorial focuses on maps but still applies to the other data structures. Reading/writing from a map requires the map name. Create the dataset class by creating a HazelcastDataset.java file in src/main/java/org/talend/components/hazelcast. The @Dataset annotation marks the class as a dataset. Note that it also references a datastore, as required by the components model. Just how it was done for the datastore, define the i18n properties of the dataset. To do that, add the following lines to the Messages.properties file. The component configuration is now ready. The next step consists in creating the Source that will read the data from the Hazelcast map. The Source is the class responsible for reading the data from the configured dataset. A source gets the configuration instance injected by TCK at runtime and uses it to connect to the targeted system and read the data. Create a new class as follows. The source also needs i18n properties to provide a readable display name. Add the following line to the Messages.properties file. At this point, it is already possible to see the result in the Talend Component Web Tester to check how the configuration looks like and validate the layout visually. To do that, execute the following command in the project folder. This command starts the Component Web Tester and deploys the component there. Access localhost:8080/. The source is set up. It is now time to start creating some Hazelcast specific code to connect to a cluster and read values for a map. Add the hazelcast-client Maven dependency to the pom.xml of the project, in the dependencies node. Add a Hazelcast instance to the @PostConstruct method. Declare a HazelcastInstance attribute in the source class. Any non-serializable attribute needs to be marked as transient to avoid serialization issues. Implement the post construct method. The component configuration is mapped to the Hazelcast client configuration to create a Hazelcast instance. This instance will be used later to get the map from its name and read the map data. Only the required configuration in the component is exposed to keep the code as simple as possible. Implement the code responsible for reading the data from the Hazelcast map through the Producer method. The Producer implements the following logic: Check if the map iterator is already initialized. If not, get the map from its name and initialize the map iterator. This is done in the @Producer method to ensure the map is initialized only if the next() method is called (lazy initialization). It also avoids the map initialization in the PostConstruct method as the Hazelcast map is not serializable. All the objects initialized in the PostConstruct method need to be serializable as the source can be serialized and sent to another worker in a distributed cluster. From the map, create an iterator on the map keys that will read from the map. Transform every key/value pair into a Talend Record with a "key, value" object on every call to next(). The RecordBuilderFactory class used above is a built-in service in TCK injected via the Source constructor. This service is a factory to create Talend Records. Now, the next() method will produce a Record every time it is called. The method will return "null" if there is no more data in the map. Implement the @PreDestroy annotated method, responsible for releasing all resources used by the Source. The method needs to shut the Hazelcast client instance down to release any connection between the component and the Hazelcast cluster. The Hazelcast Source is completed. The next section shows how to write a simple unit test to check that it works properly. TCK provides a set of APIs and tools that makes the testing straightforward. The test of the Hazelcast Source consists in creating an embedded Hazelcast instance with only one member and initializing it with some data, and then in creating a test Job to read the data from it using the implemented Source. Add the required Maven test dependencies to the project. Initialize a Hazelcast test instance and create a map with some test data. To do that, create the HazelcastSourceTest.java test class in the src/test/java folder. Create the folder if it does not exist. The above example creates a Hazelcast instance for the test and creates the MY-DISTRIBUTED-MAP map. The getMap creates the map if it does not already exist. Some keys and values uses in the test are added. Then, a simple test checks that the data is correctly initialized. Finally, the Hazelcast test instance is shut down. Run the test and check in the logs that a Hazelcast cluster of one member has been created and that the test has passed. To be able to test components, TCK provides the @WithComponents annotation which enables component testing. Add this annotation to the test. The annotation takes the component Java package as a value parameter. Create the test Job that configures the Hazelcast instance and link it to an output that collects the data produced by the Source. Execute the unit test and check that it passes, meaning that the Source is reading the data correctly from Hazelcast. The Source is now completed and tested. The next section shows how to implement the Partition Mapper for the Source. In this case, the Partition Mapper will split the work (data reading) between the available cluster members to distribute the workload. The Partition Mapper calculates the number of Sources that can be created and executed in parallel on the available workers of a distributed system. For Hazelcast, it corresponds to the cluster member count. To fully illustrate this concept, this section also shows how to enhance the test environment to add more Hazelcast cluster members and initialize it with more data. Instantiate more Hazelcast instances, as every Hazelcast instance corresponds to one member in a cluster. In the test, it is reflected as follows: The above code sample creates two Hazelcast instances, leading to the creation of two Hazelcast members. Having a cluster of two members (nodes) will allow to distribute the data. The above code also adds more data to the test map and updates the shutdown method and the test. Run the test on the multi-nodes cluster. The Source is a simple implementation that does not distribute the workload and reads the data in a classic way, without distributing the read action to different cluster members. Start implementing the Partition Mapper class by creating a HazelcastPartitionMapper.java class file. When coupling a Partition Mapper with a Source, the Partition Mapper becomes responsible for injecting parameters and creating source instances. This way, all the attribute initialization part moves from the Source to the Partition Mapper class. The configuration also sets an instance name to make it easy to find the client instance in the logs or while debugging. The Partition Mapper class is composed of the following: constructor: Handles configuration and service injections Assessor: This annotation indicates that the method is responsible for assessing the dataset size. The underlying runner uses the estimated dataset size to compute the optimal bundle size to distribute the workload efficiently. Split: This annotation indicates that the method is responsible for creating Partition Mapper instances based on the bundle size requested by the underlying runner and the size of the dataset. It creates as much partitions as possible to parallelize and distribute the workload efficiently on the available workers (known as members in the Hazelcast case). Emitter: This annotation indicates that the method is responsible for creating the Source instance with an adapted configuration allowing to handle the amount of records it will produce and the required services. I adapts the configuration to let the Source read only the requested bundle of data. The Assessor method computes the memory size of every member of the cluster. Implementing it requires submitting a calculation task to the members through a serializable task that is aware of the Hazelcast instance. Create the serializable task. The purpose of this class is to submit any task to the Hazelcast cluster. Use the created task to estimate the dataset size in the Assessor method. The Assessor method calculates the memory size that the map occupies for all members. In Hazelcast, distributing a task to all members can be achieved using an execution service initialized in the getExecutorService() method. The size of the map is requested on every available member. By summing up the results, the total size of the map in the distributed cluster is computed. The Split method calculates the heap size of the map on every member of the cluster. Then, it calculates how many members a source can handle. If a member contains less data than the requested bundle size, the method tries to combine it with another member. That combination can only happen if the combined data size is still less or equal to the requested bundle size. The following code illustrates the logic described above. The next step consists in adapting the source to take the Split into account. The following sample shows how to adapt the Source to the Split carried out previously. The next method reads the data from the members received from the Partition Mapper. A Big Data runner like Spark will get multiple Source instances. Every source instance will be responsible for reading data from a specific set of members already calculated by the Partition Mapper. The data is fetched only when the next method is called. This logic allows to stream the data from members without loading it all into the memory. Implement the method annotated with @Emitter in the HazelcastPartitionMapper class. The createSource() method creates the source instance and passes the required services and the selected Hazelcast members to the source instance. Run the test and check that it works as intended. The component implementation is now done. It is able to read data and to distribute the workload to available members in a Big Data execution environment. Refactor the component by introducing a service to make some pieces of code reusable and avoid code duplication. Refactor the Hazelcast instance creation into a service. Inject this service to the Partition Mapper to reuse it. Adapt the Source class to reuse the service. Run the test one last time to ensure everything still works as expected. Thank you for following this tutorial. Use the logic and approach presented here to create any input component for any system.

Testing code that consumes REST APIs can sometimes present many constraints: API rate limit, authentication token and password sharing, API availability, sandbox expiration, API costs, and so on. As a developer, it becomes critical to avoid those constraints and to be able to easily mock the API response. The component framework provides an API simulation tool that makes it easy to write unit tests. This tutorial shows how to use this tool in unit tests. As a starting point, the tutorial uses the component that consumes Zendesk Search API and that was created in a previous tutorial. The goal is to add unit tests for it. For this tutorial, four tickets that have the open status have been added to the Zendesk test instance used in the tests. To learn more about the testing methodology used in this tutorial, refer to Component JUnit testing. Create a unit test that performs a real HTTP request to the Zendesk Search API instance. You can learn how to create a simple unit test in this tutorial. the authentication configuration using Zendesk instance URL and credentials. the search query configuration to get all the open ticket, ordered by creation date and sorted in descending order. The test is now complete and working. It performs a real HTTP request to the Zendesk instance. As an alternative, you can use mock results to avoid performing HTTP requests every time on the development environment. The real HTTP requests would, for example, only be performed on an integration environment. To transform the unit test into a mocked test that uses a mocked response of the Zendesk Search API: Add the two following JUnit rules provided by the component framework. JUnit4HttpApi: This rule starts a simulation server that acts as a proxy and catches all the HTTP requests performed in the tests. This simulation server has two modes : capture : This mode forwards the captured HTTP request to the real server and captures the response. simulation : this mode returns a mocked response from the responses already captured. This rule needs to be added as a class rule. JUnit4HttpApi: This rule has a reference to the first rule. Its role is to configure the simulation server for every unit test. It passes the context of the running test to the simulation server. This rule needs to be added as a simple (method) rule. Example to run in a simulation mode: Make the test run in capture mode to catch the real API responses that can be used later in the simulated mode. To do that, set a new talend.junit.http.capture environment variable to true. This tells the simulation server to run in a capture mode. The captured response is saved in the resources/talend.testing.http package in a JSON format, then reused to perform the API simulation.

This tutorial shows how to create components that consume a REST API. The component developed as example in this tutorial is an input component that provides a search functionality for Zendesk using its Search API. Lombok is used to avoid writing getter, setter and constructor methods. You can generate a project using the Talend Components Kit starter, as described in this tutorial. The input component relies on Zendesk Search API and requires an HTTP client to consume it. The Zendesk Search API takes the following parameters on the /api/v2/search.json endpoint. query : The search query. sort_by : The sorting type of the query result. Possible values are updated_at, created_at, priority, status, ticket_type, or relevance. It defaults to relevance. sort_order: The sorting order of the query result. Possible values are asc (for ascending) or desc (for descending). It defaults to desc. Talend Component Kit provides a built-in service to create an easy-to-use HTTP client in a declarative manner, using Java annotations. No additional implementation is needed for the interface, as it is provided by the component framework, according to what is defined above. This HTTP client can be injected into a mapper or a processor to perform HTTP requests. This example uses the basic authentication that supported by the API. The first step is to set up the configuration for the basic authentication. To be able to consume the Search API, the Zendesk instance URL, the username and the password are needed. The data store is now configured. It provides a basic authentication token. Once the data store is configured, you can define the dataset by configuring the search query. It is that query that defines the records processed by the input component. Your component is configured. You can now create the component logic. Mappers defined with this tutorial don’t implement the split part because HTTP calls are not split on many workers in this case. Once the component logic implemented, you can create the source in charge of performing the HTTP request to the search API and converting the result to JsonObject records. You now have created a simple Talend component that consumes a REST API. To learn how to test this component, refer to this tutorial.