allora-runtime 0.0.2

Allora runtime and DSL implementation (internal crate).
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! HttpInboundAdapterSpec: specification for a single HTTP inbound adapter binding an HTTP endpoint
//! to messaging channels.
//!
//! # Purpose
//! Represents an HTTP server endpoint definition that publishes inbound requests as messages onto a
//! `request_channel` and optionally consumes replies from a `reply_channel` to form synchronous HTTP responses.
//!
//! # Field Semantics
//! * `id` (optional): Explicit adapter identifier for reference / diagnostics; may be auto-generated
//!   by a future collection builder (`http-inbound-adapter:auto.N`).
//! * `host` (required, non-empty): Interface or hostname to bind (e.g. `0.0.0.0`, `127.0.0.1`).
//! * `port` (required, 1-65535): TCP port to listen on.
//! * `path` (required, non-empty, leading `/`): Exact path segment for the endpoint.
//! * `methods` (required, non-empty list): Allowed HTTP methods (subset of standard verbs).
//! * `request_channel` (required, non-empty): Channel id receiving inbound requests as messages.
//! * `reply_channel` (optional, non-empty if present): Channel id for reply messages correlated to HTTP responses.
//!
//! # Construction Helpers
//! * `new(host, port, path, methods, request_channel)` – minimal spec (no id / reply_channel).
//! * `with_id(id, host, port, path, methods, request_channel)` – explicit id.
//! * `with_reply(host, port, path, methods, request_channel, reply_channel)` – reply channel only.
//! * `with_id_reply(id, host, port, path, methods, request_channel, reply_channel)` – id + reply.
//!
//! # Example
//! ```rust
//! use allora_runtime::spec::HttpInboundAdapterSpec;
//! let spec = HttpInboundAdapterSpec::new("127.0.0.1", 8080, "/receive", vec!["POST".into()], "inbound.receive");
//! assert_eq!(spec.host(), "127.0.0.1");
//! assert_eq!(spec.port(), 8080);
//! assert_eq!(spec.path(), "/receive");
//! assert_eq!(spec.methods(), &["POST"]);
//! assert_eq!(spec.request_channel(), "inbound.receive");
//! assert!(spec.reply_channel().is_none());
//! ```

#[derive(Debug, Clone)]
pub struct HttpInboundAdapterSpec {
    id: Option<String>,
    host: String,
    port: u16,
    path: String,
    methods: Vec<String>,
    request_channel: String,
    reply_channel: Option<String>,
}

impl HttpInboundAdapterSpec {
    pub fn new<H: Into<String>, P: Into<String>, RC: Into<String>>(
        host: H,
        port: u16,
        path: P,
        methods: Vec<String>,
        request_channel: RC,
    ) -> Self {
        Self {
            id: None,
            host: host.into(),
            port,
            path: path.into(),
            methods,
            request_channel: request_channel.into(),
            reply_channel: None,
        }
    }
    pub fn with_id<ID: Into<String>, H: Into<String>, P: Into<String>, RC: Into<String>>(
        id: ID,
        host: H,
        port: u16,
        path: P,
        methods: Vec<String>,
        request_channel: RC,
    ) -> Self {
        Self {
            id: Some(id.into()),
            host: host.into(),
            port,
            path: path.into(),
            methods,
            request_channel: request_channel.into(),
            reply_channel: None,
        }
    }
    pub fn with_reply<H: Into<String>, P: Into<String>, RC: Into<String>, R: Into<String>>(
        host: H,
        port: u16,
        path: P,
        methods: Vec<String>,
        request_channel: RC,
        reply_channel: R,
    ) -> Self {
        Self {
            id: None,
            host: host.into(),
            port,
            path: path.into(),
            methods,
            request_channel: request_channel.into(),
            reply_channel: Some(reply_channel.into()),
        }
    }
    pub fn with_id_reply<
        ID: Into<String>,
        H: Into<String>,
        P: Into<String>,
        RC: Into<String>,
        R: Into<String>,
    >(
        id: ID,
        host: H,
        port: u16,
        path: P,
        methods: Vec<String>,
        request_channel: RC,
        reply_channel: R,
    ) -> Self {
        Self {
            id: Some(id.into()),
            host: host.into(),
            port,
            path: path.into(),
            methods,
            request_channel: request_channel.into(),
            reply_channel: Some(reply_channel.into()),
        }
    }
    pub fn id(&self) -> Option<&str> {
        self.id.as_deref()
    }
    pub fn host(&self) -> &str {
        &self.host
    }
    pub fn port(&self) -> u16 {
        self.port
    }
    pub fn path(&self) -> &str {
        &self.path
    }
    pub fn methods(&self) -> &[String] {
        &self.methods
    }
    pub fn request_channel(&self) -> &str {
        &self.request_channel
    }
    pub fn reply_channel(&self) -> Option<&str> {
        self.reply_channel.as_deref()
    }
    pub fn set_id(&mut self, id: String) {
        self.id = Some(id);
    }
}