Add docs for Python XC CLM
[releng/global-jjb.git] / docs / best-practices.rst
1 .. _global-jjb-best-practices:
2
3 ##############
4 Best Practices
5 ##############
6
7 JJB YAML Layout
8 ===============
9
10 .. note::
11
12     While some of this applies to the Global JJB project other recommendations
13     are generally useful to projects that might be defining JJB templates.
14
15 The Global JJB project is a useful example project to look at so we recommend
16 referring to the Maven job definitions as an example as you read the
17 documentation below:
18
19 https://github.com/lfit/releng-global-jjb/blob/master/jjb/lf-maven-jobs.yaml
20
21 We recommend sectioning off the template into 3 general sections in order:
22
23 1. Job Groups (optional)
24 2. Common Functions
25 3. Job Template Definitions
26
27 In section 1) not all configurations need this so is an optional section. Job
28 groups are useful in cases where there are jobs that are generally useful
29 together. For example the OpenDaylight uses a lot of Merge and Verify job
30 combinations so every new project will want both job types defined in their
31 project.
32
33 In section 2) we want to define all common functions (anchors, aliases, macros)
34 that are generally useful to all jobs in the file. This allows job template
35 developers to look at the top of the file to see if there are useful functions
36 already defined that they can reuse.
37
38 In section 3) we can declare our job definitions. In the Global JJB project we
39 create Gerrit and GitHub versions of the jobs so the format we use here
40 might look strange at first but is well layed out for code reuse if we need to
41 define 2 or more versions of the same job template for different systems. We
42 will define this in more detail in the next section.
43
44 Job Template Layout
45 -------------------
46
47 1. Comment of Job Template Name
48 2. Macro containing build definition of the job
49    a. Macro named after job
50    b. Complete documentation of the job parameters
51    c. Default parameters defined by the job
52    d. Job configuration
53 3. job-template definition containing build triggers
54
55 In section 1) we need to declare a in large comment text to identify the job
56 section.
57
58 In section 2) we declare the actual job definition. This is so that we have a
59 single macro that we call in all the real job-template sections that is
60 reusable and not duplicating any code. First we declare the macro as the job
61 name. Then in 2.b) we provide the complete documentation of the job parameters
62 this is so that we can link users of the job to this file and they can
63 understand fully what options they can configure for this particular job.
64 Then we define defaults for any parameters that are optional. The last section
65 we define the job configuration which completes the macro.
66
67 In section 3) we declare the actual job-template. Because of all the
68 preparations above job template definitions should be small and simple. It
69 needs to define the scm and job triggers. The Global JJB project needs to
70 support both Gerrit and GitHub versions of the same job so the job definitions
71 there have 2 templates for each job defined.
72
73
74 Passing parameters to shell scripts
75 ===================================
76
77 There are 2 ways to pass parameters into scripts:
78
79 1. JJB variables in the format {var}
80 2. Environment variables in the format ${VAR}
81
82 We recommend avoiding using method 1 (Pass JJB variables) into shell scripts
83 and instead always use method 2 (Environment variables). This makes
84 troubleshooting JJB errors easier and does not require escaping curly braces.
85
86 This method requires 3 steps:
87
88 1. Declare a parameter section or inject the variable as properties-content.
89 2. Invoke the shell script with `include-raw-escape` instead of `include-raw`.
90 3. Use the shell variable in shell script.
91
92
93 The benefit of this method is that parameters will always be at the top
94 of the job page and when clicking the Build with Parameters button in Jenkins
95 we can see the parameters before running the job. We can review the
96 parameters retro-actively by visiting the job parameters page
97 ``job/lastSuccessfulBuild/parameters/``. Injecting variables as
98 properties-content makes the variable local to the specific macro, while
99 declaring it as parameter makes the variable global.
100
101 .. note::
102
103     When a macro which invokes a shell script has no JJB parameters defined
104     `!include-raw-escape` will insert extra curly braces, in such cases its
105     recommended to use `!include-raw`.
106
107 Usage of config-file-provider
108 =============================
109
110 When using the config-file-provider plugin in Jenkins to provide a config file.
111 We recommend using a macro so that we can configure the builder to
112 remove the config file as a last step. This ensures
113 that credentials do not exist on the system for longer than it needs to.
114
115 ship-logs example:
116
117 .. code-block:: yaml
118
119     - builder:
120         name: lf-ship-logs
121         builders:
122           - config-file-provider:
123               files:
124                 - file-id: jenkins-log-archives-settings
125                   variable: SETTINGS_FILE
126           - shell: !include-raw:
127               - ../shell/logs-get-credentials.sh
128           - shell: !include-raw:
129               - ../shell/lftools-install.sh
130               - ../shell/logs-deploy.sh
131           - shell: !include-raw:
132               - ../shell/logs-clear-credentials.sh
133           - description-setter:
134               regexp: '^Build logs: .*'
135
136 In this example the script logs-deploy requires a config file to authenticate
137 with Nexus to push logs up. We declare a macro here so that we can ensure that
138 we remove credentials from the system after the scripts
139 complete running via the logs-clear-credentials.sh script. This script contains
140 3 basic steps:
141
142 1. Provide credentials via config-file-provider
143 2. Run the build scripts in this case lftools-install.sh and logs-deploy.sh
144 3. Remove credentials provided by config-file-provider
145
146 Preserving Objects in Variable References
147 =========================================
148
149 JJB has an option to preserve a data structure object when you want to pass
150 it to a template.
151 https://docs.openstack.org/infra/jenkins-job-builder/definition.html#variable-references
152
153 One thing that is not explicitly covered is the format of the variable name
154 that you pass the object to. When you use the `{obj:key}` notation to preserve
155 the original data structure object, it will not work if the variable name has a
156 dash `-` in it. The standard that we follow, and recommend, is to use an underscore
157 `_` instead of a dash.
158
159 Example:
160
161 .. code-block:: yaml
162
163     - triggers:
164        - lf-infra-github-pr-trigger:
165            trigger-phrase: ^remerge$
166            status-context: JJB Merge
167            permit-all: false
168            github-hooks: true
169            github-org: '{github-org}'
170            github_pr_whitelist: '{obj:github_pr_whitelist}'
171            github_pr_admin_list: '{obj:github_pr_admin_list}'
172
173 In the above example note the use of underscores in `github_pr_admin_list` and
174 `github_pr_admin_list`.
175
176 Using single quotes around variables
177 ====================================
178
179 Its recommended to use single quotes around JJB variables '{variable}-field'
180 during variable substitution or when using a variable in a string field, in
181 other cases its recommended to drop the single quotes.
182
183 Example:
184
185 .. code-block:: yaml
186
187     - builder:
188         name: lf-user-logs
189         builders:
190           - inject:
191               properties-content: |
192                   'HOME={user-home}'
193           - build-file:
194               settings: '{settings-file}'
195               file-version: '{file-version}'
196
197
198 Variable expansion and Defaults
199 ===============================
200
201 .. This documentation uses work originally provided by Thanh Ha on
202 .. the OpenDaylight dev mailing list.
203 .. https://lists.opendaylight.org/pipermail/dev/2017-October/004184.html
204
205 JJB has a concept called :ref:`Defaults <defaults>` which is what JJB will
206 replace a variable with if unset. Variables can configure dynamic content
207 in :ref:`job-template <job-template>` sections and allow certain options in
208 these sections to be configurable.
209
210 The section that expands Defaults is :ref:`Job Templates <job-template>` no
211 other sections will expand a default. This documentation will explain how
212 variables and defaults expansion works and which take precedence in JJB's
213 variable expansion logic for the following configuration sections.
214
215 - macro
216 - job-template
217 - project
218 - default
219
220 Macro sections
221 --------------
222
223 :ref:`Macro <macro>` sections can contain variables but do **NOT** support
224 default values getting filled in both at the macro definition level and at the
225 defaults configuration level. :ref:`Macros <macro>` and
226 :ref:`Job Templates <job-template>` can use Macros but any variables defined in
227 a Macro needs to pass a value or a new variable redefined in the
228 :ref:`Job Template <job-template>` if you want to pass on the configuration.
229
230 So for example if you have a macro that has a '{msg}' variable:
231
232 Example:
233
234 .. code-block:: yaml
235
236    - builder:
237        name: echo-msg
238        builders:
239          - shell: "echo {msg}"
240
241 Any downstream job-templates or macros that use this macro **MUST** pass in a
242 `msg: Hello` definition or redefine the msg variable `msg: {msg}`.
243
244
245 Job Template sections
246 ---------------------
247
248 :ref:`Job Template <job-template>` sections can use defaults in two ways.
249
250 1. Configure the message:
251
252    .. code-block:: yaml
253
254       - job-template:
255           name: echo-hello-world
256           builders:
257             - echo-msg:
258                 msg: 'Hello World'
259
260 2) Re-define '{msg}' variable
261
262    .. code-block:: yaml
263
264       - job-template:
265           name: echo-message
266           builders:
267             - echo-msg:
268                 msg: '{message}'
269
270 In option 2, we redefine the variable msg as `{message}` which a user of the
271 job-template can now pass into the job their own custom message which is
272 different than option 1, where we set a static message to pass in. We purposely
273 redefined the **{msg}** to **{message}** here to show that you do not need to
274 redefine it with the same name but we could have used the same name `{msg}` in
275 the template too if we wanted to keep it the same.
276
277 Job Templates can also default a default variable for the variables it defines.
278
279 Example:
280
281 .. code-block:: yaml
282
283     - job-template:
284       name: echo-message
285       message: 'Hello World'
286       builders:
287         - echo-msg:
288             msg: '{message}'
289
290 This creates a job template variable called '{message}' which will default to
291 "Hello World" if the user of the template does not explicitly pass in a message.
292
293 We should be aware of 2 Defaults concepts:
294
295 1. Default as defined in the :ref:`job-template <job-template>`
296 2. Default as defined in a :ref:`defaults <defaults>` configuration
297    (typically defaults.yaml)
298
299 In this case there is a default '{message}' set in the
300 :ref:`job-template <job-template>`. JJB will use this default if the user
301 (project section) does not declare a {message}.
302
303 If we do not declare a default in the :ref:`job-template <job-template>` then
304 JJB will fallback to checking the "defaults configuration".
305
306 This means that the precendence of defaults is as follows:
307
308 1. User-provided
309 2. Job Template
310 3. Defaults.yaml
311
312 Project sections
313 ----------------
314
315 :ref:`Project <project>` sections define real jobs and pass in variables as
316 necessary. Projects sections do NOT expand defaults.yaml. So you cannot
317 configure a setting with {var} in here and expect defaults.yaml to fill it in
318 for you. Define required configuration here.
319
320 Example:
321
322 .. code-block:: yaml
323
324    - project
325        name: foo
326        jobs:
327          - 'echo-message'
328        message: 'I am foo'
329
330
331 Defaults sections
332 -----------------
333
334 :ref:`Defaults <defaults>` sections are the absolute last thing JJB checks if a
335 variable is not configured in a job-template and user did not pass in the
336 variable. JJB will fill in whatever is in the defaults configuration.
337
338 Variable expansion order of precedence seems to be:
339
340 1. job-group section definition
341 2. project section definition
342 3. job-template variable definition
343 4. defaults.yaml variable definition
344
345 .. note:: Defaults set variables in job-templates and are NOT used in Macros.
346
347 global-jjb should not provide job-group definitions and leave it up to users of
348 global-jjb to create their own as a job-group as a variable defined in a job
349 group the highest precendence. Global JJB should strive to be purely a
350 job-template and macro library for downstream consumers.
351
352 Final thoughts
353 --------------
354
355 For any :ref:`Basic Job Configuration <job>` for example "concurrent", "jdk",
356 "node" etc... we cannot set defaults with the same name as JJB will not expand
357 them. To use "node" we need to give the variable for that setting a
358 different name such as "build-node" instead, if we want JJB to perform
359 expansion for those settings. This issue affects top level job configuration,
360 it does not appear to affect items below the top level such as calling a
361 builder, wrapper or parameter.