Skip to main content

emq_sys/
lib.rs

1//! Raw FFI to `libemq`. Prefer the safe `emq` crate for application code.
2
3#![allow(non_camel_case_types, non_snake_case, dead_code)]
4
5use std::os::raw::{c_char, c_int, c_void};
6
7pub type emq_status = c_int;
8
9pub const EMQ_OK: emq_status = 0;
10pub const EMQ_ERR_INVALID: emq_status = -1;
11pub const EMQ_ERR_NOMEM: emq_status = -2;
12pub const EMQ_ERR_NOT_FOUND: emq_status = -3;
13pub const EMQ_ERR_FULL: emq_status = -4;
14pub const EMQ_ERR_EMPTY: emq_status = -5;
15pub const EMQ_ERR_IO: emq_status = -6;
16pub const EMQ_ERR_TIMEOUT: emq_status = -7;
17pub const EMQ_ERR_EXISTS: emq_status = -8;
18pub const EMQ_ERR_CLOSED: emq_status = -9;
19pub const EMQ_ERR_BUSY: emq_status = -10;
20pub const EMQ_ERR_UNSUPPORTED: emq_status = -11;
21
22pub const EMQ_MSG_FLAG_RETRY: u32 = 0x8000_0000;
23pub const EMQ_MSG_FLAG_DEAD_LETTER: u32 = 0x4000_0000;
24pub const EMQ_MSG_FLAG_BORROWED: u32 = 0x2000_0000;
25pub const EMQ_MSG_FLAG_CLAIMED: u32 = 0x1000_0000;
26
27#[repr(C)]
28#[derive(Clone, Copy, Debug)]
29pub struct emq_message {
30    pub id: u64,
31    pub offset: u64,
32    pub priority: u32,
33    _pad0: u32,
34    pub deliver_at_ns: u64,
35    pub ttl_ns: u64,
36    pub data: *const c_void,
37    pub size: usize,
38    pub flags: u32,
39    _pad1: u32,
40}
41
42impl Default for emq_message {
43    fn default() -> Self {
44        Self {
45            id: 0,
46            offset: 0,
47            priority: 0,
48            _pad0: 0,
49            deliver_at_ns: 0,
50            ttl_ns: 0,
51            data: std::ptr::null(),
52            size: 0,
53            flags: 0,
54            _pad1: 0,
55        }
56    }
57}
58
59#[repr(C)]
60#[derive(Clone, Copy)]
61pub struct emq_queue_opts {
62    pub storage: u32,
63    pub policy: u32,
64    pub delivery: u32,
65    pub fsync: u32,
66    pub capacity: u32,
67    pub visibility_ms: u32,
68    pub inline_threshold: u32,
69    pub ring_size: u32,
70    pub path: *const c_char,
71    pub producers: u32,
72    pub consumers: u32,
73    pub backpressure: u32,
74    pub high_watermark: u32,
75    pub low_watermark: u32,
76}
77
78#[repr(C)]
79#[derive(Clone, Copy, Default)]
80pub struct emq_stats {
81    pub enqueued: u64,
82    pub dequeued: u64,
83    pub acked: u64,
84    pub nacked: u64,
85    pub expired: u64,
86    pub depth: u64,
87    pub bytes: u64,
88    pub redelivered: u64,
89}
90
91pub enum emq_runtime {}
92pub enum emq_queue {}
93
94extern "C" {
95    pub fn emq_runtime_create(out: *mut *mut emq_runtime) -> emq_status;
96    pub fn emq_runtime_destroy(rt: *mut emq_runtime);
97    pub fn emq_queue_opts_default(opts: *mut emq_queue_opts);
98    pub fn emq_queue_create(
99        rt: *mut emq_runtime,
100        name: *const c_char,
101        opts: *const emq_queue_opts,
102        out: *mut *mut emq_queue,
103    ) -> emq_status;
104    pub fn emq_queue_close(q: *mut emq_queue) -> emq_status;
105    pub fn emq_push(
106        q: *mut emq_queue,
107        data: *const c_void,
108        size: usize,
109        meta: *const emq_message,
110    ) -> emq_status;
111    pub fn emq_pop(
112        q: *mut emq_queue,
113        out: *mut emq_message,
114        timeout_ms: u32,
115    ) -> emq_status;
116    pub fn emq_try_pop(q: *mut emq_queue, out: *mut emq_message) -> emq_status;
117    pub fn emq_pop_into(
118        q: *mut emq_queue,
119        dst: *mut c_void,
120        dst_cap: usize,
121        out_size: *mut usize,
122        meta_opt: *mut emq_message,
123        timeout_ms: u32,
124    ) -> emq_status;
125    pub fn emq_push_n(
126        q: *mut emq_queue,
127        data: *const c_void,
128        size: usize,
129        count: usize,
130        pushed: *mut usize,
131    ) -> emq_status;
132    pub fn emq_pop_into_n(
133        q: *mut emq_queue,
134        dst: *mut c_void,
135        msg_cap: usize,
136        max_count: usize,
137        out_count: *mut usize,
138        out_sizes_opt: *mut usize,
139        timeout_ms: u32,
140    ) -> emq_status;
141    pub fn emq_claim(
142        q: *mut emq_queue,
143        out: *mut emq_message,
144        timeout_ms: u32,
145    ) -> emq_status;
146    pub fn emq_release_claim(q: *mut emq_queue, message: *mut emq_message) -> emq_status;
147    pub fn emq_queue_stats(q: *mut emq_queue, out: *mut emq_stats) -> emq_status;
148    pub fn emq_message_release(message: *mut emq_message);
149    pub fn emq_status_string(status: emq_status) -> *const c_char;
150}