ump-ngx 0.7.0

Collection of ump-ng extensions.
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

//! Integration utilities for creating sqlsrv handlers.

use super::{r2d2, ConnPool, WrConn};


use threadpool::ThreadPool;

use ump_ng::ReplyContext;

// Re-export rusqlite from sqlsrv
pub use sqlsrv::rusqlite;

use rusqlite::Connection;

pub enum Error<E> {
  R2D2(r2d2::Error),
  App(E)
}


/// Given an [`ConnPool`] and a [`ReplyContext`], run a closure (presumably
/// performing read-only database operations).
///
/// Translates the closure's `Result<T, E>` into a `ReplyContext::reply()` on
/// `Ok` and `ReplyContext::fail()` on `Err`.
///
/// # Errors
/// [`r2d2::Error`] is returned if a read-only connection could not be
/// acquired from the connection pool.
pub fn proc_rodb_req<R, E, F>(
  cpool: &ConnPool,
  rctx: ReplyContext<R, E>,
  f: F
) -> Result<(), r2d2::Error>
where
  R: Send + 'static,
  E: std::error::Error + Send + 'static,
  F: FnOnce(&Connection) -> Result<R, E> + Send + 'static
{
  let roconn = cpool.reader()?;

  let res = match f(&roconn) {
    Ok(reply) => rctx.reply(reply),
    Err(e) => rctx.fail(e)
  };
  if let Err(e) = res {
    eprintln!("Reply message pass failed; {e}");
  }

  Ok(())
}

/// Process a requested read-only database message on a thread pool.
///
/// The read-only database connection will be acquired from the connection pool
/// `cpool`.  The tread will be launched on the thread pool `tpool`.
///
/// The closure `f` returns a `Result<T, E>`, where the `Ok(T)` case will pass
/// the `T` to the `rctx`'s [`reply()`](ReplyContext::reply), and `Err(E)` will
/// pass the `E` to [`fail()`](ReplyContext::fail).
///
/// # Errors
/// [`r2d2::Error`] is returned if a read-only connection could not be
/// acquired from the connection pool.
pub fn proc_rodb_req_thrd<R, E, F>(
  cpool: &ConnPool,
  tpool: &ThreadPool,
  rctx: ReplyContext<R, E>,
  f: F
) -> Result<(), r2d2::Error>
where
  R: Send + 'static,
  E: std::error::Error + Send + 'static,
  F: FnOnce(&Connection) -> Result<R, E> + Send + 'static
{
  let roconn = cpool.reader()?;

  tpool.execute(move || {
    let res = match f(&roconn) {
      Ok(reply) => rctx.reply(reply),
      Err(e) => rctx.fail(e)
    };
    if let Err(e) = res {
      eprintln!("Reply message pass failed; {e}");
    }
  });

  Ok(())
}

/// Process a requested read/write database message.
pub fn proc_rwdb_req<R, E, F>(cpool: &ConnPool, rctx: ReplyContext<R, E>, f: F)
where
  R: Send + 'static,
  E: std::error::Error + Send + 'static,
  F: FnOnce(&mut WrConn) -> Result<R, E> + Send + 'static
{
  let mut conn = cpool.writer();

  let res = match f(&mut conn) {
    Ok(reply) => rctx.reply(reply),
    Err(e) => rctx.fail(e)
  };
  if let Err(e) = res {
    eprintln!("Reply message pass failed; {e}");
  }
}

/// Process a requested read/write database message on a thread pool.
///
/// The read/write database connection will be acquired from the connection
/// pool `cpool`.  The tread will be launched on the thread pool `tpool`.
///
/// The closure `f` returns a `Result<T, E>`, where the `Ok(T)` case will pass
/// the `T` to the `rctx`'s [`reply()`](ReplyContext::reply), and `Err(E)` will
/// pass the `E` to [`fail()`](ReplyContext::fail).
pub fn proc_rwdb_req_thrd<R, E, F>(
  cpool: &ConnPool,
  tpool: &ThreadPool,
  rctx: ReplyContext<R, E>,
  f: F
) where
  R: Send + 'static,
  E: std::error::Error + Send + 'static,
  F: FnOnce(&mut WrConn) -> Result<R, E> + Send + 'static
{
  let mut rwconn = cpool.writer();

  tpool.execute(move || {
    let res = match f(&mut rwconn) {
      Ok(reply) => rctx.reply(reply),
      Err(e) => rctx.fail(e)
    };
    if let Err(e) = res {
      eprintln!("Reply message pass failed; {e}");
    }
  });
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :