Running targets in "FAKE - F# Make"

API-Reference, Operators

Command line interface for the target module

If you use the Fake.Core.Target module and call Target.runOrDefault or Target.runOrList in your build script you will have the following CLI options:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 

Usage:
  fake-run --list
  fake-run --version
  fake-run --help | -h
  fake-run [target_opts] [target <target>] [--] [<targetargs>...]

Target Module Options [target_opts]:
    -t, --target <target>
                          Run the given target (ignored if positional argument 'target' is given)
    -e, --environment-variable <keyval> [*]
                          Set an environment variable. Use 'key=val'. Consider using regular arguments, see https://fake.build/core-targets.html 
    -s, --single-target    Run only the specified target.
    -p, --parallel <num>  Run parallel with the given number of tasks.

This means you can - for example - run fake run build.fsx --list or fake build --list to list your targets.

To run a target MyTarget you could use fake run build.fsx -t MyTarget or fake build target MyTarget (or the other way around fake run build.fsx target MyTarget)

All parameters after -- or target <target> are given to the target as paramters. Note that this feature needs to be enabled by using Target.runOrDefaultWithArguments instead of Target.runOrDefault!

Running specific targets

FAKE has a special param "target" which can be used to run specific targets in a build. We assume the following build script (build.fsx):

 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: 

#r "paket:
nuget Fake.Core.Target //"

open Fake.Core
Target.initEnvironment()

// *** Define Targets ***
Target.create "Clean" (fun p ->
    Trace.trace " --- Cleaning stuff --- "
)

Target.create "Build" (fun _ ->
    Trace.trace " --- Building the app --- "
)

Target.create "Deploy" (fun _ ->
    Trace.trace " --- Deploying app --- "
)

open Fake.Core.TargetOperators

// *** Define Dependencies ***
"Clean"
    ==> "Build"
    ==> "Deploy"

// *** Start Build ***
Target.runOrDefault "Deploy"

Now we have the following options:

• fake run build.fsx -t "Build" --> starts the Build target and runs the dependency Clean
• fake run build.fsx -t "Build" --single-target --> starts only the Build target and runs no dependencies
• fake run build.fsx -s -t Build --> starts only the Build target and runs no dependencies
• fake run build.fsx --> starts the Deploy target (and runs the dependencies Clean and Build)

Script with arguments

Example:

 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: 

let args = Target.getArguments() // use this at the top of your script instead of `Target.initEnvironment()`

// So some stuff depending on the args
match args with
| Some args ->
    Trace.tracefn "Arguments: %A" args
| None ->
    // This case happens when no execution is requested (for example `--list` for listing targets)
    // Even for empty arguments `Some [||]` is given, read docs for `Target.GetArguments()`
    // never execute any side-effects outside of targets when `None` is given. 
    // NOTE: IDE will only show targets defined in this code-path, so never define targets based on arguments or environment variables.
    ()

// Set your own variable/s based on the args
let myVerbose, myArg =
    match args with
    | Some args -> 
        // Or use Fake.Core.CommandLineParsing here: https://fake.build/core-commandlineparsing.html
        args |> Seq.contains "--myverbose",
        args |> Seq.contains "--arg"
    | None -> false

Target.create "Default" (fun _ ->
    if myArg then
        printfn "do something special" 
)


// Feature is opt-in in order to provide good error messages out of the box
// see https://github.com/fsharp/FAKE/issues/1896
Target.runOrDefaultWithArguments "Default"

Everything after the target will be interpreted as argument for the target:

• fake run build.fsx target MyTarget --arg --> --arg will be contained in args
• fake build -t MyTarget --arg --> --arg will be contained in args, because --arg is not a valid argument for the Fake.Core.Target (see command line spec above)

Targets with arguments

Example:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 

Target.create "MyTarget" (fun p ->
    // Access arguments given by command-line
    Trace.tracefn "Arguments: %A" p.Context.Arguments
)

// Feature is opt-in in order to provide good error messages out of the box
// see https://github.com/fsharp/FAKE/issues/1896
Target.runOrDefaultWithArguments "Deploy"

Everything after the target will be interpreted as argument for the target:

• fake run build.fsx target MyTarget --arg --> --arg will be contained in p.Context.Arguments
• fake build -t MyTarget --arg --> --arg will be contained in p.Context.Arguments, because --arg is not a valid argument for the Fake.Core.Target (see command line spec above)

You can access the arguments from every target executed along the way.

Setting build status

You can set the build status automatically using Target.updateBuildStatus. To do this you need to use the Target.WithContext functions to run a target and retrieve the context information:

Example:

 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: 

#r "paket:
nuget Fake.Core.Target //"

open Fake.Core
Target.initEnvironment()

// *** Define Targets ***
Target.create "Clean" (fun p ->
    Trace.trace " --- Cleaning stuff --- "
)

Target.create "Build" (fun _ ->
    Trace.trace " --- Building the app --- "
)

Target.create "Deploy" (fun _ ->
    Trace.trace " --- Deploying app --- "
)

open Fake.Core.TargetOperators

// *** Define Dependencies ***
"Clean"
    ==> "Build"
    ==> "Deploy"

// *** Start Build ***
let ctx = Target.WithContext.runOrDefault "Deploy"
Target.updateBuildStatus ctx
Target.raiseIfError ctx // important to have proper exit code on build failures.

Final targets

Final targets can be used for TearDown functionality. These targets will be executed even if the build fails but have to be activated via Target.ActivateFinal().

1: 
2: 
3: 
4: 
5: 
6: 
7: 

Target.createFinal "CloseSomePrograms" (fun _ ->
    // close stuff and release resources
    ()
)

// Activate Final target somewhere during build
Target.activateFinal "CloseSomePrograms"

Build failure targets

Build failure targets can be used to execute tasks after a build failure. These targets will be executed only after a build failure but have to be activated via activateBuildFailure().

1: 
2: 
3: 
4: 
5: 
6: 
7: 

Target.createBuildFailure "ReportErrorViaMail" (fun _ ->
    // send mail about the failure
    ()
)

// Activate Build Failure Target somewhere during build
Target.activateBuildFailure "ReportErrorViaMail"

Using FAKE's parallel option

Since multithreading is beneficial (especially for large projects) FAKE allows to specify the number of threads used for traversing the dependency tree. This option of course only affects independent targets whereas dependent targets will still be executed in order.

Setting the number of threads

The number of threads used can be set using the environment variable parallel-jobs or using the --parallel parameter. This can be achieved in various ways where the easiest one is to use the parameter:

fake run *YourBuildScript* --parallel 8

Note that the dependency tree will be traversed as usual whenever setting parallel-jobs to a value <= 1 or omiting it entirely.

Issues

• Running targets in parallel is of course only possible when the target-functions themselves are thread-safe.
• Parallel execution may also cause races on stdout and build-logs may therefore be quite obfuscated.
• Error detection may suffer since it's not possible to determine a first error when targets are running in parallel

Due to these limitations it is recommended to use the standard sequential build whenever checking for errors (CI, etc.) However when a fast build is desired (and the project is e.g. known to build successfully) the parallel option might be helpful

Example

When using this parallel option, Fake resolves the build dependency hierarchies from the described paths and builds independend paths as parallel if you have multiple CPUs available. For example this dependency tree:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 

"Task 1"
    ==> "Task A2"
    ==> "Task 3"

"Task 1"
    ==> "Task B2"
    ==> "Task 3"

"Task C2"
    ==> "Task 3"

"Task 3"
    ==> "Task A4"

"Task 3"
    ==> "Task B4"

...would be treated as follows:

This is in addition to that that MSBuild may use multiple threads when building one solution having multiple independent project-files.

Soft dependencies

Typically you will define dependencies among your targets using the ==> and <== operators, and these dependencies define the order in which the targets are executed during a build.

You can also define soft dependencies among targets using the ?=> and <=? operators. For example, you might say that target B has a soft dependency on target A:

1: 
2: 
3: 

"A" ?=> "B"
// Or equivalently
"B" <=? "A"

With this soft dependency, running B will not require that A be run first. However it does mean that if A is run (due to other dependencies) it must be run before B.

Example

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 

// *** Define Targets ***
Target.create "Clean" (fun _ ->
    Trace.trace " --- Cleaning stuff --- "
)

Target.create "Build" (fun _ ->
    Trace.trace " --- Building the app --- "
)

Target.create "Rebuild" ignore

// *** Define Dependencies ***
"Build" ==> "Rebuild"
"Clean" ==> "Rebuild"
// Make sure "Clean" happens before "Build", if "Clean" is executed during a build.
"Clean" ?=> "Build"