variables and include feature

Liquibase Flow files incorporate variables and include other Flow files or YAML files. These can be placed in the Flow file Header above stages:

globalVariables

globalVariables must be defined at the top of the Flow File with the syntax shown in the example Flow File. Each Action specified in the Flow File can reference a globalVariable as a command argument. This saves you time and keeps your Flow File tidy.

Example globalVariable

offlineRefUrl: "offline:postgres?snapshot=refSnapshot.json"

Example of globalVariable in use

cmdArgs: { url: "${offlineRefUrl}"}

Example Flow File with globalVariables

This flow file has cmdArgs, globalArgs and global variables. For this example, the user will need to update the url, user, and password variables to be valid for their environment.

(Place Flow File text here once the YAML formatting can be preserved.)

Reference System Environment Variables through globalVariables

globalVariables can reference System Environment Variables to provide values within a Flow file. Within the Flow file example below, notice that the command echos "Running Liquibase from $(LIQUIBASE_HOME)". This allows you to change environment variables as desired without changing the Flow file.

Note:  Place the environment variable you would like to reference between the parenthesis like so:"Running Liquibase from $(INSERT ENVIRONMENT VARIABLE HERE)"

stages:
    systemEnvironmentVariableSample:
        actions:
        - type: shell
            command: echo "Running Liquibase from ${LIQUIBASE_HOME}"

stageVariables

stageVariables work exactly like globalVariables except they are declared inside of each stage group. If you have the same variable declared as a globalVariable, the stageVariables are applied, not the globalVariable. For example, if you have a changelog globalVariable but need to specify a different changelog, you can apply that via a stageVariable. stageVariables always override globalVariables.

All variables, especially labels and context, must be specified in the Flow File with quotations to operate properly. If you want to run all changesets with or without labels, you must leave the label names quotes empty so you do not have to list all labels individually.

1
2
3
Default:
    stageVariables:
      LABELNAMES: ""

1
2
3
4
5
6
#
# Run the update
#
- type: liquibase
  command: update
  cmdArgs: {labels: "${LABELNAMES}"}

Include configured YAML files within a Flow File

Flow Files can include references to other YAML files with configuration by using the include section of the file. You need only create a variable name for the referenced YAML file and then reference the file title so that the Flow File can locate it.

The include variable should be in the following format:

username: actual-Username

The key is username and the value is actual-Username. To use the values defined in the included file in the Flow File, you need to reference the namespace and the key. For example:

cmdArgs: {username: "${username}"}

When the flow command executes, it will read the included file, locate the username key and substitute the value for that key into the Liquibase action. In the case of the key:value example here, the substitution results in ${postgresNamespace.user} becoming actual-Username. The Liquibase action executes using actual-Username as the user property.

Example of Flow File include functionality:

include:
- postgresNamespace: postgres-vars.yaml

To enable the functionality, you will then add the created variable name to the cmdArgs section or your changelog.

cmdArgs: { url: "${postgresNamespace.url}", username: "${postgresNamespace.user}", password: "${postgresNamespace.password}", changelog-file: "${postgresNamespace.changelogFile}"}

Example Flow File includes cmdArgs, globalArgs, and a referenced include file(YAML)

Copy

flow-with-include-global

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
##########           LIQUIBASE FLOW FILE               ##########
##########  learn more http://docs.liquibase.com/flow  ##########

## NOTE: This is an advanced example flowfile, compared to the other sample at examples/liquibase.flowfile.yaml
## Advanced options show in this file include:
## non-default name of 'liquibase.advanced.flow' (use by setting flowfile property to this name)
#### example for CLI: liquibase flow --flow-file=liquibase.advanced.flow
#### example for ENV Var: LIQUIBASE_FLOW_FLOW_FILE=liquibase.advanced.flow
## use of 'include' to inject namespaced yaml files of key:val variables
## use of globalVariables and stageVariables
## use of globalArgs and cmdArgs
## use of property substitution
## use of a nested flowfile (in this case in the endStage, but could be elsewhere)

## Bring in and namespace an external file with yaml 'key: val' pairs for use in this file
## The variables will be used as ${namespace.variablename}, seen in this example as $(DATES.THISDATE)
include:
  DATES: liquibase.flowvariables.yaml

## Set up some global variables for property substitution in ANY stage
globalVariables:
  PROJNAME: "MyFlowProject"

## Start the stages. There can be more than one, if desired.
stages:  
  
  ## The first stage. There can be more than one if desired.
  stage1:

    ## set up vars for property substitution in THIS stage only
    stageVariables:
      VERBOSESTATE: TRUE

    actions:
    
   #
   # Do a validate command 
   #
    - type: liquibase
      command: validate

   #
   # tell me what is pending a deployment
   #
    - type: liquibase
      command: status
      cmdArgs: {verbose: "${VERBOSESTATE}"}

   #
   # And then save a version in detail
   #
    - type: liquibase
      command: updatesql
      globalArgs: {outputfile: "${PROJNAME}-${DATES.THISDATE}-updatesql.log"}

   #
   # Quality Checks for changelog 
   #
    - type: liquibase
      command: checks run
      cmdArgs: {checks-scope: changelog}
   #
   # Run update
   #
    - type: liquibase
      command: update
      
   #
   # Quality Checks for database
   #
    - type: liquibase
      command: checks run
      cmdArgs: {checks-scope: database}
    
    ## Put your clean up and other actions for this stage in the afterActions
    afterActions:
    - type: liquibase
      command: history
      globalArgs: {outputfile: "${PROJNAME}-${DATES.THISDATE}-history.log"}

## Put your clean up and other actions for after success in all stage(s) above in the endStage
endStage:
  actions:
    - type: liquibase
      command: flow
      cmdArgs: {flowfile: liquibase.endstage.flow}
      
  afterActions: null