case class proc(command: Shellable*) extends Product with Serializable
Convenience APIs around java.lang.Process and java.lang.ProcessBuilder:
- os.proc.call provides a convenient wrapper for "function-like" processes that you invoke with some input, whose entire output you need, but otherwise do not have any intricate back-and-forth communication
- os.proc.stream provides a lower level API: rather than providing the output all at once, you pass in callbacks it invokes whenever there is a chunk of output received from the spawned process.
- os.proc(...) provides the lowest level API: an simple Scala API around java.lang.ProcessBuilder, that spawns a normal java.lang.Process for you to deal with. You can then interact with it normally through the standard stdin/stdout/stderr streams, using whatever protocol you want
- Alphabetic
- By Inheritance
- proc
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
call(cwd: Path = null, env: Map[String, String] = null, stdin: ProcessInput = Pipe, stdout: ProcessOutput = Pipe, stderr: ProcessOutput = os.Inherit, mergeErrIntoOut: Boolean = false, timeout: Long = -1, check: Boolean = true, propagateEnv: Boolean = true): CommandResult
Invokes the given subprocess like a function, passing in input and returning a CommandResult.
Invokes the given subprocess like a function, passing in input and returning a CommandResult. You can then call
result.exitCode
to see how it exited, orresult.out.bytes
orresult.err.string
to access the aggregated stdout and stderr of the subprocess in a number of convenient ways. If a non-zero exit code is returned, this throws a os.SubprocessException containing the CommandResult, unless you pass incheck = false
.If you want to spawn an interactive subprocess, such as
vim
,less
, or apython
shell, set all ofstdin
/stdout
/stderr
to os.Inheritcall
provides a number of parameters that let you configure how the subprocess is run:- cwd
the working directory of the subprocess
- env
any additional environment variables you wish to set in the subprocess
- stdin
any data you wish to pass to the subprocess's standard input
- stdout
How the process's output stream is configured.
- stderr
How the process's error stream is configured.
- mergeErrIntoOut
merges the subprocess's stderr stream into it's stdout
- timeout
how long to wait for the subprocess to complete
- check
disable this to avoid throwing an exception if the subprocess fails with a non-zero exit code
- propagateEnv
disable this to avoid passing in this parent process's environment variables to the subprocess
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
- val command: Shellable*
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
spawn(cwd: Path = null, env: Map[String, String] = null, stdin: ProcessInput = Pipe, stdout: ProcessOutput = Pipe, stderr: ProcessOutput = os.Inherit, mergeErrIntoOut: Boolean = false, propagateEnv: Boolean = true): SubProcess
The most flexible of the os.proc calls,
os.proc.spawn
simply configures and starts a subprocess, and returns it as ajava.lang.Process
for you to interact with however you like.The most flexible of the os.proc calls,
os.proc.spawn
simply configures and starts a subprocess, and returns it as ajava.lang.Process
for you to interact with however you like.To implement pipes, you can spawn a process, take it's stdout, and pass it as the stdin of a second spawned process.
Note that if you provide
ProcessOutput
callbacks tostdout
/stderr
, the calls to those callbacks take place on newly spawned threads that execute in parallel with the main thread. Thus make sure any data processing you do in those callbacks is thread safe! -
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()