remind 0.3.1

A program/daemon for scheduling reminder notifications after a given duration. 
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

use std::io::Read as _;
use std::marker::PhantomData;
use std::net::SocketAddr;
use std::net::TcpListener;
use std::net::TcpStream;

use anyhow::Context as _;
use anyhow::Result;

use postcard::from_bytes as postcard_from_bytes;
use postcard::to_io as postcard_to_io;

use serde::Deserialize;
use serde::Serialize;
use serde::de::DeserializeOwned;


#[derive(Debug)]
pub struct Channel;

impl Channel {
  pub fn oneshot<T>() -> Result<(Reader<T>, Writer<T>)>
  where
    T: DeserializeOwned + Serialize,
  {
    let listener =
      TcpListener::bind(("127.0.0.1", 0)).context("failed to bind to local address")?;

    let client = Writer {
      addr: listener
        .local_addr()
        .context("failed to retrieve local address of TCP listener")?,
      _phantom: PhantomData,
    };
    let server = Reader {
      listener,
      _phantom: PhantomData,
    };

    Ok((server, client))
  }
}


#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Writer<T> {
  addr: SocketAddr,
  _phantom: PhantomData<T>,
}

impl<T> Writer<T> {
  pub fn write(self, obj: &T) -> Result<()>
  where
    T: Serialize,
  {
    let Self { addr, _phantom: _ } = self;

    let stream =
      TcpStream::connect(addr).with_context(|| format!("failed to connect to {addr}"))?;

    let _stream =
      postcard_to_io(obj, stream).context("failed to write object to oneshot channel")?;
    Ok(())
  }
}


#[derive(Debug)]
pub struct Reader<T> {
  listener: TcpListener,
  _phantom: PhantomData<T>,
}

impl<T> Reader<T> {
  pub fn read(self) -> Result<T>
  where
    T: DeserializeOwned,
  {
    let Self {
      listener,
      _phantom: _,
    } = self;

    let (mut stream, _addr) = listener
      .accept()
      .context("failed to accept onesht channel connection")?;

    let mut buf = Vec::new();
    let _cnt = stream
      .read_to_end(&mut buf)
      .context("failed to read object data")?;
    let obj =
      postcard_from_bytes::<T>(&buf).context("failed to read object from oneshot channel")?;
    Ok(obj)
  }
}


#[cfg(test)]
mod tests {
  use super::*;

  use std::thread;

  use postcard::from_bytes;
  use postcard::to_allocvec;


  /// Make sure that we can send and receive data over a channel.
  #[test]
  fn sending_and_receiving() {
    const OBJ: usize = 1337;

    let (reader, writer) = Channel::oneshot().unwrap();

    let sender = thread::spawn(move || {
      let () = writer.write(&OBJ).unwrap();
    });

    let obj = reader.read().unwrap();
    let () = sender.join().unwrap();

    assert_eq!(obj, OBJ);
  }

  /// Check that we can serialize and deserialize a [`Writer`].
  #[test]
  fn writer_serialization() {
    let (server, client) = Channel::oneshot::<usize>().unwrap();

    let serialized = to_allocvec(&client).unwrap();
    let deserialized = from_bytes::<Writer<usize>>(&serialized).unwrap();

    assert_eq!(client.addr, deserialized.addr);

    let () = deserialized.write(&42).unwrap();
    let obj = server.read().unwrap();
    assert_eq!(obj, 42);
  }
}