process-mel 0.10.1

Mélodium external process management library
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use std/flow::emit
use std/ops/option/block::unwrap
use root/command::Command
use root/environment::Environment
use root/exec::Executor
use root/local::|local_executor
use root/exec::execOnce as generalExecOnce
use root/exec::spawnOnce as generalSpawnOnce

/**
Execute a single command on the local machine, triggered by a launch signal.

Convenience wrapper around `execOnce` that automatically obtains the local executor.
`command` is run with the optional `environment` when `launch` fires.
`started`, `completed`, `failed`, `error`, `exit`, and `finished` behave identically to `execOnce`.
*/
treatment execOnce(command: Command, environment: Option<Environment> = _)
  input  launch:    Block<void>
  output started:   Block<void>
  output finished:  Block<void>
  output completed: Block<void>
  output failed:    Block<void>
  output error:     Block<string>
  output exit:      Block<Option<i32>>
{
    emitExecutor: emit<Option<Executor>>(value = |local_executor())
    unwrapExecutor: unwrap<Executor>()

    generalExecOnce(command = command, environment = environment)

    Self.launch -> emitExecutor.trigger,emit -> unwrapExecutor.option,value -> generalExecOnce.executor
    Self.launch -------------------------------------------------------------> generalExecOnce.launch

    generalExecOnce.started ----> Self.started
    generalExecOnce.finished ---> Self.finished
    generalExecOnce.completed --> Self.completed
    generalExecOnce.failed -----> Self.failed
    generalExecOnce.error ------> Self.error
    generalExecOnce.exit -------> Self.exit
}

/**
Spawn a single command on the local machine with stdio streams, triggered by a launch signal.

Convenience wrapper around `spawnOnce` that automatically obtains the local executor.
`command` is spawned with the optional `environment` when `launch` fires.
Connects `stdin`, `stdout`, and `stderr` streams to the process.
`started`, `completed`, `failed`, `error`, `exit`, and `finished` behave identically to `spawnOnce`.
*/
treatment spawnOnce(command: Command, environment: Option<Environment> = _)
  input  launch:    Block<void>
  input  stdin:     Stream<byte>
  output stdout:    Stream<byte>
  output stderr:    Stream<byte>
  output started:   Block<void>
  output finished:  Block<void>
  output completed: Block<void>
  output failed:    Block<void>
  output error:     Block<string>
  output exit:      Block<Option<i32>>
{
    emitExecutor: emit<Option<Executor>>(value = |local_executor())
    unwrapExecutor: unwrap<Executor>()

    generalSpawnOnce(command = command, environment = environment)

    Self.launch -> emitExecutor.trigger,emit -> unwrapExecutor.option,value -> generalSpawnOnce.executor
    Self.launch -------------------------------------------------------------> generalSpawnOnce.launch

    Self.stdin --------> generalSpawnOnce.stdin
    generalSpawnOnce.stdout --> Self.stdout
    generalSpawnOnce.stderr --> Self.stderr

    generalSpawnOnce.started ----> Self.started
    generalSpawnOnce.finished ---> Self.finished
    generalSpawnOnce.completed --> Self.completed
    generalSpawnOnce.failed -----> Self.failed
    generalSpawnOnce.error ------> Self.error
    generalSpawnOnce.exit -------> Self.exit
}