mirror of
https://gitlab.com/fabinfra/fabaccess/bffh.git
synced 2024-09-21 11:40:08 +02:00
267 lines
8.1 KiB
Rust
267 lines
8.1 KiB
Rust
use std::str::FromStr;
|
|
use std::collections::HashMap;
|
|
use std::fs;
|
|
use std::fs::File;
|
|
use std::io::{Read, Write};
|
|
use std::path::{Path, PathBuf};
|
|
|
|
use slog::Logger;
|
|
|
|
use serde::{Serialize, Deserialize};
|
|
|
|
use std::sync::Arc;
|
|
use smol::lock::RwLock;
|
|
|
|
use crate::error::Result;
|
|
use crate::config::Settings;
|
|
use crate::access;
|
|
|
|
use capnp::Error;
|
|
|
|
use uuid::Uuid;
|
|
|
|
use lmdb::{Transaction, RwTransaction, Cursor};
|
|
|
|
use smol::channel::{Receiver, Sender};
|
|
|
|
use futures_signals::signal::*;
|
|
|
|
use crate::registries::StatusSignal;
|
|
|
|
pub type ID = Uuid;
|
|
|
|
/// Status of a Machine
|
|
#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
|
|
#[repr(u8)]
|
|
pub enum Status {
|
|
/// Not currently used by anybody
|
|
Free,
|
|
/// Used by somebody
|
|
Occupied,
|
|
/// Not used by anybody but also can not be used. E.g. down for maintenance
|
|
Blocked,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Machines {
|
|
inner: Arc<RwLock<MachinesProvider>>,
|
|
}
|
|
impl Machines {
|
|
pub fn new(inner: Arc<RwLock<MachinesProvider>>) -> Self {
|
|
Self { inner }
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct GiveBack {
|
|
mdb: Arc<RwLock<MachinesProvider>>,
|
|
uuid: Uuid,
|
|
}
|
|
impl GiveBack {
|
|
pub fn new(mdb: Arc<RwLock<MachinesProvider>>, uuid: Uuid) -> Self {
|
|
Self { mdb, uuid }
|
|
}
|
|
}
|
|
|
|
fn uuid_from_api(uuid: crate::api::api_capnp::u_u_i_d::Reader) -> Uuid {
|
|
let uuid0 = uuid.get_uuid0() as u128;
|
|
let uuid1 = uuid.get_uuid1() as u128;
|
|
let num: u128 = (uuid1 << 64) + uuid0;
|
|
Uuid::from_u128(num)
|
|
}
|
|
fn api_from_uuid(uuid: Uuid, mut wr: crate::api::api_capnp::u_u_i_d::Builder) {
|
|
let num = uuid.to_u128_le();
|
|
let uuid0 = num as u64;
|
|
let uuid1 = (num >> 64) as u64;
|
|
wr.set_uuid0(uuid0);
|
|
wr.set_uuid1(uuid1);
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct MachineManager {
|
|
mdb: Arc<RwLock<MachinesProvider>>,
|
|
uuid: Uuid,
|
|
}
|
|
|
|
impl MachineManager {
|
|
pub fn new(uuid: Uuid, mdb: Arc<RwLock<MachinesProvider>>) -> Self {
|
|
Self { mdb, uuid }
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
/// Internal machine representation
|
|
///
|
|
/// A machine connects an event from a sensor to an actor activating/deactivating a real-world
|
|
/// machine, checking that the user who wants the machine (de)activated has the required
|
|
/// permissions.
|
|
pub struct Machine {
|
|
/// Computer-readable identifier for this machine
|
|
// Implicit in database since it's the key.
|
|
#[serde(skip)]
|
|
id: ID,
|
|
|
|
/// The human-readable name of the machine. Does not need to be unique
|
|
name: String,
|
|
|
|
/// The required permission to use this machine.
|
|
perm: access::PermIdentifier,
|
|
|
|
/// The state of the machine as bffh thinks the machine *should* be in.
|
|
///
|
|
/// This is a Signal generator. Subscribers to this signal will be notified of changes. In the
|
|
/// case of an actor it should then make sure that the real world matches up with the set state
|
|
state: Mutable<Status>,
|
|
}
|
|
|
|
impl Machine {
|
|
pub fn new(id: Uuid, name: String, perm: access::PermIdentifier) -> Machine {
|
|
Machine {
|
|
id: id,
|
|
name: name,
|
|
perm: perm,
|
|
state: Mutable::new(Status::Free),
|
|
}
|
|
}
|
|
|
|
/// Generate a signal from the internal state.
|
|
///
|
|
/// A signal is a lossy stream of state changes. Lossy in that if changes happen in quick
|
|
/// succession intermediary values may be lost. But this isn't really relevant in this case
|
|
/// since the only relevant state is the latest one.
|
|
/// dedupe ensures that if state is changed but only changes to the value it had beforehand
|
|
/// (could for example happen if the machine changes current user but stays activated) no
|
|
/// update is sent.
|
|
pub fn signal(&self) -> StatusSignal {
|
|
Box::pin(self.state.signal().dedupe())
|
|
}
|
|
|
|
/// Requests to use a machine. Returns `true` if successful.
|
|
///
|
|
/// This will update the internal state of the machine, notifying connected actors, if any.
|
|
pub fn request_use<T: Transaction>
|
|
( &mut self
|
|
, txn: &T
|
|
, pp: &access::PermissionsProvider
|
|
, who: access::UserIdentifier
|
|
) -> Result<bool>
|
|
{
|
|
if pp.check(txn, who, self.perm)? {
|
|
self.state.set(Status::Occupied);
|
|
return Ok(true);
|
|
} else {
|
|
return Ok(false);
|
|
}
|
|
}
|
|
|
|
pub fn set_state(&mut self, state: Status) {
|
|
self.state.set(state)
|
|
}
|
|
}
|
|
|
|
pub struct MachinesProvider {
|
|
log: Logger,
|
|
db: lmdb::Database,
|
|
}
|
|
|
|
impl MachinesProvider {
|
|
pub fn new(log: Logger, db: lmdb::Database) -> Self {
|
|
Self { log, db }
|
|
}
|
|
|
|
pub fn get_machine<T: Transaction>(&self, txn: &T, uuid: Uuid)
|
|
-> Result<Option<Machine>>
|
|
{
|
|
match txn.get(self.db, &uuid.as_bytes()) {
|
|
Ok(bytes) => {
|
|
let mut machine: Machine = flexbuffers::from_slice(bytes)?;
|
|
machine.id = uuid;
|
|
|
|
Ok(Some(machine))
|
|
},
|
|
Err(lmdb::Error::NotFound) => { Ok(None) },
|
|
Err(e) => { Err(e.into()) },
|
|
}
|
|
}
|
|
|
|
pub fn put_machine( &self, txn: &mut RwTransaction, uuid: Uuid, machine: Machine)
|
|
-> Result<()>
|
|
{
|
|
let bytes = flexbuffers::to_vec(machine)?;
|
|
txn.put(self.db, &uuid.as_bytes(), &bytes, lmdb::WriteFlags::empty())?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn load_db(&mut self, txn: &mut RwTransaction, mut path: PathBuf) -> Result<()> {
|
|
path.push("machines");
|
|
for entry in std::fs::read_dir(path)? {
|
|
let entry = entry?;
|
|
let path = entry.path();
|
|
if path.is_file() {
|
|
// will only ever be none if the path has no file name and then how is it a file?!
|
|
let machID_str = path
|
|
.file_stem().expect("Found a file with no filename?")
|
|
.to_str().expect("Found an OsStr that isn't valid Unicode. Fix your OS!");
|
|
let machID = match uuid::Uuid::from_str(machID_str) {
|
|
Ok(i) => i,
|
|
Err(e) => {
|
|
warn!(self.log, "File {} had a invalid name. Expected an u64 in [0-9a-z] hex with optional file ending: {}. Skipping!", path.display(), e);
|
|
continue;
|
|
}
|
|
};
|
|
let s = match fs::read_to_string(path.as_path()) {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
warn!(self.log, "Failed to open file {}: {}, skipping!"
|
|
, path.display()
|
|
, e);
|
|
continue;
|
|
}
|
|
};
|
|
let mach: Machine = match toml::from_str(&s) {
|
|
Ok(r) => r,
|
|
Err(e) => {
|
|
warn!(self.log, "Failed to parse mach at path {}: {}, skipping!"
|
|
, path.display()
|
|
, e);
|
|
continue;
|
|
}
|
|
};
|
|
self.put_machine(txn, machID, mach)?;
|
|
debug!(self.log, "Loaded machine {}", machID);
|
|
} else {
|
|
warn!(self.log, "Path {} is not a file, skipping!", path.display());
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn dump_db<T: Transaction>(&self, txn: &T, mut path: PathBuf) -> Result<()> {
|
|
path.push("machines");
|
|
let mut mach_cursor = txn.open_ro_cursor(self.db)?;
|
|
for buf in mach_cursor.iter_start() {
|
|
let (kbuf, vbuf) = buf?;
|
|
let machID = uuid::Uuid::from_slice(kbuf).unwrap();
|
|
let mach: Machine = flexbuffers::from_slice(vbuf)?;
|
|
let filename = format!("{}.yml", machID.to_hyphenated().to_string());
|
|
path.set_file_name(filename);
|
|
let mut fp = std::fs::File::create(&path)?;
|
|
let out = toml::to_vec(&mach)?;
|
|
fp.write_all(&out)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub fn init(log: Logger, config: &Settings, env: &lmdb::Environment) -> Result<MachinesProvider> {
|
|
let mut flags = lmdb::DatabaseFlags::empty();
|
|
flags.set(lmdb::DatabaseFlags::INTEGER_KEY, true);
|
|
let machdb = env.create_db(Some("machines"), flags)?;
|
|
debug!(&log, "Opened machine db successfully.");
|
|
|
|
Ok(MachinesProvider::new(log, machdb))
|
|
}
|