springql 0.18.1

SpringQL: Open-source stream processor for IoT devices and in-vehicle computers
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

// This file is part of https://github.com/SpringQL/SpringQL which is licensed under MIT OR Apache-2.0. See file LICENSE-MIT or LICENSE-APACHE for full license details.

//! Usage:
//!
//! ```bash
//! cargo run --example http_client_sink_writer -- REMOTE_HOST REMOTE_PORT
//! ```

use std::{env, process::Command, thread, time::Duration};

use springql::SpringSourceRowBuilder;
use springql_core::api::{SpringConfig, SpringPipeline};
use springql_test_logger::setup_test_logger;

fn parse_remote_args() -> (String, u16) {
    let args: Vec<String> = env::args().collect();
    assert_eq!(args.len(), 3);

    let host = args[1].clone();
    let port = args[2].parse::<u16>().unwrap();
    log::info!("Remote info - {}:{}", host, port);

    (host, port)
}

fn launch_http_server(port: u16) {
    Command::new("bash")
        .arg("-c")
        .arg(format!("nc -l {}", port))
        .spawn()
        .expect("failed to launch http server");
}

fn main() {
    setup_test_logger();

    let (sink_host, sink_port) = parse_remote_args();

    launch_http_server(sink_port);

    let pipeline = SpringPipeline::new(&SpringConfig::default()).unwrap();

    pipeline
        .command(
            "
            CREATE SOURCE STREAM source_1 (
                bytes BLOB NOT NULL
              );
            ",
        )
        .unwrap();

    pipeline
        .command(
            "
            CREATE SINK STREAM sink_1 (
                http_body BLOB NOT NULL
              );
            ",
        )
        .unwrap();

    pipeline
        .command(
            "
            CREATE PUMP pu_1 AS
            INSERT INTO sink_1 (http_body)
            SELECT STREAM source_1.bytes FROM source_1;
            ",
        )
        .unwrap();

    pipeline
        .command(format!(
            "
            CREATE SINK WRITER http_sink_1 FOR sink_1
              TYPE HTTP1_CLIENT OPTIONS (
                REMOTE_HOST '{remote_host}',
                REMOTE_PORT '{remote_port}',
                METHOD 'POST',
                URL 'http://{remote_host}:{remote_port}/test',
                HEADER_Content-Type 'application/octet-stream',
                HEADER_Connection 'keep-alive',
                BLOB_BODY_COLUMN 'http_body'
            );
            ",
            remote_host = sink_host,
            remote_port = sink_port
        ))
        .unwrap();

    pipeline
        .command(
            "
            CREATE SOURCE READER q_source_1 FOR source_1
            TYPE IN_MEMORY_QUEUE OPTIONS (
              NAME 'q'
            );
            ",
        )
        .unwrap();

    let bytes = vec![b'h', b'e', b'l', b'l', b'o', 0xF0, 0x9F, 0x98, 0x84];

    let source_rows = vec![SpringSourceRowBuilder::default()
        .add_column("bytes", bytes)
        .unwrap()
        .build()];

    for row in source_rows {
        pipeline.push("q", row).unwrap()
    }

    thread::sleep(Duration::from_secs(1));
}