astro-run-server 0.1.0

AstroRun is a highly customizable workflow orchestrator that allows users to define their own core runners. Whether it's Docker or other platforms, AstroRun empowers users to run workflows with ease and flexibility.
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

# Astro Run Server


`astro-run-server` is an extension of [astro-run](https://github.com/panghu-huang/astro-run) that allows it to be served as a service and accept runners via gRPC requests.

`astro-run-server` forwards run requests, plugin events, logs, etc. from `astro-run` to runners using gRPC streams, enabling remote invocation and multi-runner scheduling.

## Example


Add `astro-run` and `astro-run-server` as dependencies in your `Cargo.toml`:

```toml
[dependencies]
astro-run = "0.1"
astro-run-server = "0.1"
```

### Astro Run Server


```rust
use astro_run::{AstroRun, Result, Workflow};
use astro_run_server::AstroRunServer;

#[tokio::main]

async fn main() -> Result<()> {
    let server = AstroRunServer::new();

    let cloned_server = server.clone();

    // Start the server in the background
    let handle = tokio::spawn(async move {
        // Server listening address
        cloned_server.serve("127.0.0.1:5001").await.unwrap();
    });

    let astro_run = AstroRun::builder().runner(server).build();

    let workflow = r#"
    jobs:
      test:
        name: Test Job
        steps:
          - timeout: 60m
            continue-on-error: false
            run: Hello World
    "#;

    let workflow = Workflow::builder()
        .config(workflow)
        .build()
        .unwrap();

    let ctx = astro_run.execution_context();

    // Run the workflow
    let _res = workflow.run(ctx).await;

    // Wait for the server to stop
    handle.await.unwrap();

    Ok(())
}
```

### Runner


```rust
use astro_run::{stream, Context, Result, RunResult};
use astro_run_server::AstroRunRunner;

// Simulated implementation of a Runner
struct Runner {}

impl Runner {
    fn new() -> Self {
        Runner {}
    }
}

impl astro_run::Runner for Runner {
    fn run(&self, ctx: Context) -> astro_run::RunResponse {
        let (tx, rx) = stream();

        tx.log(ctx.command.run);
        tx.end(RunResult::Succeeded);

        Ok(rx)
    }
}

#[tokio::main]

async fn main() -> Result<()> {
    let runner = Runner::new();

    let mut astro_run_runner = AstroRunRunner::builder()
        .runner(runner)
        // Remote server address
        .url("http://127.0.0.1:5001")
        // Runner ID
        .id("test-runner")
        .build()
        .await
        .unwrap();

    astro_run_runner.start().await.unwrap();

    Ok(())
}
```

In the above example, you can replace the runner with a specific implementation from [astro-runner](../astro-runner).