bcms 0.1.12

Bluetooth Client Manager Service for IoT device management
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

use serde::{Deserialize, Serialize};
use std::time::Duration;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    /// How often data is submitted to backend (seconds)
    pub data_submission_interval: f64,
    /// Cache clearing interval (seconds)
    pub clear_iot_data_cache_interval: f64,
    /// Bluetooth scanning frequency (seconds)
    pub bluetooth_scan_interval: f64,
    /// Supported BLE device prefixes
    pub supported_devices: Vec<String>,
    /// HTTP request timeout (seconds)
    pub http_timeout_seconds: u64,
    /// RPC server address
    pub rpc_address: String,
    /// RPC server port
    pub rpc_port: u16,
    /// Device data file path
    pub known_devices_file: Option<String>,
    /// OIDC issuer URL
    pub issuer_url: Option<String>,
    /// Device private key file path for OIDC authentication
    pub device_private_key_path: Option<String>,
    /// Rate limiting: samples every N seconds per device+type (default: 2)
    pub samples_every_seconds: i64,
    /// Maximum data points per device (default: 1000)
    pub max_data_points_per_device: usize,
    /// Maximum total data points across all devices (default: 10000)
    pub max_total_data_points: usize,
    /// Maximum age of data in seconds before cleanup (default: 24 hours)
    pub max_data_age_seconds: i64,
    /// Mock backend URL (bypasses OIDC discovery)
    pub mock_backend_url: Option<String>,
    /// Mock bearer token (bypasses OIDC authentication)
    pub mock_bearer_token: Option<String>,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            data_submission_interval: 3.0,
            clear_iot_data_cache_interval: 180.0,
            bluetooth_scan_interval: 5.0,
            supported_devices: vec![
                "A&D_UA-651BLE_".to_string(),
                "BLESmart_".to_string(),
                "X4 Smart".to_string(),
            ],
            http_timeout_seconds: 10,
            rpc_address: "127.0.0.1".to_string(),
            rpc_port: 4567,
            known_devices_file: None,
            issuer_url: None,
            device_private_key_path: None,
            samples_every_seconds: 2,
            max_data_points_per_device: 1000,
            max_total_data_points: 10000,
            max_data_age_seconds: 24 * 60 * 60, // 24 hours
            mock_backend_url: None,
            mock_bearer_token: None,
        }
    }
}

impl Config {
    pub fn data_submission_duration(&self) -> Duration {
        Duration::from_secs_f64(self.data_submission_interval)
    }

    pub fn cache_clear_duration(&self) -> Duration {
        Duration::from_secs_f64(self.clear_iot_data_cache_interval)
    }

    pub fn bluetooth_scan_duration(&self) -> Duration {
        Duration::from_secs_f64(self.bluetooth_scan_interval)
    }

    pub fn http_timeout(&self) -> Duration {
        Duration::from_secs(self.http_timeout_seconds)
    }

    pub fn rpc_bind_address(&self) -> String {
        format!("{}:{}", self.rpc_address, self.rpc_port)
    }
}