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<'?18091> -> CreateProcess<'?18091>
Type parameters: '?18091

Execute the given function right after the process is started.

addOnStartedEx f c
Signature: f:(StartedProcessInfo -> unit) -> c:CreateProcess<'?18093> -> CreateProcess<'?18093>
Type parameters: '?18093

Execute the given function right after the process is started. PID for process can be obtained from p parameter (p.Process.Id).

appendSimpleFuncs(...)
Signature: prepareState:(unit -> 'b) -> onStart:('b -> Process -> unit) -> onResult:(Async<'c> -> 'b -> Task<RawProcessResult> -> Async<'d>) -> onDispose:('b -> unit) -> c:CreateProcess<'c> -> CreateProcess<'d>
Type parameters: 'b, 'c, 'd

Attaches the given functions to the current CreateProcess instance.

copyRedirectedProcessOutputsToStandardOutputs(...)
Signature: c:CreateProcess<'?18033> -> CreateProcess<'?18033>
Type parameters: '?18033

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<'a> -> CreateProcess<'a>
Type parameters: 'a

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<'a> -> CreateProcess<'a>
Type parameters: 'a

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<'?18099> -> EnvMap
Type parameters: '?18099

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:('b -> 'c) -> c:CreateProcess<'b> -> CreateProcess<'c>
Type parameters: 'b, 'c

Map the current result to a new type.

mapFilePath f c
Signature: f:(FilePath -> FilePath) -> c:CreateProcess<'?18043> -> CreateProcess<'?18043>
Type parameters: '?18043

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.

redirectOutputIfNotRedirected(c)
Signature: c:CreateProcess<'b> -> CreateProcess<'b>
Type parameters: 'b

Starts redirecting the output streams if they are not already redirected. Be careful when using this function. Using redirectOutput is the preferred variant

replaceFilePath newFilePath c
Signature: newFilePath:FilePath -> c:CreateProcess<'?18041> -> CreateProcess<'?18041>
Type parameters: '?18041

Replace the file-path

setEnvironmentVariable envKey envVar c
Signature: envKey:string -> envVar:string -> c:CreateProcess<'b> -> CreateProcess<'b>
Type parameters: 'b

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<'b> -> CreateProcess<'b>
Type parameters: 'b

Set the command to the given one.

withEnvironment env c
Signature: env:(string * string) list -> c:CreateProcess<'?18095> -> CreateProcess<'?18095>
Type parameters: '?18095

Sets the given environment variables

withEnvironmentMap env c
Signature: env:EnvMap -> c:CreateProcess<'b> -> CreateProcess<'b>
Type parameters: 'b

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<'b> -> CreateProcess<'b>
Type parameters: 'b

Like withOutputEvents but skips null objects.

withStandardError stdErr c
Signature: stdErr:StreamSpecification -> c:CreateProcess<'?18105> -> CreateProcess<'?18105>
Type parameters: '?18105

Set the standard error stream.

withStandardInput stdIn c
Signature: stdIn:StreamSpecification -> c:CreateProcess<'?18107> -> CreateProcess<'?18107>
Type parameters: '?18107

Set the standard input stream.

withStandardOutput stdOut c
Signature: stdOut:StreamSpecification -> c:CreateProcess<'?18103> -> CreateProcess<'?18103>
Type parameters: '?18103

Set the standard output stream.

withTimeout timeout c
Signature: timeout:TimeSpan -> c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Set the given timeout, kills the process after the specified timespan

withWorkingDirectory workDir c
Signature: workDir:string -> c:CreateProcess<'a> -> CreateProcess<'a>
Type parameters: 'a

Set the working directory of the new process.