Packages

package root

Definition Classes: root

package io

Definition Classes: root

package github

Definition Classes: io

package vigoo

Definition Classes: github

package prox

Provides classes to work with system processes in a type safe way.

Overview

A system process to be started is represented by the Process case class, taking a command and optionally a list of arguments and a working directory:

import io.github.vigoo.prox._
import io.github.vigoo.prox.syntax._

val process = Process("echo", List("Hello world"))

To start the process, we can use the syntax.ProcessOps.start extension method, defined in syntax.ProcessOps, which creates a cats IO operation returning a RunningProcess instance.

Use the returned value to wait for the process to exit or to send a termination signal to it:

val program =
for {
  echo <- Process("echo", List("Hello world")).start
  result <- echo.waitForExit()
} yield result.exitCode

val exitCode = program.unsafeRunSync()

Redirection

The syntax.ProcessNodeInputRedirect, syntax.ProcessNodeOutputRedirect and syntax.ProcessNodeErrorRedirect classes define extension methods for processes to redirect their inpout, output and error streams. The target of redirection can be anything that has the matching type class defined for: CanBeProcessInputSource, CanBeProcessOutputTarget and CanBeProcessErrorTarget.

The three extension methods are syntax.ProcessNodeInputRedirect.<, syntax.ProcessNodeOutputRedirect.> and syntax.ProcessNodeErrorRedirect.redirectErrorTo

The type system guarantees that each redirection can only happen once for a process.

Streams

The library provides type classes to redirect to/from fs2 streams: InputStreamingSource for feeding a stream as a process' input, and OutputStreamingTarget and ErrorStreamingTarget to feed a process' output and error to fs2 pipes.

Three special wrapper types can be used to modify how the streams are executed when the IO operation is composed:

Drain to run the stream with fs2.Stream.InvariantOps.run, having a result of Unit
ToVector to run the stream with fs2.Stream.InvariantOps.runLog, having a result of Vector
Fold to run the stream with fs2.Stream.InvariantOps.runFold, having a custom fold result

If none of the above wrappers is used, the default is to use fs2.Stream.InvariantOps.run for fs2.Sink, fs2.Stream.InvariantOps.runFoldMonoid if the pipe's output is a cats.Monoid and fs2.Stream.InvariantOps.runLog otherwise.

Piping

The syntax.ProcessNodeOutputRedirect class defined two extension methods for piping one process to another: syntax.ProcessNodeOutputRedirect.| for direct piping and syntax.ProcessNodeOutputRedirect.via for piping through a custom fs2 fs2.Pipe.

The result of the piping operators is a PipedProcess, which can be used exactly as a simple process, but its syntax.ProcessOps.start method returns a tuple of RunningProcess instances.

Definition Classes: vigoo

package path

Small helper package to work with Java NIO paths

Definition Classes: prox

CanBeProcessErrorTarget

CanBeProcessInputSource

CanBeProcessOutputTarget

Drain

ErrorStreamingTarget

FileSource

FileTarget

Fold

InputStreamingSource

LowPriorityCanBeProcessErrorTarget

LowPriorityCanBeProcessOutputTarget

NotRedirected

OutputStreamingTarget

OutputStreamingTargetBase

PipeBuilder

PipeConstruction

PipedProcess

Piping

Process

ProcessErrorTarget

ProcessIO

ProcessInputSource

ProcessNode

ProcessOutputTarget

ProcessResult

RedirectError

RedirectInput

RedirectOutput

Redirected

RedirectionState

RunningProcess

Start

StdError

StdIn

StdOut

ToVector

syntax

io.github.vigoo.prox

syntax

object syntax

Implicit classes for working with simple and piped processes

All the operations are implemented for both simple Process objects and PipedProcess objects as well. Most of the operations encode information in the types of the processes as well.

The operations are implemented by various type classes and exposed through extension methods defined in the implicit classes in this object.

Examples

Starting simple and piped processes:

val echoProcess = Process("echo", List("This is an output"))
val wordCountProcess = Process("wc", List("-w"))
val combined = echoProcess | wordCountProcess

for {
  echo1 <- Process("echo", List("Hello world")).start
  runningProcs <- combined.start
  (echo2, wordCount) = runningProcs
} yield ()

Redirecting input, output and error channels:

val p1 = Process("echo", List("Hello world")) > (home / "tmp" / "out.txt")
val p2 = Process("cat") < (home / "something")
val p3 = Process("make") errorTo (home / "errors.log")

Piping:

val echoProcess = Process("echo", List("This is an output"))
val wordCountProcess = Process("wc", List("-w"))
val combined1 = echoProcess | wordCountProcess

val customPipe: Pipe[IO, Byte, Byte] = ???
val combined2 = echoProcess.via(customPipe).to(wordCountProcess)

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

syntax
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Type Members

implicit class ProcessNodeErrorRedirect[PN <: ProcessNode[_, _, _, _, NotRedirected]] extends AnyRef
implicit class ProcessNodeInputRedirect[PN <: ProcessNode[_, _, NotRedirected, _, _]] extends AnyRef
implicit class ProcessNodeOutputRedirect[PN <: ProcessNode[_, _, _, NotRedirected, _]] extends AnyRef
implicit class ProcessOps[PN <: ProcessNode[_, _, _, _, _]] extends AnyRef

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 clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

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()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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
@native() @throws( ... )

Packages

Overview

Redirection

Streams

Piping

syntax

object syntax

Examples

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Overview

Redirection

Streams

Piping

syntax 

object syntax

Examples

Type Members

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

syntax