viaduct 0.4.0

A duplex communication channel between a parent and child process, using unnamed pipes
Documentation 
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

[![crates.io](https://img.shields.io/crates/v/viaduct.svg)](https://crates.io/crates/viaduct)
[![docs.rs](https://docs.rs/viaduct/badge.svg)](https://docs.rs/viaduct/)
[![license](https://img.shields.io/crates/l/viaduct)](https://github.com/WilliamVenner/viaduct/blob/master/LICENSE)

Viaduct is a library for establishing a duplex communication channel between a parent and child process, using unnamed pipes.

# Example


## Shared library


```rust
#[derive(Serialize, Deserialize)]

pub enum ExampleRpc {
    Cow,
    Pig,
    Horse
}

#[derive(Serialize, Deserialize)]

pub enum ExampleRequest {
    DoAFrontflip,
    DoABackflip,
}

#[derive(Serialize, Deserialize, PartialEq, Eq)]

pub struct FrontflipError;

#[derive(Serialize, Deserialize, PartialEq, Eq)]

pub struct BackflipError;
```

## Parent process


```rust
let child = std::process::Command::new("child.exe");
let ((tx, rx), mut child) = ViaductParent::new(child).unwrap().build().unwrap();

std::thread::spawn(move || {
    rx.run(
        |rpc: ExampleRpc| match rpc {
            ExampleRpc::Cow => println!("Moo"),
            ExampleRpc::Pig => println!("Oink"),
            ExampleRpc::Horse => println!("Neigh"),
        },

        |request: ExampleRequest, tx| match request {
            ExampleRequest::DoAFrontflip => {
                println!("Doing a frontflip!");
                tx.respond(Ok::<_, FrontflipError>(())).unwrap();
            },

            ExampleRequest::DoABackflip => {
                println!("Doing a backflip!");
                tx.respond(Ok::<_, BackflipError>(())).unwrap();
            },
        },
    ).unwrap();
});

tx.rpc(ExampleRpc::Cow).unwrap();
tx.rpc(ExampleRpc::Pig).unwrap();
tx.rpc(ExampleRpc::Horse).unwrap();

let response: Result<(), FrontflipError> = tx.request(ExampleRequest::DoAFrontflip).unwrap();
assert_eq!(response, Ok(()));
```

## Child process


```rust
let (tx, rx) = unsafe { ViaductChild::new() }.unwrap();

std::thread::spawn(move || {
    rx.run(
        |rpc: ExampleRpc| match rpc {
            ExampleRpc::Cow => println!("Moo"),
            ExampleRpc::Pig => println!("Oink"),
            ExampleRpc::Horse => println!("Neigh"),
        },

        |request: ExampleRequest, tx| match request {
            ExampleRequest::DoAFrontflip => {
                println!("Doing a frontflip!");
                tx.respond(Ok::<_, FrontflipError>(())).unwrap();
            },

            ExampleRequest::DoABackflip => {
                println!("Doing a backflip!");
                tx.respond(Ok::<_, BackflipError>(())).unwrap();
            },
        },
    ).unwrap();
});

tx.rpc(ExampleRpc::Horse).unwrap();
tx.rpc(ExampleRpc::Pig).unwrap();
tx.rpc(ExampleRpc::Cow).unwrap();

let response: Result<(), BackflipError> = tx.request(ExampleRequest::DoABackflip).unwrap();
assert_eq!(response, Ok(()));
```

# Use Cases


Viaduct was designed for separating user interface from application logic in a cross-platform manner.

For example, an application may want to run a GUI in a separate process from the application logic, for modularity or performance reasons.

Viaduct allows for applications like this to communicate between these processes in a natural way, without having to manually implement IPC machinery & synchronization.

# Usage


Check out [the documentation](https://docs.rs/viaduct/) for usage information.

# License


Viaduct is licensed under the MIT license or the Apache License v2.0, at your choice.