extension

Les Joblets dans Talaxie Joblets in Talaxie

Regroupez des composants dans un Joblet, puis déposez-le dans vos jobs comme un composant : son code est injecté dans celui du job. Réservés jusqu'ici aux éditions payantes du Studio Talend, les Joblets font partie de Talaxie 9. Group components into a Joblet, then drop it into your jobs like a component: its code is injected into the job code. Until now reserved for the paid editions of Talend Studio, Joblets are part of Talaxie 9.

Vue d'ensembleOverview

Un Joblet est un morceau de job rangé dans le référentiel du projet. Il remplace un groupe de composants par un seul, qui se réutilise dans plusieurs jobs, ou plusieurs fois dans le même. Il sert à factoriser un traitement récurrent (un contrôle, une mise en forme, une suite d'étapes) et à alléger le dessin d'un job. Le Studio Talaxie 8 (le studio Eclipse) n'a pas le plugin des Joblets : dans Talaxie, ils viennent du nouvel éditeur de Talaxie 9, et cette page décrit ce que fait cet éditeur. A Joblet is a piece of job stored in the project repository. It replaces a group of components with a single one, reusable in several jobs or several times in the same job. It factors out a recurring processing (a check, a formatting step, a sequence of steps) and makes a job design lighter. Talaxie Studio 8 (the Eclipse studio) does not have the Joblet plugin: in Talaxie, Joblets come with the new editor of Talaxie 9, and this page describes what that editor does.

widgets

Un composant du jobA component of the job

Dans le job, le Joblet a son icône et son nom, comme un composant. On le relie par des flux et des déclencheurs. Un double clic l'ouvre dans son propre onglet. In the job, the Joblet has its icon and its name, like a component. It is connected with flows and triggers. A double-click opens it in its own tab.

merge_type

Un code injectéInjected code

Avant de générer le code, Talaxie remplace chaque Joblet par ses composants. Le job reste une seule classe Java : aucun sous-job lancé, la même globalMap, les mêmes variables de contexte. Before generating the code, Talaxie replaces each Joblet with its components. The job remains a single Java class: no sub-job is launched, same globalMap, same context variables.

compare_arrows

Joblet ou tRunJob ?Joblet or tRunJob?

Un tRunJob lance un autre job, qui a sa classe et ses propres variables de contexte. Un Joblet fait partie du job : il lit et écrit ses variables, et des lignes de données le traversent. A tRunJob launches another job, with its own class and its own context variables. A Joblet is part of the job: it reads and writes the job variables, and data rows flow through it.

Ce qu'on voit dans le jobWhat you see in the job

JOB_Flux row1 row2 tFixedFlowInput_1 JBL_Normalise tLogRow_1
  • L'icône du Joblet (celle de son fichier) et, dessous, son nom. Son nom unique dans le job, JBL_Normalise_1, se lit dans le titre de l'onglet Composant. The Joblet icon (the one stored in its file) with its name below. Its unique name in the job, JBL_Normalise_1, is shown in the title of the Component tab.
  • Pas de cadre particulier, et pas de dépliage dans le job : les composants du Joblet se voient et se modifient dans son onglet. No special frame, and no expanding inside the job: the Joblet components are shown and edited in its own tab.
  • Sa page Paramètres simples n'a qu'un champ par TRIGGER_INPUT du Joblet (le composant du job qui le déclenche) ; sa page Schémas montre, en lecture seule, le schéma de chacune de ses sorties de flux. Its Basic settings page only has one field per TRIGGER_INPUT of the Joblet (the job component that triggers it); its Schemas page shows, read-only, the schema of each of its flow outputs.
  • Un Joblet n'a jamais le fond vert des composants de départ, même quand il commence un sous-job. A Joblet never gets the green background of start components, even when it begins a subjob.

PrérequisRequirements

  • Un projet ouvert : les Joblets sont des éléments de son référentiel (section Joblets, dossier joblets du projet). An open project: Joblets are items of its repository (Joblets section, joblets folder of the project).
  • Rien à installer : ni plugin, ni licence. Pour exécuter, un JDK 21, comme pour tous les jobs de Talaxie. Nothing to install: no plugin, no license. To run, a JDK 21, as for every Talaxie job.
  • Des jobs standard : un Joblet ne se dépose pas dans une route, et il n'y a pas de Joblets Spark. Standard jobs: a Joblet cannot be dropped into a route, and there are no Spark Joblets.
  • Un nom par Joblet dans le projet. Les exemples de cette page les préfixent par JBL_ ; ce n'est qu'une convention. One name per Joblet in the project. The examples of this page prefix them with JBL_; this is only a convention.

Créer un JobletCreate a Joblet

Deux chemins : partir d'un Joblet vide, ou sortir d'un job les composants qui méritent d'être réutilisés (Refactoriser en Joblet). Two ways: start from an empty Joblet, or take out of a job the components worth reusing (Refactor to Joblet).

De zéroFrom scratch

  1. Dans le référentiel, clic droit sur la section Joblets (ou sur un de ses dossiers) › Créer un Joblet. In the repository, right-click the Joblets section (or one of its folders) › Create Joblet.
  2. Remplissez la fenêtre Nouveau Joblet (tableau ci-contre), puis Terminer. Fill in the New Joblet window (table opposite), then Finish.
  3. Le Joblet s'ouvre dans un onglet. Il contient déjà INPUT_1 et OUTPUT_1, au schéma vide. Supprimez ceux dont vous n'avez pas besoin (touche Suppr). The Joblet opens in a tab. It already contains INPUT_1 and OUTPUT_1, with empty schemas. Delete the ones you do not need (Del key).
  4. Déposez vos composants, reliez-les entre eux et aux composants de liaison, réglez les schémas. Drop your components, connect them to each other and to the port components, set the schemas.
  5. Enregistrez (Ctrl + S). Le Joblet est dans la palette des jobs dès sa création ; les jobs utilisent ce qui est enregistré. Save (Ctrl + S). The Joblet is in the palette of the jobs as soon as it is created; jobs use what has been saved.

Fenêtre « Nouveau Joblet »"New Joblet" window

NomNameObligatoire : une lettre, puis des lettres, des chiffres ou « _ ». Unique parmi les Joblets du projet, corbeille comprise, sans tenir compte de la casse.Required: a letter, then letters, digits or "_". Unique among the Joblets of the project, recycle bin included, case-insensitive.
Objectif · DescriptionPurpose · DescriptionFacultatifs : laissés vides, la fenêtre le déconseille sans bloquer.Optional: when left empty, the window advises against it without blocking.
Créé parCreated byL'auteur du projet, en lecture seule.The project author, read-only.
Version0.1 ; les boutons M et m passent à la version majeure ou mineure suivante.0.1; the M and m buttons move to the next major or minor version.
Chemin d'accèsLocationLe dossier de la section Joblets où ranger le Joblet.The folder of the Joblets section where the Joblet is stored.

Messages de la fenêtre : « Le nom est vide. », « Nom invalide : une lettre, puis des lettres, des chiffres ou « _ ». », « Un Joblet porte déjà ce nom dans le projet. ». Messages of the window: "The name is empty.", "Invalid name: a letter, then letters, digits or "_".", "A Joblet with this name already exists in the project.".

L'onglet d'un JobletThe tab of a Joblet

  • Il se dessine comme un job : mêmes composants, mêmes liens, onglets Job, Contexte et Composant. It is designed like a job: same components, same links, Job, Context and Component tabs.
  • Dans la palette, le groupe Liaison du Joblet précède les familles de composants : INPUT, OUTPUT, TRIGGER_INPUT, TRIGGER_OUTPUT. La recherche de la palette et l'ajout rapide (un clic sur la grille, puis taper le nom) les trouvent aussi. In the palette, the Joblet ports group comes before the component families: INPUT, OUTPUT, TRIGGER_INPUT, TRIGGER_OUTPUT. The palette search and quick add (click the grid, then type the name) find them too.
  • Pas de vue Code, et l'onglet Exécuter le job affiche « Un Joblet s'exécute dans le job qui l'utilise. ». No Code view, and the Run the job tab shows "A Joblet runs inside the job that uses it.".
  • Un Joblet n'est pas compilé seul : une erreur dans son code n'apparaît qu'à l'exécution d'un job qui l'utilise. A Joblet is not compiled on its own: an error in its code only shows up when a job that uses it is run.

Ce que contient un Joblet neufWhat a new Joblet contains

JBL_Normalise INPUT_1 OUTPUT_1
  • INPUT_1 ne sert que si un flux du job entre dans le Joblet ; OUTPUT_1, que si un flux en sort vers le job. Un Joblet peut n'avoir ni l'un ni l'autre. INPUT_1 is only useful when a job flow enters the Joblet; OUTPUT_1, when a flow leaves it towards the job. A Joblet may have neither.
  • L'environnement de contexte Default, sans variable. The Default context environment, without any variable.
  • Sur le disque : joblets/<Nom>_0.1.item et son .properties, au format du Studio Talend. On disk: joblets/<Name>_0.1.item and its .properties, in the Talend Studio format.

Les composants de liaisonThe port components

Quatre composants, propres aux Joblets, relient l'intérieur du Joblet au job qui l'utilise. Un Joblet en contient autant qu'il veut, numérotés à la création : INPUT_1, INPUT_2, TRIGGER_OUTPUT_1… Four components, specific to Joblets, connect the inside of the Joblet to the job that uses it. A Joblet holds as many of them as needed, numbered when created: INPUT_1, INPUT_2, TRIGGER_OUTPUT_1…

ComposantComponent RôleRole Liens dans le JobletLinks inside the Joblet SchémaSchema
INPUT Reçoit un flux du job.Receives a flow from the job. Un seul lien sortant, Ligne › Principal (ou sa poignée). Aucun lien entrant.A single outgoing link, Row › Main (or its handle). No incoming link. Oui, à saisir : Modifier le schéma, ou page Schémas. Il décrit les colonnes que le job doit fournir.Yes, to be entered: Edit schema, or the Schemas page. It describes the columns the job must provide.
OUTPUT Rend un flux au job.Returns a flow to the job. Reçoit un flux : Principal, Reject, Filter, sortie de tMap… Refuse les déclencheurs et Iterate. Aucun lien sortant.Receives a flow: Main, Reject, Filter, tMap output… Refuses triggers and Iterate. No outgoing link. Oui : c'est le schéma que le job verra en sortie du Joblet. Il faut le renseigner (voir ci-dessous).Yes: it is the schema the job will see at the Joblet output. It must be filled in (see below).
TRIGGER_INPUT Démarre le Joblet quand le job le déclenche.Starts the Joblet when the job triggers it. Part en Déclencher › On Subjob Ok ou On Component Ok. Aucun lien entrant.Leaves with Trigger › On Subjob Ok or On Component Ok. No incoming link. Non : aucune ligne ne le traverse.No: no row goes through it.
TRIGGER_OUTPUT Déclenche la suite du job.Triggers the rest of the job. Reçoit On Subjob Ok, On Subjob Error, On Component Ok, On Component Error ou Run if. Refuse les flux et Iterate. Aucun lien sortant.Receives On Subjob Ok, On Subjob Error, On Component Ok, On Component Error or Run if. Refuses flows and Iterate. No outgoing link. Non.No.

Le schéma d'OUTPUTThe OUTPUT schema

Quand vous reliez un flux à un OUTPUT encore sans colonnes, il prend le schéma de ce flux. Si ce schéma change ensuite, faites l'un ou l'autre : When you connect a flow to an OUTPUT that has no columns yet, it takes the schema of this flow. If this schema changes later, do one of these:

  • sélectionnez le composant qui précède OUTPUT, onglet Composant › Schémas : le message « ⚠ Schéma différent de OUTPUT_1 » est suivi du bouton Propager… ; select the component before OUTPUT, Component tab › Schemas: the "⚠ Schema differs from OUTPUT_1" message is followed by the Propagate… button;
  • ou sélectionnez OUTPUT et saisissez ses colonnes par Modifier le schéma. or select OUTPUT and enter its columns with Edit schema.

Un OUTPUT resté sans colonnes (flux relié avant que son composant ait un schéma) ne gêne pas le Joblet, mais le composant du job qui le suit ne reçoit aucun schéma : un tLogRow affiche alors des lignes vides. An OUTPUT left without columns (flow connected before its component had a schema) does not disturb the Joblet, but the job component that follows it receives no schema: a tLogRow then prints empty lines.

À savoirGood to know

  • Un lien refusé par un composant de liaison n'est pas créé. A link refused by a port component is not created.
  • Le schéma d'INPUT passe, quand on trace le lien, au composant suivant s'il reprend le schéma de son entrée (tLogRow, tFilterRow…). Un tJavaRow ou un tMap gardent le leur, à régler comme dans un job. When the link is drawn, the INPUT schema goes to the next component if it takes the schema of its input (tLogRow, tFilterRow…). A tJavaRow or a tMap keep their own, to be set as in a job.
  • Les composants de liaison ne se copient pas : un copier-coller ne prend que les autres composants. Port components are not copied: copy and paste only takes the other components.
  • À la génération, les schémas d'INPUT et d'OUTPUT ne sont pas lus : les lignes du job vont droit au premier composant du Joblet, et celles du dernier composant droit au job. Ils servent au dessin, dans le Joblet et dans le job. At generation, the INPUT and OUTPUT schemas are not read: job rows go straight to the first component of the Joblet, and those of the last component straight to the job. They serve the design, in the Joblet and in the job.

Depuis un job : « Refactoriser en Joblet »From a job: "Refactor to Joblet"

Les étapesSteps

  1. Dans le job, sélectionnez le ou les composants à sortir, puis clic droit sur l'un d'eux › Refactoriser en Joblet. In the job, select the component or components to take out, then right-click one of them › Refactor to Joblet.
  2. Le job est enregistré, puis la fenêtre Nouveau Joblet demande le nom. The job is saved, then the New Joblet window asks for the name.
  3. Terminer : les composants passent dans le Joblet, avec leurs réglages, leurs schémas et les liens qui les reliaient entre eux. Le Joblet s'ouvre dans un onglet. Finish: the components move into the Joblet, with their settings, their schemas and the links between them. The Joblet opens in a tab.
  4. Dans le job, un Joblet les remplace, au milieu de la place qu'ils occupaient, et les liens coupés lui sont rattachés. In the job, a Joblet replaces them, in the middle of the place they occupied, and the cut links are attached to it.

La commande n'existe ni dans une route ni dans un Joblet. Elle écrit le job et le Joblet sur le disque : Ctrl + Z ne la défait pas. The command exists neither in a route nor in a Joblet. It writes the job and the Joblet to disk: Ctrl + Z does not undo it.

Ce qui est crééWhat is created

Flux qui entre dans la sélectionFlow entering the selectionINPUT_n, avec le schéma du lien.INPUT_n, with the schema of the link.
Flux qui en sortFlow leaving itOUTPUT_n, avec le schéma du lien ; le lien du job garde son nom.OUTPUT_n, with the schema of the link; the job link keeps its name.
Déclencheur qui entreTrigger enteringTRIGGER_INPUT_n
Déclencheur qui sortTrigger leavingTRIGGER_OUTPUT_n ; dans le job, le lien devient « OnSubjobOk (TRIGGER_OUTPUT_n) ».TRIGGER_OUTPUT_n; in the job, the link becomes "OnSubjobOk (TRIGGER_OUTPUT_n)".
Contexte et routinesContext and routinesLe Joblet reçoit une copie des variables de contexte du job et de ses dépendances de routines.The Joblet gets a copy of the job context variables and of its routine dependencies.

Le code resté dans le job suit : là où il lisait une variable globale d'un composant déplacé, tFilterRow_1_NB_LINE_REJECT devient JBL_Total_1_tFilterRow_1_NB_LINE_REJECT (voir l'exemple). The code left in the job follows: where it read a global variable of a moved component, tFilterRow_1_NB_LINE_REJECT becomes JBL_Total_1_tFilterRow_1_NB_LINE_REJECT (see the example).

Utiliser un Joblet dans un jobUse a Joblet in a job

Le Joblet se dépose comme un composant, de trois façons : depuis le groupe Joblets de la palette, placé avant les familles de composants, par l'ajout rapide (un clic sur la grille, puis taper son nom), ou en le glissant depuis la section Joblets du référentiel. Un clic droit dans la palette l'ajoute aux favoris. Dans le job, il se nomme <Joblet>_<n> et se copie-colle comme un composant. A Joblet is dropped like a component, in three ways: from the Joblets group of the palette, placed before the component families, with quick add (click the grid, then type its name), or by dragging it from the Joblets section of the repository. A right-click in the palette adds it to the favorites. In the job, it is named <Joblet>_<n> and is copied and pasted like a component.

LienLink Comment le tracerHow to draw it Ce qu'il devientWhat it becomes
Flux entrantIncoming flow Depuis le composant précédent : Ligne › Principal (ou sa poignée), jusqu'au Joblet.From the previous component: Row › Main (or its handle), up to the Joblet. Il alimente un INPUT : le premier flux tracé va à INPUT_1, le suivant à INPUT_2… Il doit porter les colonnes que les composants du Joblet emploient.It feeds an INPUT: the first flow drawn goes to INPUT_1, the next one to INPUT_2… It must carry the columns that the Joblet components use.
Flux sortantOutgoing flow Clic droit sur le Joblet › Ligne › OUTPUT_n. Sa poignée trace le premier OUTPUT encore libre.Right-click the Joblet › Row › OUTPUT_n. Its handle draws the first OUTPUT still free. Le lien prend le schéma de ce point de sortie et le donne au composant suivant s'il n'en a pas. Un OUTPUT n'alimente qu'un lien : une fois relié, il n'est plus proposé. Pour deux destinations, ajoutez un tReplicate dans le job.The link takes the schema of this output and gives it to the next component if it has none. An OUTPUT feeds a single link: once connected, it is no longer offered. For two destinations, add a tReplicate in the job.
Déclencheur entrantIncoming trigger Depuis un autre composant : Déclencher › On Subjob Ok, On Component Ok, Run if…, jusqu'au Joblet.From another component: Trigger › On Subjob Ok, On Component Ok, Run if…, up to the Joblet. Il lance le composant relié à TRIGGER_INPUT dans le Joblet. C'est le type du lien du job qui s'applique, condition d'un Run if comprise.It starts the component connected to TRIGGER_INPUT in the Joblet. The type of the job link applies, including the condition of a Run if.
Déclencheur sortantOutgoing trigger Clic droit sur le Joblet › Déclencher › TRIGGER_OUTPUT_n.Right-click the Joblet › Trigger › TRIGGER_OUTPUT_n. Le lien s'appelle toujours « OnSubjobOk (TRIGGER_OUTPUT_n) », mais c'est le lien tracé dans le Joblet vers ce point de sortie qui décide : un On Subjob Error y déclenche la suite en cas d'erreur.The link is always called "OnSubjobOk (TRIGGER_OUTPUT_n)", but the link drawn inside the Joblet to this output decides: an On Subjob Error there triggers what follows when an error occurs.

Un Joblet n'a que les sorties qu'on lui a donnéesA Joblet only has the outputs it was given

Les menus Ligne et Déclencher d'un Joblet ne proposent que ses OUTPUT_n et ses TRIGGER_OUTPUT_n : pas de On Subjob Ok ni de Run if propres au Joblet. Pour enchaîner un sous-job après lui, il lui faut un TRIGGER_OUTPUT. Sans lien, les sous-jobs d'un job s'exécutent dans leur ordre de création : un Joblet déposé après les autres passe après eux. The Row and Trigger menus of a Joblet only offer its OUTPUT_n and TRIGGER_OUTPUT_n: no On Subjob Ok or Run if of its own. To chain a subjob after it, it needs a TRIGGER_OUTPUT. Without links, the subjobs of a job run in their creation order: a Joblet dropped after the others runs after them.

Version utiliséeVersion used

Le job prend la dernière version du Joblet, lue au moment de générer. Il n'y a pas de liste Version sur le Joblet. Un job venu du Studio Talend qui demande une version précise la garde si elle existe ; sinon, il prend la dernière. The job takes the latest version of the Joblet, read when generating. There is no Version list on the Joblet. A job coming from Talend Studio that asks for a given version keeps it if it exists; otherwise it takes the latest.

Plusieurs fois le même JobletThe same Joblet several times

Chaque dépôt a son nom (JBL_Normalise_1, JBL_Normalise_2) et donc ses propres composants, lignes et variables globales dans le code. Deux Joblets peuvent aussi se suivre, la sortie de l'un reliée à l'entrée de l'autre. Each drop has its name (JBL_Normalise_1, JBL_Normalise_2) and therefore its own components, rows and global variables in the code. Two Joblets can also follow each other, the output of one connected to the input of the other.

Joblet en début de jobJoblet at the beginning of a job

Rien à cocher : il n'y a pas de case Startable. Un Joblet sans INPUT ni TRIGGER_INPUT, dont le premier composant peut commencer un sous-job (tFixedFlowInput, tFileInputDelimited, tJava…), commence lui-même un sous-job du job. Nothing to tick: there is no Startable checkbox. A Joblet without INPUT or TRIGGER_INPUT, whose first component can begin a subjob (tFixedFlowInput, tFileInputDelimited, tJava…), begins a subjob of the job by itself.

Joblet dans un JobletJoblet inside a Joblet

Un Joblet peut en contenir d'autres, à toute profondeur. La palette d'un Joblet ne les liste pas : glissez le Joblet depuis le référentiel sur la grille, ou collez-le. Un Joblet ne se dépose pas dans lui-même, et une boucle (A contient B, B contient A) arrête la génération. A Joblet can contain other Joblets, at any depth. The palette of a Joblet does not list them: drag the Joblet from the repository onto the grid, or paste it. A Joblet cannot be dropped into itself, and a loop (A contains B, B contains A) stops the generation.

Plusieurs entréesSeveral inputs

Reliez un flux par INPUT du Joblet, dans l'ordre : il n'y a pas de réglage pour choisir quel flux va à quel INPUT. Avec plusieurs TRIGGER_INPUT, chaque lien de déclenchement tracé vers le Joblet s'attache au premier point d'entrée libre : le premier lien à TRIGGER_INPUT_1, le suivant à TRIGGER_INPUT_2. Pour changer, sélectionnez le Joblet : sa page Paramètres simples a un champ Composant attaché à TRIGGER_INPUT_n par point d'entrée, où choisir le composant du job qui le déclenche. Connect one flow per INPUT of the Joblet, in order: there is no setting to choose which flow goes to which INPUT. With several TRIGGER_INPUT, each trigger link drawn to the Joblet is attached to the first free entry point: the first link to TRIGGER_INPUT_1, the next one to TRIGGER_INPUT_2. To change this, select the Joblet: its Basic settings page has a Node attached to TRIGGER_INPUT_n field per entry point, where you choose the job component that triggers it.

Désactiver un JobletDeactivating a Joblet

Le clic droit › Désactiver grise le Joblet dans le job : ses composants ne s'exécutent pas, comme ceux d'un composant désactivé, et ses liens sont ignorés. Right-click › Deactivate dims the Joblet in the job: its components do not run, as for a deactivated component, and its links are ignored.

ExécutionExecution

Un job à Joblet se lance comme un autre (bouton Exécuter, F6, construction). Juste avant de générer le code, Talaxie lit la version enregistrée de chaque Joblet et le remplace par ses composants, renommés d'après le nom du Joblet dans le job. Les Joblets contenus dans un Joblet sont remplacés à leur tour. A job with a Joblet is launched like any other (Run button, F6, build). Right before generating the code, Talaxie reads the saved version of each Joblet and replaces it with its components, renamed after the name of the Joblet in the job. Joblets contained in a Joblet are replaced in turn.

Dessiné (nom unique du Joblet dans le job : JBL_Normalise_1)Designed (unique name of the Joblet in the job: JBL_Normalise_1)

JOB_Flux row1 row2 tFixedFlowInput_1 JBL_Normalise tLogRow_1

GénéréGenerated

JOB_Flux row1 row2 tFixedFlowInput_1 JBL_Normalise_1_tJavaRow_1 tLogRow_1
Dans le JobletIn the Joblet Dans le job généréIn the generated job ExempleExample
Un composantA componentPréfixé par le nom du Joblet dans le job.Prefixed with the name of the Joblet in the job.JBL_Normalise_1_tJavaRow_1
Une ligne entre deux composants du JobletA row between two components of the JobletPréfixée de même.Prefixed in the same way.JBL_Total_1_row2
Une ligne reliée à INPUT ou à OUTPUTA row connected to INPUT or OUTPUTPrend le nom du lien du job.Takes the name of the job link.row1 · out1
La variable globale d'un composant du JobletThe global variable of a Joblet componentSuit le nom du composant. Dans le Joblet, on l'écrit sans préfixe (tJavaRow_1_NB_LINE) : le préfixe est ajouté. Dans le job, on écrit le nom complet.Follows the component name. In the Joblet, it is written without prefix (tJavaRow_1_NB_LINE): the prefix is added. In the job, write the full name.JBL_Normalise_1_tJavaRow_1_NB_LINE
Une variable globale libre, une variable de contexteA free global variable, a context variableInchangées : le Joblet et le job partagent la même globalMap et le même context.Unchanged: the Joblet and the job share the same globalMap and the same context.globalMap.get("lot") · context.prefixe
Un sous-jobA subjobUne méthode de la classe du job.A method of the job class.JBL_Preparation_1_tJava_1Process

Dans la consoleIn the console

  • Une erreur nomme le composant généré : Exception in component JBL_Controle_1_tJava_1. Un clic sur ce nom sélectionne le Joblet dans le job. An error names the generated component: Exception in component JBL_Controle_1_tJava_1. Clicking this name selects the Joblet in the job.
  • Les composants de journalisation du job voient ceux du Joblet. Un tWarn placé dans un Joblet et capté par le tLogCatcher du job donne (colonnes job, priority, type, origin, message, code) : The logging components of the job see those of the Joblet. A tWarn placed in a Joblet and caught by the job tLogCatcher gives (job, priority, type, origin, message, code columns):
JOB_Alerte|4|tWarn|JBL_Alerte_1_tWarn_1|stock faible|42

Statistiques, construction, onglet ExécuterStatistics, build, Run tab

  • Les liens du job qui entrent dans le Joblet et en sortent reçoivent leurs statistiques (nombre de lignes) comme les autres. Celles des liens intérieurs sont produites sous leur nom préfixé, sans lien du job où s'afficher. The job links that enter and leave the Joblet get their statistics (row count) like the others. Those of the inner links are produced under their prefixed name, with no job link to be shown on.
  • Un job construit contient le code de ses Joblets, et leurs variables de contexte dans ses fichiers de contexte. Si les éléments du projet sont joints à l'archive, les Joblets du job y sont. A built job contains the code of its Joblets, and their context variables in its context files. If the project items are added to the archive, the Joblets of the job are in it.
  • Un Joblet ouvert seul ne s'exécute pas : ni bouton Exécuter ni F6, et l'onglet Exécuter le job affiche « Un Joblet s'exécute dans le job qui l'utilise. ». A Joblet opened on its own cannot be run: no Run button, no F6, and the Run the job tab shows "A Joblet runs inside the job that uses it.".

Le préfixe s'applique à tout le texte des réglagesThe prefix applies to all the text of the settings

Dans les réglages des composants du Joblet (code, expressions, requêtes, messages), tout mot égal au nom d'un composant ou d'une ligne du Joblet reçoit le préfixe, même dans un texte entre guillemets : "lignes vues par tJavaRow_1" s'affiche « lignes vues par JBL_Compte_1_tJavaRow_1 ». In the settings of the Joblet components (code, expressions, queries, messages), every word equal to the name of a component or a row of the Joblet gets the prefix, even inside a quoted text: "lignes vues par tJavaRow_1" is printed "lignes vues par JBL_Compte_1_tJavaRow_1".

Modifier et organiserEdit and organize

Un Joblet s'ouvre par un double clic dans le référentiel, ou par un double clic sur lui dans un job : sa dernière version s'affiche dans un onglet, où il se modifie comme un job. Les jobs lisent le Joblet au moment de générer : dès qu'il est enregistré, tous ceux qui l'utilisent prennent la modification à leur prochaine exécution ou construction, sans être rouverts. A Joblet is opened with a double-click in the repository, or with a double-click on it in a job: its latest version is shown in a tab, where it is edited like a job. Jobs read the Joblet when generating: as soon as it is saved, all the jobs that use it take the change at their next run or build, without being reopened.

Détection des mises à jourUpdate detection

Chaque Joblet déposé dans un job garde une copie du schéma de ses OUTPUT. À l'enregistrement d'un Joblet, Talaxie compare cette copie dans tous les jobs et Joblets du projet. Ceux qui s'en écartent sont listés dans la fenêtre Détection des mises à jour, par une ligne comme : Each Joblet dropped into a job keeps a copy of the schema of its OUTPUTs. When a Joblet is saved, Talaxie compares this copy in all the jobs and Joblets of the project. Those that differ are listed in the Update detection window, with a line such as:

JBL_Normalise_1 (OUTPUT_1) : schéma repris de JBL_NormaliseJBL_Normalise_1 (OUTPUT_1): schema taken from JBL_Normalise

Cochez les jobs à mettre à jour : le Joblet du job reçoit les nouvelles colonnes, et le composant qui le suit aussi s'il avait celles du lien ; un composant qui a son propre schéma, ou un schéma du référentiel, garde le sien. La même vérification a lieu à l'ouverture d'un job et par le menu ⋮ › Détecter les mises à jour des jobs. Tick the jobs to update: the Joblet of the job gets the new columns, and so does the component that follows it if it had those of the link; a component with its own schema, or a repository schema, keeps it. The same check runs when a job is opened and from the ⋮ › Detect job updates menu.

Ce qu'il reste à faire dans les jobsWhat remains to be done in the jobs

Composants, réglages, code du JobletComponents, settings, code of the JobletRien.Nothing.
Colonnes d'un OUTPUTColumns of an OUTPUTValider la détection des mises à jour.Confirm the update detection.
Colonnes attendues en entréeColumns expected as inputRien n'est signalé : adaptez le flux du job. Une colonne qui manque empêche le job de compiler.Nothing is reported: adapt the job flow. A missing column prevents the job from compiling.
Point de sortie ajoutéOutput addedIl apparaît dans les menus du Joblet : tracez son lien.It appears in the Joblet menus: draw its link.
Point de sortie suppriméOutput removedLe lien du job qui en partait est en erreur : une pastille rouge sur le Joblet le signale, et la génération s'arrête en le nommant. Supprimez-le.The job link that left it is in error: a red badge on the Joblet reports it, and the generation stops and names it. Delete it.
INPUT ajoutéINPUT addedReliez-lui un flux : un INPUT sans flux laisse ses composants sans entrée.Connect a flow to it: an INPUT without a flow leaves its components without input.
Type du lien vers un TRIGGER_OUTPUT, variable de contexteType of the link to a TRIGGER_OUTPUT, context variableRien : ils sont lus dans le Joblet.Nothing: they are read in the Joblet.
OrganiserOrganize CommentHow EffetEffect
DossiersFolders Clic droit sur la section Joblets ou un dossier › Créer un dossier ; glissez les Joblets dedans.Right-click the Joblets section or a folder › Create folder; drag the Joblets into it. Les jobs retrouvent un Joblet par son nom, où qu'il soit rangé. Un dossier se renomme, et se supprime une fois vide.Jobs find a Joblet by its name, wherever it is stored. A folder can be renamed, and deleted once empty.
RenommerRename Clic droit sur le Joblet › Renommer.Right-click the Joblet › Rename. Toutes ses versions sont renommées, et les jobs et Joblets du projet qui l'utilisent suivent. Dans ces jobs, le Joblet garde son nom unique (JBL_Version_1) : les variables globales déjà citées restent valables.All its versions are renamed, and the jobs and Joblets of the project that use it follow. In those jobs, the Joblet keeps its unique name (JBL_Version_1): global variables already referenced remain valid.
DupliquerDuplicate Clic droit › Dupliquer, puis un nom.Right-click › Duplicate, then a name. Toutes les versions sont copiées sous ce nom, dans le même dossier. Les jobs restent sur l'original.All the versions are copied under this name, in the same folder. Jobs stay on the original.
SupprimerDelete Clic droit › Supprimer. La fenêtre liste les versions concernées, puis les jobs et Joblets qui l'utilisent ; la case Supprimer définitivement (sans passer par la corbeille) efface les fichiers.Right-click › Delete. The window lists the versions affected, then the jobs and Joblets that use it; the Delete permanently (skip the recycle bin) checkbox erases the files. Sans la case, le Joblet va à la Corbeille : il quitte la palette, son nom reste pris, et les jobs qui l'utilisent ne se génèrent plus (« Le Joblet … est dans la corbeille »). Dans la Corbeille, clic droit › Restaurer le remet en place avec toutes ses versions ; Supprimer l'efface. Une fois effacé, ces jobs s'arrêtent sur « Composant introuvable ».Without the checkbox, the Joblet goes to the Recycle bin: it leaves the palette, its name stays taken, and the jobs that use it are no longer generated ("Le Joblet … est dans la corbeille"). In the Recycle bin, right-click › Restore puts it back with all its versions; Delete erases it. Once erased, these jobs stop with "Composant introuvable".
Versions Joblet ouvert, onglet Job › Principal : choisissez la version, puis Appliquer.With the Joblet open, Job tab › Main: choose the version, then Apply. Le Joblet est enregistré, et la nouvelle version, créée à partir de lui, s'ouvre à sa place ; l'ancienne reste telle quelle. Les jobs passent à la nouvelle version.The Joblet is saved, and the new version, created from it, opens in its place; the former one stays as it was. Jobs switch to the new version.

Variables de contexte et routinesContext variables and routines

Variables de contexteContext variables

  • Un Joblet a son onglet Contexte, comme un job : variables, environnements, groupes du référentiel. Ses composants les lisent par context.nom. A Joblet has its Context tab, like a job: variables, environments, repository groups. Its components read them with context.name.
  • À la génération, les variables du Joblet que le job n'a pas lui sont ajoutées, dans chacun de ses environnements. La valeur vient de l'environnement de même nom du Joblet, sinon de son premier environnement. At generation, the Joblet variables that the job does not have are added to it, in each of its environments. The value comes from the Joblet environment of the same name, otherwise from its first environment.
  • Si le job a une variable du même nom, c'est la sienne qui compte : le job peut ainsi fixer la valeur qu'emploiera le Joblet. If the job has a variable with the same name, the job one wins: this is how a job sets the value the Joblet will use.
  • Un Joblet peut aussi lire une variable que seul le job définit. Si ni l'un ni l'autre ne la définit, le job ne compile pas. A Joblet can also read a variable that only the job defines. If neither defines it, the job does not compile.
  • Un job a un seul jeu de variables : on ne donne pas à un Joblet un groupe de contextes à part en le déposant sur lui. A job has a single set of variables: a Joblet cannot be given a separate context group by dropping one on it.

Avec le Joblet JBL_Etiquette des exemples, dont la variable prefixe vaut CLI- dans Default et PRD- dans PRD : With the JBL_Etiquette Joblet of the examples, whose prefixe variable is CLI- in Default and PRD- in PRD:

Job sans la variable, environnement DefaultJob without the variable, Default environmentCLI-00042|Durand
Le même, lancé dans PRDThe same, run in PRDPRD-00042|Durand
Le même, lancé dans REC, que le Joblet n'a pasThe same, run in REC, which the Joblet does not haveCLI-00042|Durand
Job qui définit prefixe = FOU-Job that defines prefixe = FOU-FOU-00042|Durand

Routines et dépendances de codeRoutines and code dependencies

  • Le code d'un Joblet appelle les routines système et celles du projet comme celui d'un job : Formats.code(input_row.id). Joblet code calls the system routines and the project routines like job code does: Formats.code(input_row.id).
  • Il n'y a rien à déclarer sur le Joblet. À l'exécution comme à la construction, Talaxie compile avec le job les routines du projet que son code nomme, et celui des Joblets en fait partie. There is nothing to declare on the Joblet. At run time as well as at build time, Talaxie compiles with the job the project routines that its code names, and the Joblet code is part of it.
  • Les dépendances de routines inscrites dans le fichier d'un Joblet (par le Studio Talend, ou par « Refactoriser en Joblet ») sont ajoutées à celles du job à la génération. The routine dependencies written in a Joblet file (by Talend Studio, or by "Refactor to Joblet") are added to those of the job at generation.

La routine de l'exemple :The routine of the example:

package routines;

public class Formats {

    /** Code sur cinq chiffres : 42 donne 00042. */
    public static String code(Integer id) {
        return String.format("%05d", id);
    }
}

ExemplesExamples

Sept jobs exécutés tels quels avec Talaxie 9 sous Java 21. Les consoles sont celles des exécutions, sans les lignes communes à tous les jobs (étapes du lancement, [statistics]). Les schémas reprennent l'affichage de la grille : sous l'icône d'un Joblet déposé dans un job se lit le nom du Joblet, pas son nom unique. Seven jobs run as is with Talaxie 9 on Java 21. The consoles are those of the runs, without the lines common to every job (launch steps, [statistics]). The diagrams follow the canvas display: below the icon of a Joblet dropped in a job is the name of the Joblet, not its unique name.

1. Joblet de flux1. Flow Joblet

JBL_Normalise row1 row2 INPUT_1 tJavaRow_1 OUTPUT_1

Les trois ont le schéma id (Integer), nom, ville (String). Code du tJavaRow_1 :All three have the schema id (Integer), nom, ville (String). tJavaRow_1 code:

output_row.id = input_row.id;
output_row.nom = input_row.nom.trim().toUpperCase();
output_row.ville = input_row.ville.trim();
JOB_Flux row1 row2 OnSubjobOk tFixedFlowInput_1 JBL_Normalise tLogRow_1 tJava_1

Trois lignes en entrée ( durand , Martin, petit, avec des espaces). Le tJava_1 du job lit la variable globale d'un composant du Joblet :Three input rows ( durand , Martin, petit, with spaces). The job tJava_1 reads the global variable of a Joblet component:

System.out.println("lignes traitées par le Joblet : "
    + globalMap.get("JBL_Normalise_1_tJavaRow_1_NB_LINE"));
1|DURAND|Lyon
2|MARTIN|Nantes
3|PETIT|Lille
lignes traitées par le Joblet : 3

2. Joblet à déclencheurs2. Trigger Joblet

JBL_Preparation OnSubjobOk OnSubjobOk TRIGGER_INPUT_1 tJava_1 TRIGGER_OUTPUT_1

INPUT_1 et OUTPUT_1 ont été supprimés. Code du tJava_1 du Joblet :INPUT_1 and OUTPUT_1 were deleted. Code of the Joblet tJava_1:

String lot = "LOT-0042";
globalMap.put("lot", lot);
System.out.println("2. dans le Joblet : lot " + lot + " ouvert");
JOB_Declencheurs OnSubjobOk OnSubjobOk (TRIGGER_OUTPUT_1) tJava_1 JBL_Preparation tJava_2

Le tJava_2 du job affiche globalMap.get("lot"), posé par le Joblet :The job tJava_2 prints globalMap.get("lot"), set by the Joblet:

1. avant le Joblet
2. dans le Joblet : lot LOT-0042 ouvert
3. après le Joblet : lot = LOT-0042

Même console avec un lien On Component Ok vers le Joblet. Avec un Run if dont la condition est fausse (1 + 1 == 3), le Joblet et la suite ne s'exécutent pas :Same console with an On Component Ok link to the Joblet. With a Run if whose condition is false (1 + 1 == 3), the Joblet and what follows do not run:

1. avant le Joblet

3. Le même Joblet deux fois3. The same Joblet twice

JOB_DeuxFois row1 row2 OnSubjobOk row3 row4 OnSubjobOk tFixedFlowInput_1 JBL_Normalise tLogRow_1 tFixedFlowInput_2 JBL_Normalise tLogRow_2 tJava_1

Sous leur icône, les deux Joblets portent le même nom ; leurs noms uniques sont JBL_Normalise_1 (en haut) et JBL_Normalise_2.Below their icon, both Joblets show the same name; their unique names are JBL_Normalise_1 (top) and JBL_Normalise_2.

Deux clients, puis trois fournisseurs. Chaque dépôt du Joblet a ses variables :Two customers, then three suppliers. Each drop of the Joblet has its own variables:

System.out.println("clients : " + globalMap.get("JBL_Normalise_1_tJavaRow_1_NB_LINE") + " lignes");
System.out.println("fournisseurs : " + globalMap.get("JBL_Normalise_2_tJavaRow_1_NB_LINE") + " lignes");
1|DURAND|Lyon
2|MARTIN|Nantes
7|LEROY|Brest
8|MOREAU|Dijon
9|SIMON|Reims
clients : 2 lignes
fournisseurs : 3 lignes

4. Variable de contexte et routine4. Context variable and routine

JBL_Etiquette row1 row2 INPUT_1 tJavaRow_1 OUTPUT_1
  • Onglet Contexte du Joblet : prefixe (String) = CLI-.Context tab of the Joblet: prefixe (String) = CLI-.
  • INPUT_1 : id (Integer), nom ; tJavaRow_1 et OUTPUT_1 : code, nom.INPUT_1: id (Integer), nom; tJavaRow_1 and OUTPUT_1: code, nom.
  • Routine du projet Formats (voir plus haut).Project routine Formats (see above).
output_row.code = context.prefixe + Formats.code(input_row.id);
output_row.nom = input_row.nom;
JOB_Contexte row1 row2 tFixedFlowInput_1 JBL_Etiquette tLogRow_1

Le job n'a ni variable de contexte ni réglage pour la routine. Lignes 42;Durand et 7;Martin :The job has neither a context variable nor a setting for the routine. Rows 42;Durand and 7;Martin:

CLI-00042|Durand
CLI-00007|Martin

Construit en archive, puis lancé par son .bat, le job donne les mêmes lignes ; son fichier contexts/Default.properties contient prefixe=CLI-.Built as an archive, then launched with its .bat, the job gives the same lines; its contexts/Default.properties file contains prefixe=CLI-.

5. Refactoriser en Joblet5. Refactor to Joblet

Avant. Trois commandes (id, article, quantite, prix) ; le tFilterRow garde input_row.quantite > 0, le tMap calcule total = row2.quantite * row2.prix.Before. Three orders (id, article, quantite, prix); the tFilterRow keeps input_row.quantite > 0, the tMap computes total = row2.quantite * row2.prix.

JOB_Refactor row1 row2 out1 OnSubjobOk tFixedFlowInput_1 tFilterRow_1 tMap_1 tLogRow_1 tJava_1
1;stylo;10;1.5
2;cahier;0;3.2
3;classeur;4;2.75

Le tJava_1 affiche globalMap.get("tFilterRow_1_NB_LINE_REJECT") :tJava_1 prints globalMap.get("tFilterRow_1_NB_LINE_REJECT"):

stylo|15.0
classeur|11.0
lignes écartées : 1

Après. Sélection de tFilterRow_1 et de tMap_1, clic droit › Refactoriser en Joblet, nom JBL_Total.After. Selection of tFilterRow_1 and tMap_1, right-click › Refactor to Joblet, name JBL_Total.

JBL_Total row1 row2 out1 INPUT_1 tFilterRow_1 tMap_1 OUTPUT_1
JOB_Refactor row1 out1 OnSubjobOk tFixedFlowInput_1 JBL_Total tLogRow_1 tJava_1

Les lignes sont les mêmes. Le code du tJava_1, resté dans le job, a suivi : il lit maintenant globalMap.get("JBL_Total_1_tFilterRow_1_NB_LINE_REJECT").The rows are the same. The code of tJava_1, which stayed in the job, followed: it now reads globalMap.get("JBL_Total_1_tFilterRow_1_NB_LINE_REJECT").

stylo|15.0
classeur|11.0
lignes écartées : 1

6. Deux sorties de flux6. Two flow outputs

JBL_Tri row1 row2 row3 INPUT_1 tFilterRow_1 OUTPUT_1 OUTPUT_2

row2 est la sortie Filter du tFilterRow_1 ; row3, en rouge, sa sortie Reject.row2 is the Filter output of tFilterRow_1; row3, in red, its Reject output.

Même condition, input_row.quantite > 0. Les schémas des deux OUTPUT ont été posés par Propager… depuis le tFilterRow ; celui d'OUTPUT_2 a la colonne errorMessage du rejet.Same condition, input_row.quantite > 0. The schemas of both OUTPUTs were set with Propagate… from the tFilterRow; the OUTPUT_2 one has the errorMessage column of the reject.

JOB_DeuxSorties row1 row2 row3 tFixedFlowInput_1 JBL_Tri tLogRow_1 tLogRow_2

row2 part d'OUTPUT_1, row3 d'OUTPUT_2.row2 leaves OUTPUT_1, row3 leaves OUTPUT_2.

Mêmes commandes que l'exemple 5 ; le tLogRow_2 est en mode tableau :Same orders as example 5; tLogRow_2 is in table mode:

1|stylo|10|1.5
3|classeur|4|2.75
.--+-------+--------+----+-------------------------.
|                    tLogRow_2                     |
|=-+-------+--------+----+------------------------=|
|id|article|quantite|prix|errorMessage             |
|=-+-------+--------+----+------------------------=|
|2 |cahier |0       |3.2 |advanced condition failed|
'--+-------+--------+----+-------------------------'

7. Deux sorties de déclenchement7. Two trigger outputs

JBL_Controle OnSubjobOk OnSubjobOk OnSubjobError TRIGGER_INPUT_1 tJava_1 TRIGGER_OUTPUT_1 TRIGGER_OUTPUT_2
if (!"oui".equals(globalMap.get("valide"))) {
    throw new RuntimeException("contrôle refusé");
}
System.out.println("contrôle réussi");
JOB_ControleOk OnSubjobOk OnSubjobOk (TRIGGER_OUTPUT_1) OnSubjobOk (TRIGGER_OUTPUT_2) tJava_1 JBL_Controle tJava_2 tJava_3

Le tJava_1 du job pose valide. Avec "oui" :The job tJava_1 sets valide. With "oui":

contrôle réussi
suite normale

Avec "non", c'est le lien de TRIGGER_OUTPUT_2 qui part, bien qu'il s'appelle OnSubjobOk dans le job (suite de la pile d'appels coupée) :With "non", the TRIGGER_OUTPUT_2 link fires, although it is called OnSubjobOk in the job (rest of the stack trace cut):

Exception in component JBL_Controle_1_tJava_1 (JOB_ControleErreur)
java.lang.RuntimeException: contrôle refusé
	at demo.job_docjb_controleerreur_0_1.JOB_ControleErreur.JBL_Controle_1_tJava_1Process(JOB_ControleErreur.java:629)
	…
traitement de l'erreur

Compatibilité et différences avec le Studio TalendCompatibility and differences with Talend Studio

Les Joblets de Talaxie reprennent le format de fichier et le principe de ceux du Studio Talend, pas toute leur interface. La colonne « Studio Talend » résume son guide d'utilisation ; la colonne « Talaxie 9 » dit ce que fait Talaxie. Talaxie Joblets take over the file format and the principle of those of Talend Studio, not their whole interface. The "Talend Studio" column summarizes its user guide; the "Talaxie 9" column says what Talaxie does.

SujetTopic Studio TalendTalend Studio Talaxie 9
DisponibilitéAvailability Éditions payantes.Paid editions. Inclus, sans plugin ni licence. Le Studio Talaxie 8 ne les a pas.Included, with no plugin and no license. Talaxie Studio 8 does not have them.
RéférentielRepository Nœud Joblets sous Job Designs ; création depuis Job Designs ou Joblets.Joblets node under Job Designs; creation from Job Designs or Joblets. Section Joblets, à côté de Jobs ; création par clic droit sur cette section.Joblets section, next to Jobs; creation with a right-click on this section.
Fenêtre de créationCreation window Name, Purpose, Description, Author, Locker, Version, Status, Path. Nom, Objectif, Description, Créé par, Version, Chemin d'accès : ni Locker ni Status.Name, Purpose, Description, Created by, Version, Location: no Locker, no Status.
Dessin dans le jobDrawing in the job Cadre en pointillés sur fond vert ; [+] déplie le Joblet, dont les composants se règlent depuis le job.Dotted frame on a green background; [+] expands the Joblet, whose components can be set from the job. Une icône et un nom ; pas de dépliage. Le Joblet se modifie dans son onglet (double clic).An icon and a name; no expanding. The Joblet is edited in its tab (double-click).
Début de jobBeginning of a job Case Startable (onglet Joblet › Extra).Startable checkbox (Joblet tab › Extra). Pas de case, et rien à régler.No checkbox, and nothing to set.
Déclencheurs acceptés en entréeTriggers accepted as input Les types de liens employés dans le Joblet à la sortie de Trigger Input.The link types used in the Joblet at the output of Trigger Input. Tout déclencheur ; le type appliqué est celui du lien du job.Any trigger; the type applied is that of the job link.
Déclencheurs offerts en sortieTriggers offered as output Les types de liens employés dans le Joblet vers Trigger Output.The link types used in the Joblet towards Trigger Output. Un lien « OnSubjobOk (TRIGGER_OUTPUT_n) » par point de sortie ; le type appliqué est celui du lien du Joblet.One "OnSubjobOk (TRIGGER_OUTPUT_n)" link per output; the type applied is that of the Joblet link.
Plusieurs Trigger InputSeveral Trigger Inputs Champ Attached node pour rattacher chaque lien.Attached node field to attach each link. Champ Composant attaché à TRIGGER_INPUT_n dans les paramètres du Joblet ; chaque lien tracé prend le premier point d'entrée libre (voir Plusieurs entrées).Node attached to TRIGGER_INPUT_n field in the Joblet settings; each link drawn takes the first free entry point (see Several inputs).
Version Liste Version sur le Joblet, dans le job.Version list on the Joblet, in the job. Pas de liste : la dernière version.No list: the latest version.
ContexteContext Un groupe de contextes se dépose sur le Joblet, dans le job, pour lui donner d'autres variables.A context group can be dropped on the Joblet, in the job, to give it other variables. Les variables du Joblet s'ajoutent à celles du job ; un seul jeu de variables par job.The Joblet variables are added to those of the job; a single set of variables per job.
Routines Dépendance de code à déclarer sur le Joblet.Code dependency to be declared on the Joblet. Rien à déclarer.Nothing to declare.
Après une modificationAfter a change Mettre à jour les jobs quand un lien de déclenchement du Joblet change.Update the jobs when a trigger link of the Joblet changes. Les liens sont relus à chaque génération ; seule la copie du schéma des sorties se met à jour, par la détection.Links are read again at each generation; only the copy of the output schemas is updated, through the detection.
Joblets Spark, RouteletsSpark Joblets, Routelets Joblets Spark pour les jobs Spark ; Routelets pour les routes.Spark Joblets for Spark jobs; Routelets for routes. Ni les uns ni les autres : Joblets des jobs standard seulement.Neither: Joblets of standard jobs only.

Fichiers et compatibilitéFiles and compatibility

  • Même emplacement et même format que le Studio Talend : joblets/<Nom>_<version>.item et son .properties. Le fichier contient le Joblet (model:JobletProcess, composants de liaison en jobletNodes) et son icône. Same location and same format as Talend Studio: joblets/<Name>_<version>.item and its .properties. The file holds the Joblet (model:JobletProcess, port components as jobletNodes) and its icon.
  • Talaxie lit un Joblet écrit par le Studio Talend et montre son icône ; Importer des éléments reprend le dossier joblets d'une archive. Talaxie reads a Joblet written by Talend Studio and shows its icon; Import items takes the joblets folder of an archive.
  • Quand Talaxie enregistre un Joblet venu du Studio Talend, la signature que celui-ci avait placée dans le fichier est retirée : elle ne correspondrait plus au contenu. When Talaxie saves a Joblet coming from Talend Studio, the signature the latter had put in the file is removed: it would no longer match the content.
  • Dans un job, le Joblet est un composant qui porte son nom ; ses liens sortants nomment le point de sortie (OUTPUT_1, TRIGGER_OUTPUT_1). In a job, the Joblet is a component bearing its name; its outgoing links name the output (OUTPUT_1, TRIGGER_OUTPUT_1).
  • Non vérifié : la réouverture, dans le Studio Talend, d'un Joblet ou d'un job à Joblet enregistrés par Talaxie. Not verified: reopening, in Talend Studio, a Joblet or a job with a Joblet saved by Talaxie.

Limites actuellesCurrent limits

  • Entrées de flux dans l'ordre. On ne choisit pas quel flux du job va à quel INPUT : le premier tracé va à INPUT_1. Flow inputs in order. You cannot choose which job flow goes to which INPUT: the first one drawn goes to INPUT_1.
  • Pas de contrôle du Joblet seul : ni compilation ni exécution sans un job. No check of the Joblet alone: no compilation and no run without a job.

Jusqu'à Talaxie 9.0.6 : un tMap à Lookup dans un Joblet, ou un Lookup à travers un INPUT ou un OUTPUT, empêchait le job de compiler ; un Joblet désactivé s'exécutait quand même ; OUTPUT ne prenait pas le schéma du flux relié ; plusieurs liens pouvaient partir d'un même OUTPUT ; avec plusieurs TRIGGER_INPUT, seul le premier se rattachait ; un Joblet à la corbeille servait encore et ne se restaurait pas ; une version demandée mais absente arrêtait la génération ; après « Refactoriser en Joblet », le code resté dans le job gardait l'ancien nom des variables globales. Up to Talaxie 9.0.6: a tMap with a Lookup in a Joblet, or a Lookup through an INPUT or an OUTPUT, prevented the job from compiling; a deactivated Joblet still ran; OUTPUT did not take the schema of the connected flow; several links could leave the same OUTPUT; with several TRIGGER_INPUT, only the first one was attached; a Joblet in the recycle bin was still used and could not be restored; a requested but missing version stopped the generation; after "Refactor to Joblet", the code left in the job kept the old name of the global variables.

Erreurs courantesCommon errors

Une erreur de génération s'affiche dans la console après « Échec de l'exécution : », sur une ligne Exception in thread "main" java.lang.IllegalStateException: … suivie d'une pile d'appels ; une erreur de compilation, après « Échec de la compilation du job : ». Les messages du générateur sont en français quelle que soit la langue de l'interface. A generation error is shown in the console after "Run failed:", on a line Exception in thread "main" java.lang.IllegalStateException: … followed by a stack trace; a compilation error, after "The job failed to compile:". The generator messages are in French whatever the interface language.

Message ou symptômeMessage or symptom CauseCause Que faireWhat to do
Joblet JBL_Preparation : le lien row1 vers TRIGGER_OUTPUT_1 est un flux, alors que ce point de sortie ne reçoit qu'un déclencheur (OnSubjobOk, OnComponentOk…) Dans le fichier du Joblet, un flux arrive sur un TRIGGER_OUTPUT. L'éditeur refuse ce lien : le fichier vient d'ailleurs ou d'une version plus ancienne.In the Joblet file, a flow reaches a TRIGGER_OUTPUT. The editor refuses this link: the file comes from elsewhere or from an older version. Ouvrez le Joblet, supprimez le lien et tracez un déclencheur.Open the Joblet, delete the link and draw a trigger.
Joblet JBL_Normalise : le lien OnComponentOk vers OUTPUT_1 est un déclencheur, alors que ce point de sortie ne reçoit qu'un flux L'inverse : un déclencheur arrive sur un OUTPUT.The reverse: a trigger reaches an OUTPUT. Reliez un flux à OUTPUT, et le déclencheur à un TRIGGER_OUTPUT.Connect a flow to OUTPUT, and the trigger to a TRIGGER_OUTPUT.
Composant introuvable : JBL_Absent Le job utilise un Joblet qui n'est plus dans le projet (effacé, corbeille vidée).The job uses a Joblet that is no longer in the project (erased, recycle bin emptied). Recréez ou réimportez le Joblet sous ce nom, ou retirez-le du job.Recreate or reimport the Joblet under this name, or remove it from the job.
Joblets imbriqués sans fin Des Joblets se contiennent en boucle (A contient B, qui contient A).Joblets contain each other in a loop (A contains B, which contains A). Retirez l'un des deux de l'autre.Remove one of them from the other.
error: cannot find symbol
row2.ville = row1.ville;
symbol: variable ville
location: variable row1 of type row1Struct
Le flux que le job envoie au Joblet n'a pas une colonne dont ses composants se servent.The flow the job sends to the Joblet lacks a column that its components use. Donnez au flux du job les colonnes du schéma de l'INPUT.Give the job flow the columns of the INPUT schema.
error: cannot find symbol
symbol: variable site
location: variable context of type JOB_ContexteAbsent.ContextProperties
Le Joblet lit context.site, que ni lui ni le job ne définissent.The Joblet reads context.site, which neither it nor the job defines. Ajoutez la variable dans l'onglet Contexte du Joblet, ou du job.Add the variable in the Context tab of the Joblet, or of the job.
error: cannot find symbol
symbol: variable input_row
Un INPUT du Joblet n'a pas de flux dans le job : le tJavaRow qui le suit n'a plus d'entrée.An INPUT of the Joblet has no flow in the job: the tJavaRow after it no longer has an input. Reliez un flux pour chaque INPUT.Connect a flow for each INPUT.
Le Joblet JBL_Normalise est dans la corbeille : restaurez-le, ou retirez-le du job. Le job utilise un Joblet envoyé à la corbeille.The job uses a Joblet sent to the recycle bin. Dans la Corbeille du référentiel, clic droit sur le Joblet › Restaurer ; ou retirez-le du job.In the Recycle bin of the repository, right-click the Joblet › Restore; or remove it from the job.
Exception in component JBL_Controle_1_tJava_1 (JOB_ControleErreur) Une erreur à l'exécution dans le composant tJava_1 du Joblet déposé sous le nom JBL_Controle_1.A runtime error in the tJava_1 component of the Joblet dropped under the name JBL_Controle_1. Cliquez sur le nom dans la console pour retrouver le Joblet, puis ouvrez-le.Click the name in the console to find the Joblet, then open it.
Le tLogRow placé après le Joblet affiche des lignes vides.The tLogRow placed after the Joblet prints empty lines. Le schéma de l'OUTPUT est vide dans le Joblet : le composant du job n'a reçu aucune colonne.The OUTPUT schema is empty in the Joblet: the job component received no column. Renseignez le schéma de l'OUTPUT, enregistrez, puis validez la détection des mises à jour.Fill in the OUTPUT schema, save, then confirm the update detection.
Joblet JBL_Tri : le lien row3 du job part de OUTPUT_2, qui n'est pas un point de sortie de ce Joblet. Supprimez ce lien dans le job, puis tracez-le depuis une sortie du Joblet. Un lien du job part d'un point de sortie que le Joblet n'a plus. Le Joblet porte aussi une pastille rouge dans le job.A job link leaves an output that the Joblet no longer has. The Joblet also carries a red badge in the job. Supprimez le lien, puis retracez-le depuis une sortie du menu du Joblet.Delete the link, then draw it again from an output of the Joblet menu.

À retenirKey points

  • Un Joblet est remplacé par ses composants à chaque génération : il n'existe pas dans le code du job, seuls ses composants y sont, sous le nom <Joblet>_<n>_<composant>. A Joblet is replaced with its components at each generation: it does not exist in the job code, only its components do, under the name <Joblet>_<n>_<component>.
  • Renseignez le schéma de chaque OUTPUT, et donnez au Joblet un TRIGGER_OUTPUT s'il doit être suivi d'un autre sous-job. Fill in the schema of each OUTPUT, and give the Joblet a TRIGGER_OUTPUT if another subjob must follow it.
  • Les types des déclencheurs se lisent au bon endroit : en entrée, sur le lien du job ; en sortie, sur le lien du Joblet. Trigger types are read in the right place: for an input, on the job link; for an output, on the Joblet link.
  • Le job et ses Joblets partagent les variables de contexte et la globalMap ; à nom égal, la variable de contexte du job l'emporte. The job and its Joblets share the context variables and the globalMap; for the same name, the job context variable wins.
  • Après avoir modifié un Joblet, lancez un job qui l'utilise : c'est là que ses erreurs apparaissent. After changing a Joblet, run a job that uses it: that is where its errors show up.