base-station: First part of refactoring to use tokio and InfluxDB.

base-station/software/Cargo.lock

  "memchr",
 ]
 
+[[package]]
+name = "arc-swap"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b585a98a234c46fc563103e9278c9391fde1f4e6850334da895d27edb9580f62"
+
 [[package]]
 name = "atty"
 version = "0.2.14"
 dependencies = [
  "hermit-abi",
  "libc",
- "winapi",
+ "winapi 0.3.8",
 ]
 
 [[package]]
  "protocol",
  "rand",
  "thiserror",
+ "tokio",
 ]
 
 [[package]]
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 
+[[package]]
+name = "bytes"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "130aac562c0dd69c56b3b1cc8ffd2e17be31d0b6c25b61c96b76231aa23e39e1"
+
 [[package]]
 name = "cast"
 version = "0.2.3"
  "termcolor",
 ]
 
+[[package]]
+name = "fnv"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+dependencies = [
+ "bitflags",
+ "fuchsia-zircon-sys",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+
+[[package]]
+name = "futures-core"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59f5fff90fd5d971f936ad674802482ba441b6f09ba5e15fd8b39145582ca399"
+
 [[package]]
 name = "getrandom"
 version = "0.1.14"
  "libc",
 ]
 
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
 
+[[package]]
+name = "mio"
+version = "0.6.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
+dependencies = [
+ "cfg-if",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
+ "libc",
+ "log",
+ "miow 0.2.1",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "mio-named-pipes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5e374eff525ce1c5b7687c4cef63943e7686524a387933ad27ca7ec43779cb3"
+dependencies = [
+ "log",
+ "mio",
+ "miow 0.3.3",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "mio-uds"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "966257a94e196b11bb43aca423754d87429960a768de9414f3691d6957abf125"
+dependencies = [
+ "iovec",
+ "libc",
+ "mio",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "396aa0f2003d7df8395cb93e09871561ccc3e785f0acb369170e8cc74ddf9226"
+dependencies = [
+ "socket2",
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "mqtt-protocol"
 version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1411551beb3c11dedfb0a90a0fa256b47d28b9ec2cdff34c25a2fa59e45dbdc"
 
+[[package]]
+name = "net2"
+version = "0.2.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ba7c918ac76704fb42afcbbb43891e72731f3dcca3bef2a19786297baf14af7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "nix"
 version = "0.14.1"
  "void",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7505eeebd78492e0f6108f7171c4948dbb120ee8119d9d77d0afa5469bef67f"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.6"
  "rand_core",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
+
 [[package]]
 name = "regex"
 version = "1.3.7"
  "termios",
 ]
 
+[[package]]
+name = "signal-hook-registry"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f478ede9f64724c5d173d7bb56099ec3e2d9fc2774aac65d34b8b890405f41"
+dependencies = [
+ "arc-swap",
+ "libc",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
+
+[[package]]
+name = "socket2"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03088793f677dce356f3ccc2edb1b314ad191ab702a5de3faf49304f7e104918"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "winapi 0.3.8",
+]
+
 [[package]]
 name = "spidev"
 version = "0.4.0"
  "lazy_static",
 ]
 
+[[package]]
+name = "tokio"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c1d570eb1a36f0345a5ce9c6c6e665b70b73d11236912c0b477616aeec47b1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "iovec",
+ "lazy_static",
+ "libc",
+ "memchr",
+ "mio",
+ "mio-named-pipes",
+ "mio-uds",
+ "num_cpus",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "slab",
+ "tokio-macros",
+ "winapi 0.3.8",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c3acc6aa564495a0f2e1d59fab677cd7f81a19994cfc7f3ad0e64301560389"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "unicode-xid"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
 
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
 [[package]]
 name = "winapi"
 version = "0.3.8"
  "winapi-x86_64-pc-windows-gnu",
 ]
 
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa515c5163a99cc82bab70fd3bfdd36d827be85de63737b40fcef2ce084a436e"
 dependencies = [
- "winapi",
+ "winapi 0.3.8",
 ]
 
 [[package]]
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
 [[package]]
 name = "xxtea-nostd"
 version = "0.1.0"

base-station/software/Cargo.toml

 thiserror = "1.0"
 protocol = { path = "../../common/rust-protocol" }
 rand = "0.7.3"
+tokio = { version="0.2", features=[ "full" ] }

base-station/software/src/current.rs

+use protocol::{Location, Value, ValueType};
+
+pub struct CurrentValues {
+    // TODO
+}
+
+impl CurrentValues {
+    pub fn new() -> CurrentValues {
+        CurrentValues {}
+    }
+
+    pub fn set(&mut self, location: Location, _value: Value) {
+        // TODO
+    }
+
+    pub fn get(&self, location: Location, _value: ValueType) -> Option<Value> {
+        // TODO
+        None
+    }
+}

base-station/software/src/main.rs

 use std::env;
 use std::io;
-use std::sync::mpsc;
-use std::thread::sleep;
-use std::time::Duration;
+use std::sync::Arc;
+use std::time::Instant;
 
-use ::mqtt::control::variable_header::ConnectReturnCode;
-use log::error;
+use log::{error, info};
+use protocol::{GetValues, Packet, Report, Value, Values};
+use rand::{rngs::ThreadRng, Rng};
+use tokio::sync::Mutex;
 
-use crate::mqtt::MQTT;
+use current::CurrentValues;
+use publish::Publish;
+use radio::{Radio, RadioConfig};
+use tsdb::TimeSeriesDatabase;
 
-mod mqtt;
+mod current;
+mod publish;
 mod radio;
 mod spi;
+mod tsdb;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     env::set_var(
         "RUST_LOG",
         env::var_os("RUST_LOG").unwrap_or_else(|| "info".into()),
     );
     env_logger::init();
 
-    let (sensor_send, sensor_recv) = mpsc::channel();
+    // Initialize radio, MQTT and InfluxDB.
+    let radio_config = RadioConfig{
+        // TODO: Configure pins.
+    };
+    let (radio, mut incoming_packets) = Radio::init(radio_config)
+        .await
+        .expect("radio initialization failed");
+    let tsdb = TimeSeriesDatabase::init();
+    let publish = Publish::init();
 
-    radio::start(sensor_send);
+    let mut app = Application {
+        radio: Arc::new(Mutex::new(radio)),
+        publish: Arc::new(Mutex::new(publish)),
+        tsdb: Arc::new(Mutex::new(tsdb)),
+        current: CurrentValues::new(),
+        rng: rand::thread_rng(),
+    };
 
-    // Whenever the MQTT connection returns an error, we wait for a couple of seconds and then try
-    // to reconnect.
+    // Wait for packets and handle the corresponding requests.
     loop {
-        // TODO: Pass events from ratio to mqtt connection.
-        //     if let Err(e) = run_mqtt_connection(&sensor_recv) {
-        //         error!("MQTT error: {:?}", e);
-        //     }
-        sleep(Duration::from_secs(3));
+        let (device_id, packet) = incoming_packets
+            .recv()
+            .await
+            .expect("unexpected end of packet stream");
+        app.handle_packet(device_id, packet).await;
     }
 }
 
-fn run_mqtt_connection(updates: &mpsc::Receiver<SensorUpdate>) -> Result<(), Error> {
+struct Application {
+    radio: Arc<Mutex<Radio>>,
+    publish: Arc<Mutex<Publish>>,
+    tsdb: Arc<Mutex<TimeSeriesDatabase>>,
+    current: CurrentValues,
+    rng: ThreadRng,
+}
+
+impl Application {
+    async fn handle_packet(&mut self, device_id: u8, packet: Packet) {
+        // TODO: More packet types to query timeseries database.
+        match packet {
+            Packet::GetSalt => {
+                self.handle_get_salt(device_id).await;
+            }
+            Packet::Salt(_) => {
+                error!("Received Salt packet from device, ignoring.");
+            }
+            Packet::Report(payload) => {
+                self.handle_report(device_id, payload).await;
+            }
+            Packet::GetValues(payload) => {
+                self.handle_get_values(device_id, payload).await;
+            }
+            Packet::Values(_payload) => {
+                error!("received Values packet from device.");
+            }
+        }
+    }
+
+    async fn handle_get_salt(&mut self, device_id: u8) {
+        let salt = (self.rng.gen::<u64>() & !0xff & !(1 << 63)) | device_id as u64;
+        // TODO: Store the salt as the expected salt in Radio.
+        self.radio
+            .lock()
+            .await
+            .send_packet_async(device_id, Packet::Salt(salt));
+    }
+
+    async fn handle_report(&mut self, device_id: u8, report: Report) {
+        let location = radio::get_device_location(device_id);
+        let count = report.count as usize;
+        // Update local copy of current values.
+        for i in 0..count {
+            match report.values[i] {
+                Value::Invalid => {}
+                Value::Time(_) => {
+                    error!("device tried to report a time");
+                }
+                Value::Temperature(temperature) => {
+                    let temperature = temperature as f32 / 10.0;
+                    info!("{:?} temperature: {} °C", location, temperature);
+                }
+                Value::Pressure(pressure) => {
+                    let pressure = pressure as f32 / 100.0;
+                    info!("{:?} pressure: {} HPa", location, pressure);
+                }
+                Value::Humidity(humidity) => {
+                    let humidity = humidity as f32 / 100.0;
+                    info!("{:?} humidity: {}%", location, humidity);
+                }
+            }
+            self.current.set(location, report.values[i]);
+        }
+
+        // Send values via MQTT.
+        let publish = self.publish.clone();
+        let r = report.clone();
+        tokio::spawn(async move {
+            let mut publish = publish.lock().await;
+            publish.publish(location, &r.values[0..count]).await;
+        });
+
+        // Insert values into TSDB.
+        let tsdb = self.tsdb.clone();
+        tokio::spawn(async move {
+            let mut tsdb = tsdb.lock().await;
+            tsdb.insert(Instant::now(), location, &report.values[0..count])
+                .await;
+        });
+    }
+
+    async fn handle_get_values(&mut self, device_id: u8, request: GetValues) {
+        let count = request.count as usize;
+        let mut response = Values {
+            count: 0,
+            location: request.location,
+            values: [Value::Invalid; 8],
+        };
+        for i in 0..count {
+            match self.current.get(request.location, request.types_[i]) {
+                Some(value) => {
+                    // During deserialization, we made sure that count can never be larger than 7.
+                    response.values[response.count as usize] = value;
+                    response.count += 1;
+                }
+                None => {
+                    // TODO: Tell the sender that the value was not found?
+                }
+            }
+        }
+        self.radio
+            .lock()
+            .await
+            .send_packet_async(device_id, Packet::Values(response));
+    }
+}
+
+/*fn run_mqtt_connection(updates: &mpsc::Receiver<SensorUpdate>) -> Result<(), Error> {
     let mut m = MQTT::connect("127.0.0.1:1883")?;
 
     loop {
             }
         }
     }
-}
+}*/
 
-pub struct SensorUpdate {
+/*pub(crate) struct SensorUpdate {
     location: u32,
     data: Vec<SensorData>,
 }
 
-pub enum SensorData {
+pub(crate) enum SensorData {
     Temperature(f32),
     Humidity(f32),
     Pressure(f32),
-}
+}*/
 
 #[derive(thiserror::Error, Debug)]
-pub enum Error {
+pub(crate) enum Error {
     #[error("I/O error")]
     Io(#[from] io::Error),
-    #[error("connection refused, return code {0:?}")]
-    ConnectionRefused(ConnectReturnCode),
     #[error("radio error: {0:?}")]
     Radio(embedded_nrf24l01::Error<std::io::Error>),
 }

base-station/software/src/mqtt.rs

 
 use super::Error;
 
-pub struct MQTT {
+pub(crate) struct MQTT {
     stream: TcpStream,
 }
 
 impl MQTT {
-    pub fn connect(server_addr: &str) -> Result<MQTT, Error> {
+    pub(crate) fn connect(server_addr: &str) -> Result<MQTT, Error> {
         info!("Connecting to MQTT broker at {}...", server_addr);
         let mut stream = TcpStream::connect(server_addr)?;
 
         Ok(MQTT { stream })
     }
 
-    pub fn publish(&mut self, topic: &str, value: &str) -> Result<(), Error> {
+    pub(crate) fn publish(&mut self, topic: &str, value: &str) -> Result<(), Error> {
         // Publish the value.
         let topic = TopicName::new(topic).unwrap();
         let publish_packet = PublishPacket::new(topic, QoSWithPacketIdentifier::Level0, value);

base-station/software/src/publish.rs

+use protocol::{Location, Value};
+
+pub struct Publish {
+    // TODO
+}
+
+impl Publish {
+    pub fn init() -> Publish {
+        // TODO
+        Publish {}
+    }
+
+    pub async fn publish(&mut self, _location: Location, _values: &[Value]) {
+        // TODO
+    }
+}

base-station/software/src/radio.rs

-use std::convert::TryInto;
+/*use std::convert::TryInto;
 use std::sync::mpsc;
 use std::thread;
 use std::thread::sleep;
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant};*/
 
-use embedded_hal::blocking::spi::Transfer;
+/*use embedded_hal::blocking::spi::Transfer;
 use embedded_hal::digital::v2::OutputPin;
 use embedded_nrf24l01::{Configuration, CrcMode, DataRate, RxMode, NRF24L01};
 use linux_embedded_hal::spidev::{SpiModeFlags, Spidev, SpidevOptions};
 use linux_embedded_hal::sysfs_gpio::Error as GpioError;
 use linux_embedded_hal::Pin;
 use log::{error, info};
-use protocol::{Location, Packet, Value};
 use rand::rngs::ThreadRng;
-use rand::Rng;
+use rand::Rng;*/
+use protocol::{Location, Packet};
+use tokio::sync::mpsc::UnboundedReceiver;
 
-use crate::spi::EmbeddedHalSpidev;
-use crate::Error;
-use crate::{SensorData, SensorUpdate};
+/*use super::spi::EmbeddedHalSpidev;
+use super::Error;
+use super::{SensorData, SensorUpdate};*/
 
 const DISPLAY_ID: u8 = 0x20;
-const DISPLAY_KEY: [u8; 16] = include!("../../../common/display_key.txt");
+//const DISPLAY_KEY: [u8; 16] = include!("../../../common/display_key.txt");
 const WEATHER_STATION_0_ID: u8 = 0x30;
-const WEATHER_STATION_0_KEY: [u8; 16] = include!("../../../common/weather_station_0_key.txt");
+//const WEATHER_STATION_0_KEY: [u8; 16] = include!("../../../common/weather_station_0_key.txt");
 
-pub fn start(updates: mpsc::Sender<SensorUpdate>) {
+pub struct RadioConfig {
+    // TODO
+}
+
+pub struct Radio {
+    // TODO
+}
+
+impl Radio {
+    pub async fn init(
+        _config: RadioConfig,
+    ) -> Result<(Radio, UnboundedReceiver<(u8, Packet)>), RadioError> {
+        // TODO
+        panic!("Not yet implemented.");
+    }
+
+    pub fn send_packet_async(&mut self, _device_id: u8, _packet: Packet) {
+        // TODO
+        panic!("Not yet implemented.");
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum RadioError {
+    // TODO
+}
+
+/*pub(crate) fn start(updates: mpsc::Sender<SensorUpdate>) {
     // TODO: Channels for sensor readings.
     thread::spawn(move || {
         // Whenever a error occurs, reinitialize the radio module shortly later.
 }
 
 fn radio_thread(updates: &mpsc::Sender<SensorUpdate>) -> Result<(), Error> {
-    let mut radio = Radio::init(updates)?;
+    let mut radio = RadioImpl::init(updates)?;
     radio.run_loop()?;
     Ok(())
 }
 
-struct Radio<'a> {
+struct RadioImpl<'a> {
     rx: Option<RxMode<NRF24L01<GpioError, Pin, Pin, EmbeddedHalSpidev>>>,
     updates: &'a mpsc::Sender<SensorUpdate>,
     rng: ThreadRng,
 }
 
-impl<'a> Radio<'a> {
-    fn init(updates: &'a mpsc::Sender<SensorUpdate>) -> Result<Radio<'a>, Error> {
+impl<'a> RadioImpl<'a> {
+    fn init(updates: &'a mpsc::Sender<SensorUpdate>) -> Result<RadioImpl<'a>, Error> {
         info!("Initializing radio...");
 
         // The NRF module is connected as follows:
 
         let rx = nrf24.rx().unwrap();
 
-        Ok(Radio {
+        Ok(RadioImpl {
             rx: Some(rx),
             updates,
             rng: rand::thread_rng(),
         info!("packet sent: {:?}", packet);
         Ok(())
     }
-}
+}*/
 
-fn get_location(device_id: u8) -> Location {
+pub fn get_device_location(device_id: u8) -> Location {
     match device_id {
         DISPLAY_ID => Location::Bedroom,
         WEATHER_STATION_0_ID => Location::Livingroom,
     }
 }
 
-fn get_key(device_id: u8) -> Option<&'static [u8]> {
+/*fn get_key(device_id: u8) -> Option<&'static [u8]> {
     match device_id {
         DISPLAY_ID => Some(&DISPLAY_KEY),
         WEATHER_STATION_0_ID => Some(&WEATHER_STATION_0_KEY),
 
 fn get_pin_number(c: char, n: u64) -> u64 {
     (c as u64 - 'A' as u64) * 32 + n
-}
+}*/

base-station/software/src/tsdb.rs

+use std::time::Instant;
+
+use protocol::{Location, Value};
+
+pub struct TimeSeriesDatabase {
+    // TODO
+}
+
+impl TimeSeriesDatabase {
+    pub fn init() -> TimeSeriesDatabase {
+        // TODO
+        TimeSeriesDatabase {}
+    }
+
+    pub async fn insert(&mut self, _time: Instant, _location: Location, _values: &[Value]) {
+        // TODO
+    }
+}