Note: This is the migration API reference for FAKE 5. The new (modularized) API documentation can be found here. If the API is already migrated you can check here if exists in a module. More information regarding the migration can be found here

CreateProcess

Module for creating and modifying CreateProcess<'TRes> instances. You can manage:

  • The command (ie file to execute and arguments)
  • The working directory
  • The process environment
  • Stream redirection and pipes
  • Timeout for the process to exit
  • The result and the result transformations (map, mapResult)

More extensions can be found in the CreateProcess Extensions

Example

1: 
2: 
3: 
4: 

Command.RawCommand("file", Arguments.OfArgs ["arg1"; "arg2"])
|> CreateProcess.fromCommand
|> Proc.run
|> ignore
val ignore : value:'T -> unit

Functions and values

Function or valueDescription
addOnExited f c
Signature: f:('a -> int -> 'b) -> c:CreateProcess<'a> -> CreateProcess<'b>
Type parameters: 'a, 'b

Execute the given function after the process has been exited and the previous result has been calculated.
addOnFinally f c
Signature: f:(unit -> unit) -> c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Execute the given function when the process is cleaned up.
addOnSetup f c
Signature: f:(unit -> 'a) -> c:CreateProcess<'b> -> CreateProcess<'b>
Type parameters: 'a, 'b

Execute the given function before the process is started
addOnStarted f c
Signature: f:(unit -> unit) -> c:CreateProcess<'?17724> -> CreateProcess<'?17724>
Type parameters: '?17724

Execute the given function right after the process is started.
appendSimpleFuncs(...)
Signature: prepareState:(unit -> '?17715) -> onStart:('?17715 -> Process -> unit) -> onResult:(Async<'?17716> -> '?17715 -> Task<RawProcessResult> -> Async<'?17717>) -> onDispose:('?17715 -> unit) -> c:CreateProcess<'?17716> -> CreateProcess<'?17717>
Type parameters: '?17715, '?17716, '?17717

Attaches the given functions to the current CreateProcess instance.
copyRedirectedProcessOutputsToStandardOutputs(...)
Signature: c:CreateProcess<'?17666> -> CreateProcess<'?17666>
Type parameters: '?17666

Copies std-out and std-err into the corresponding System.Console streams (by using interceptStream).
disableTraceCommand(c)
Signature: c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Disable the default trace of started processes.
ensureExitCode(r)
Signature: r:CreateProcess<'?17758> -> CreateProcess<'?17758>
Type parameters: '?17758

Makes sure the exit code is 0, otherwise a detailed exception is thrown (showing the command line).
ensureExitCodeWithMessage msg r
Signature: msg:string -> r:CreateProcess<'?17755> -> CreateProcess<'?17755>
Type parameters: '?17755

throws an exception with the given message if exitCode <> 0
fromCommand(command)
Signature: command:Command -> CreateProcess<ProcessResult<unit>>

Create a simple CreateProcess<_> instance from the given command.

Example

1: 
2: 
3: 
4: 

Command.RawCommand("file", Arguments.OfArgs ["arg1"; "arg2"])
|> CreateProcess.fromCommand
|> Proc.run
|> ignore
val ignore : value:'T -> unit
fromRawCommand command args
Signature: command:FilePath -> args:seq<string> -> CreateProcess<ProcessResult<unit>>

Create a CreateProcess from the given file and arguments

Example

1: 
2: 
3: 

CreateProcess.fromRawCommand "cmd" [ "/C";  "echo test" ]
|> Proc.run
|> ignore
val ignore : value:'T -> unit
fromRawCommandLine(...)
Signature: command:FilePath -> windowsCommandLine:string -> CreateProcess<ProcessResult<unit>>

Create a CreateProcess from the given file and arguments

Example

1: 
2: 
3: 

CreateProcess.fromRawCommandLine "cmd" "/C \"echo test\""
|> Proc.run
|> ignore

Using BlackFox.CommandLine

See BlackFox.CommandLine for details

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

open BlackFox.CommandLine

CmdLine.empty
|> CmdLine.append "build"
|> CmdLine.appendIf noRestore "--no-restore"
|> CmdLine.appendPrefixIfSome "--framework" framework
|> CmdLine.appendPrefixf "--configuration" "%A" configuration
|> CmdLine.toString
|> CreateProcess.fromRawCommandLine "dotnet.exe"
|> Proc.run
|> ignore
val ignore : value:'T -> unit
fromRawWindowsCommandLine(...)
Signature: command:FilePath -> windowsCommandLine:string -> CreateProcess<ProcessResult<unit>>
Attributes:
[<Obsolete("Use fromRawCommandLine instead.")>]
OBSOLETE

Use fromRawCommandLine instead.

Create a CreateProcess from the given file and arguments
getEnvironmentMap(c)
Signature: c:CreateProcess<'?17730> -> EnvMap
Type parameters: '?17730

Retrieve the current environment map.
interceptStream target s
Signature: target:Stream -> s:StreamSpecification -> StreamSpecification

intercept the given StreamSpecification and writes the intercepted data into target. Throws if the stream is not redirected (ie is Inherit).
map f c
Signature: f:('?17740 -> '?17741) -> c:CreateProcess<'?17740> -> CreateProcess<'?17741>
Type parameters: '?17740, '?17741

Map the current result to a new type.
mapFilePath f c
Signature: f:(FilePath -> FilePath) -> c:CreateProcess<'?17676> -> CreateProcess<'?17676>
Type parameters: '?17676

Map the file-path according to the given function.
mapResult f c
Signature: f:('a -> 'b) -> c:CreateProcess<ProcessResult<'a>> -> CreateProcess<ProcessResult<'b>>
Type parameters: 'a, 'b

Map only the result object and leave the exit code in the result type.
ofStartInfo(p)
Signature: p:ProcessStartInfo -> CreateProcess<ProcessResult<unit>>

Create a CreateProcess from the given ProcessStartInfo
redirectOutput(c)
Signature: c:CreateProcess<'a> -> CreateProcess<ProcessResult<ProcessOutput>>
Type parameters: 'a

Starts redirecting the output streams and collects all data at the end.
replaceFilePath newFilePath c
Signature: newFilePath:FilePath -> c:CreateProcess<'?17674> -> CreateProcess<'?17674>
Type parameters: '?17674

Replace the file-path
setEnvironmentVariable envKey envVar c
Signature: envKey:string -> envVar:string -> c:CreateProcess<'?17732> -> CreateProcess<'?17732>
Type parameters: '?17732

Set the given environment variable.
warnOnExitCode msg r
Signature: msg:string -> r:CreateProcess<unit> -> CreateProcess<unit>

LikeensureExitCode but only triggers a warning instead of failing.
withCommand command c
Signature: command:Command -> c:CreateProcess<'?17672> -> CreateProcess<'?17672>
Type parameters: '?17672

Set the command to the given one.
withEnvironment env c
Signature: env:(string * string) list -> c:CreateProcess<'?17726> -> CreateProcess<'?17726>
Type parameters: '?17726

Sets the given environment variables
withEnvironmentMap env c
Signature: env:EnvMap -> c:CreateProcess<'?17728> -> CreateProcess<'?17728>
Type parameters: '?17728

Sets the given environment map.
withOutputEvents onStdOut onStdErr c
Signature: onStdOut:(string -> unit) -> onStdErr:(string -> unit) -> c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Calls the given functions whenever a new output-line is received.
withOutputEventsNotNull(...)
Signature: onStdOut:(string -> unit) -> onStdErr:(string -> unit) -> c:CreateProcess<'?17750> -> CreateProcess<'?17750>
Type parameters: '?17750

Like withOutputEvents but skips null objects.
withStandardError stdErr c
Signature: stdErr:StreamSpecification -> c:CreateProcess<'?17736> -> CreateProcess<'?17736>
Type parameters: '?17736

Set the standard error stream.
withStandardInput stdIn c
Signature: stdIn:StreamSpecification -> c:CreateProcess<'?17738> -> CreateProcess<'?17738>
Type parameters: '?17738

Set the standard input stream.
withStandardOutput stdOut c
Signature: stdOut:StreamSpecification -> c:CreateProcess<'?17734> -> CreateProcess<'?17734>
Type parameters: '?17734

Set the standard output stream.
withTimeout timeout c
Signature: timeout:TimeSpan -> c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Set the given timeout
withWorkingDirectory workDir c
Signature: workDir:string -> c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Set the working directory of the new process.