NG-SD-Plugins/usdpl-rs
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity

Merge branch 'next'

Browse source
This commit is contained in:
NGnius (Graham) 2024-04-02 17:57:03 -04:00
commit 811aa01444
54 changed files with 3524 additions and 2176 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1329
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

32
Cargo.toml
View file

@ -1,13 +1,16 @@
[package]
name = "usdpl"
version = "0.10.0"
authors = ["NGnius (Graham) <ngniusness@gmail.com>"]
edition = "2021"
license = "GPL-3.0-only"
repository = "https://github.com/NGnius/usdpl-rs"
readme = "README.md"
[workspace]
members = [
"usdpl-core",
"usdpl-front",
"usdpl-back",
"usdpl-build",
]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
exclude = [
"templates/decky/backend"
]
resolver = "2"
[profile.release]
# Tell `rustc` to optimize for small code size.
@ -16,14 +19,3 @@ debug = false
strip = true
lto = true
codegen-units = 4
[workspace]
members = [
"usdpl-core",
"usdpl-front",
"usdpl-back",
]
exclude = [
"templates/decky/backend"
]

33
usdpl-back/Cargo.toml
View file

@ -1,29 +1,35 @@
[package]
name = "usdpl-back"
version = "0.10.1"
version = "0.11.0"
edition = "2021"
authors = ["NGnius <ngniusness@gmail.com>"]
license = "GPL-3.0-only"
repository = "https://github.com/NGnius/usdpl-rs"
readme = "README.md"
repository = "https://git.ngni.us/NG-SD-Plugins/usdpl-rs"
readme = "../README.md"
description = "Universal Steam Deck Plugin Library back-end"
[features]
default = ["blocking", "translate"]
default = ["blocking"]
decky = ["usdpl-core/decky"]
crankshaft = ["usdpl-core/crankshaft"]
blocking = ["tokio", "tokio/rt", "tokio/rt-multi-thread"] # synchronous API for async functionality, using tokio
encrypt = ["usdpl-core/encrypt", "obfstr", "hex"]
translate = ["usdpl-core/translate", "gettext-ng"]
blocking = [] # synchronous API for async functionality, using tokio
#encrypt = ["usdpl-core", "obfstr", "hex"]
[dependencies]
usdpl-core = { version = "0.10", path = "../usdpl-core"}
usdpl-core = { version = "0.11", path = "../usdpl-core"}
log = "0.4"
# gRPC/protobuf
nrpc = { version = "0.10", path = "../../nRPC/nrpc", default-features = false, features = [ "server-send" ] }
async-lock = "2.7"
prost = "0.11"
# websocket framework
ratchet_rs = { version = "0.4", features = [ "deflate" ] }
# HTTP web framework
warp = { version = "0.3" }
bytes = { version = "1.1" }
tokio = { version = "1", optional = true }
tokio = { version = "1", features = [ "full" ]}
# this is why people don't like async
async-trait = "0.1.57"
@ -34,4 +40,7 @@ obfstr = { version = "0.3", optional = true }
hex = { version = "0.4", optional = true }
# translations
gettext-ng = { version = "0.4.1", optional = true }
gettext-ng = { version = "0.4.1" }
[build-dependencies]
usdpl-build = { version = "0.11", path = "../usdpl-build" }

6
usdpl-back/build.rs Normal file
View file

@ -0,0 +1,6 @@
fn main() {
usdpl_build::back::build_with_custom_builtins(
[].into_iter(),
[].into_iter(),
)
}

8
usdpl-back/src/api_any/dirs.rs
View file

@ -5,14 +5,10 @@ use std::process::Command;
/// The home directory of the user currently running the Steam Deck UI (specifically: running gamescope).
pub fn home() -> Option<PathBuf> {
let who_out = Command::new("who")
.output().ok()?;
let who_out = Command::new("who").output().ok()?;
let who_str = String::from_utf8_lossy(who_out.stdout.as_slice());
for login in who_str.split("\n") {
let username = login
.split(" ")
.next()?
.trim();
let username = login.split(" ").next()?.trim();
let path = Path::new("/home").join(username);
if path.is_dir() {
return Some(path);

16
usdpl-back/src/api_common/dirs.rs
View file

@ -6,15 +6,11 @@ use std::path::PathBuf;
pub fn home() -> Option<PathBuf> {
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
let result = crate::api_any::dirs::home();
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
let result = None; // TODO
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
let result = crate::api_decky::home().ok()
.map(|x| PathBuf::from(x)
.join("..")
.canonicalize()
.ok()
).flatten();
let result = crate::api_decky::home()
.ok()
.map(|x| PathBuf::from(x).join("..").canonicalize().ok())
.flatten();
result
}
@ -23,8 +19,6 @@ pub fn home() -> Option<PathBuf> {
pub fn plugin() -> Option<PathBuf> {
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
let result = None; // TODO
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
let result = None; // TODO
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
let result = crate::api_decky::plugin_dir().ok().map(|x| x.into());
@ -35,8 +29,6 @@ pub fn plugin() -> Option<PathBuf> {
pub fn log() -> Option<PathBuf> {
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
let result = crate::api_any::dirs::log();
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
let result = None; // TODO
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
let result = crate::api_decky::log_dir().ok().map(|x| x.into());

46
usdpl-back/src/api_common/files.rs
View file

@ -1,46 +0,0 @@
//! Common low-level file operations
use std::fmt::Display;
use std::path::Path;
use std::fs::File;
use std::io::{Read, Write, self};
use std::str::FromStr;
/// Write something to a file.
/// Useful for kernel configuration files.
#[inline]
pub fn write_single<P: AsRef<Path>, D: Display>(path: P, display: D) -> Result<(), io::Error> {
let mut file = File::create(path)?;
write!(file, "{}", display)
}
/// read_single error
#[derive(Debug)]
pub enum ReadError<E> {
/// IO Error
Io(io::Error),
/// String parsing error
Parse(E),
}
impl<E: std::error::Error> std::fmt::Display for ReadError<E> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Io(io) => write!(f, "io: {}", io),
Self::Parse(e) => write!(f, "parse: {}", e),
}
}
}
impl<E: std::error::Error> std::error::Error for ReadError<E> {
}
/// Read something from a file.
/// Useful for kernel configuration files.
#[inline]
pub fn read_single<P: AsRef<Path>, D: FromStr<Err=E>, E>(path: P) -> Result<D, ReadError<E>> {
let mut file = File::open(path).map_err(ReadError::Io)?;
let mut string = String::new();
file.read_to_string(&mut string).map_err(ReadError::Io)?;
string.trim().parse().map_err(ReadError::Parse)
}

1
usdpl-back/src/api_common/mod.rs
View file

@ -1,2 +1 @@
pub mod dirs;
pub mod files;

1
usdpl-back/src/api_crankshaft/mod.rs
View file

@ -1 +0,0 @@
compile_error!("Crankshaft unsupported (project no longer maintained)");

87
usdpl-back/src/callable.rs
View file

@ -1,87 +0,0 @@
use std::sync::{Arc, Mutex};
use usdpl_core::serdes::Primitive;
/// A mutable function which can be called from the front-end (remotely)
pub trait MutCallable: Send + Sync {
/// Invoke the function
fn call(&mut self, params: Vec<Primitive>) -> Vec<Primitive>;
}
impl<F: (FnMut(Vec<Primitive>) -> Vec<Primitive>) + Send + Sync> MutCallable for F {
fn call(&mut self, params: Vec<Primitive>) -> Vec<Primitive> {
(self)(params)
}
}
/// A function which can be called from the front-end (remotely)
pub trait Callable: Send + Sync {
/// Invoke the function
fn call(&self, params: Vec<Primitive>) -> Vec<Primitive>;
}
impl<F: (Fn(Vec<Primitive>) -> Vec<Primitive>) + Send + Sync> Callable for F {
fn call(&self, params: Vec<Primitive>) -> Vec<Primitive> {
(self)(params)
}
}
/// An async function which can be called from the front-end (remotely)
#[async_trait::async_trait]
pub trait AsyncCallable: Send + Sync {
/// Invoke the function
async fn call(&self, params: Vec<Primitive>) -> Vec<Primitive>;
}
#[async_trait::async_trait]
impl<F: (Fn(Vec<Primitive>) -> A) + Send + Sync, A: core::future::Future<Output=Vec<Primitive>> + Send> AsyncCallable for F {
async fn call(&self, params: Vec<Primitive>) -> Vec<Primitive> {
(self)(params).await
}
}
pub enum WrappedCallable {
Blocking(Arc<Mutex<Box<dyn MutCallable>>>),
Ref(Arc<Box<dyn Callable>>),
Async(Arc<Box<dyn AsyncCallable>>),
}
impl WrappedCallable {
pub fn new_ref<T: Callable + 'static>(callable: T) -> Self {
Self::Ref(Arc::new(Box::new(callable)))
}
pub fn new_locking<T: MutCallable + 'static>(callable: T) -> Self {
Self::Blocking(Arc::new(Mutex::new(Box::new(callable))))
}
pub fn new_async<T: AsyncCallable + 'static>(callable: T) -> Self {
Self::Async(Arc::new(Box::new(callable)))
}
}
impl Clone for WrappedCallable {
fn clone(&self) -> Self {
match self {
Self::Blocking(x) => Self::Blocking(x.clone()),
Self::Ref(x) => Self::Ref(x.clone()),
Self::Async(x) => Self::Async(x.clone()),
}
}
}
#[async_trait::async_trait]
impl AsyncCallable for WrappedCallable {
async fn call(&self, params: Vec<Primitive>) -> Vec<Primitive> {
match self {
Self::Blocking(mut_callable) => {
mut_callable
.lock()
.expect("Failed to acquire mut_callable lock")
.call(params)
},
Self::Ref(callable) => callable.call(params),
Self::Async(async_callable) => async_callable.call(params).await,
}
}
}

262
usdpl-back/src/instance.rs
View file

@ -1,262 +0,0 @@
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use warp::Filter;
use usdpl_core::serdes::{Dumpable, Loadable};
use usdpl_core::{socket, RemoteCallResponse};
use super::{Callable, MutCallable, AsyncCallable, WrappedCallable};
static LAST_ID: AtomicU64 = AtomicU64::new(0);
const MAX_ID_DIFFERENCE: u64 = 32;
//type WrappedCallable = Arc<Mutex<Box<dyn Callable>>>; // thread-safe, cloneable Callable
#[cfg(feature = "encrypt")]
const NONCE: [u8; socket::NONCE_SIZE] = [0u8; socket::NONCE_SIZE];
/// Back-end instance for interacting with the front-end
pub struct Instance {
calls: HashMap<String, WrappedCallable>,
port: u16,
#[cfg(feature = "encrypt")]
encryption_key: Vec<u8>,
}
impl Instance {
/// Initialise an instance of the back-end
#[inline]
pub fn new(port_usdpl: u16) -> Self {
Instance {
calls: HashMap::new(),
port: port_usdpl,
#[cfg(feature = "encrypt")]
encryption_key: hex::decode(obfstr::obfstr!(env!("USDPL_ENCRYPTION_KEY"))).unwrap(),
}
}
/// Register a thread-safe function which can be invoked by the front-end
pub fn register<S: std::convert::Into<String>, F: Callable + 'static>(
mut self,
name: S,
f: F,
) -> Self {
self.calls
.insert(name.into(), WrappedCallable::new_ref(f));
self
}
/// Register a thread-unsafe function which can be invoked by the front-end
pub fn register_blocking<S: std::convert::Into<String>, F: MutCallable + 'static>(
mut self,
name: S,
f: F,
) -> Self {
self.calls
.insert(name.into(), WrappedCallable::new_locking(f));
self
}
/// Register a thread-unsafe function which can be invoked by the front-end
pub fn register_async<S: std::convert::Into<String>, F: AsyncCallable + 'static>(
mut self,
name: S,
f: F,
) -> Self {
self.calls
.insert(name.into(), WrappedCallable::new_async(f));
self
}
/// Run the web server instance forever, blocking this thread
#[cfg(feature = "blocking")]
pub fn run_blocking(&self) -> Result<(), ()> {
let result = self.serve_internal();
tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()
.unwrap()
.block_on(result)
}
/// Run the web server forever, asynchronously
pub async fn run(&self) -> Result<(), ()> {
self.serve_internal().await
}
#[async_recursion::async_recursion]
async fn handle_call(
packet: socket::Packet,
handlers: &HashMap<String, WrappedCallable>,
) -> socket::Packet {
match packet {
socket::Packet::Call(call) => {
log::debug!("Got USDPL call {} (`{}`, params: {})", call.id, call.function, call.parameters.len());
let last_id = LAST_ID.load(Ordering::SeqCst);
if last_id == 0 {
log::info!("Last id is 0, assuming resumed connection (overriding last id)");
LAST_ID.store(call.id, Ordering::SeqCst);
} else if call.id < MAX_ID_DIFFERENCE {
log::info!("Call ID is low, assuming new connection (resetting last id)");
LAST_ID.store(call.id, Ordering::SeqCst);
} else if call.id > last_id && call.id - last_id < MAX_ID_DIFFERENCE {
LAST_ID.store(call.id, Ordering::SeqCst);
} else if call.id < last_id && last_id - call.id < MAX_ID_DIFFERENCE {
// Allowed, but don't store new (lower) LAST_ID
} else {
#[cfg(not(debug_assertions))]
{
log::error!("Got USDPL call with strange ID! got:{} last id:{} (rejecting packet)", call.id, last_id);
return socket::Packet::Invalid
}
#[cfg(debug_assertions)]
log::warn!("Got USDPL call with strange ID! got:{} last id:{} (in release mode this packet will be rejected)", call.id, last_id);
}
//let handlers = CALLS.lock().expect("Failed to acquire CALLS lock");
if let Some(target) = handlers.get(&call.function) {
let result = target.call(call.parameters).await;
socket::Packet::CallResponse(RemoteCallResponse {
id: call.id,
response: result,
})
} else {
socket::Packet::Invalid
}
},
socket::Packet::Many(packets) => {
let mut result = Vec::with_capacity(packets.len());
for packet in packets {
result.push(Self::handle_call(packet, handlers).await);
}
socket::Packet::Many(result)
},
#[cfg(feature = "translate")]
socket::Packet::Language(lang) => socket::Packet::Translations(get_all_translations(lang)),
_ => socket::Packet::Invalid,
}
}
#[cfg(not(feature = "encrypt"))]
async fn process_body((data, handlers): (bytes::Bytes, HashMap<String, WrappedCallable>)) -> impl warp::Reply {
let (packet, _) = match socket::Packet::load_base64(&data) {
Ok(x) => x,
Err(e) => {
return warp::reply::with_status(
warp::http::Response::builder()
.body(format!("Failed to load packet: {}", e)),
warp::http::StatusCode::from_u16(400).unwrap(),
)
}
};
//let mut buffer = [0u8; socket::PACKET_BUFFER_SIZE];
let mut buffer = String::with_capacity(socket::PACKET_BUFFER_SIZE);
let response = Self::handle_call(packet, &handlers).await;
let _len = match response.dump_base64(&mut buffer) {
Ok(x) => x,
Err(e) => {
return warp::reply::with_status(
warp::http::Response::builder()
.body(format!("Failed to dump response packet: {}", e)),
warp::http::StatusCode::from_u16(500).unwrap(),
)
}
};
warp::reply::with_status(
warp::http::Response::builder().body(buffer),
warp::http::StatusCode::from_u16(200).unwrap(),
)
}
#[cfg(feature = "encrypt")]
async fn process_body((data, handlers, key): (bytes::Bytes, HashMap<String, WrappedCallable>, Vec<u8>)) -> impl warp::Reply {
let (packet, _) = match socket::Packet::load_encrypted(&data, &key, &NONCE) {
Ok(x) => x,
Err(_) => {
return warp::reply::with_status(
warp::http::Response::builder()
.body("Failed to load packet".to_string()),
warp::http::StatusCode::from_u16(400).unwrap(),
)
}
};
let mut buffer = Vec::with_capacity(socket::PACKET_BUFFER_SIZE);
//buffer.extend(&[0u8; socket::PACKET_BUFFER_SIZE]);
let response = Self::handle_call(packet, &handlers).await;
let len = match response.dump_encrypted(&mut buffer, &key, &NONCE) {
Ok(x) => x,
Err(_) => {
return warp::reply::with_status(
warp::http::Response::builder()
.body("Failed to dump response packet".to_string()),
warp::http::StatusCode::from_u16(500).unwrap(),
)
}
};
buffer.truncate(len);
let string: String = String::from_utf8(buffer).unwrap().into();
warp::reply::with_status(
warp::http::Response::builder().body(string),
warp::http::StatusCode::from_u16(200).unwrap(),
)
}
/// Receive and execute callbacks forever
async fn serve_internal(&self) -> Result<(), ()> {
let handlers = self.calls.clone();
#[cfg(not(feature = "encrypt"))]
let input_mapper = move |data: bytes::Bytes| { (data, handlers.clone()) };
#[cfg(feature = "encrypt")]
let key = self.encryption_key.clone();
#[cfg(feature = "encrypt")]
let input_mapper = move |data: bytes::Bytes| { (data, handlers.clone(), key.clone()) };
//self.calls = HashMap::new();
let calls = warp::post()
.and(warp::path!("usdpl" / "call"))
.and(warp::body::content_length_limit(
(socket::PACKET_BUFFER_SIZE * 2) as _,
))
.and(warp::body::bytes())
.map(input_mapper)
.then(Self::process_body)
.map(|reply| warp::reply::with_header(reply, "Access-Control-Allow-Origin", "*"));
#[cfg(debug_assertions)]
warp::serve(calls).run(([0, 0, 0, 0], self.port)).await;
#[cfg(not(debug_assertions))]
warp::serve(calls).run(([127, 0, 0, 1], self.port)).await;
Ok(())
}
}
#[cfg(feature = "translate")]
fn get_all_translations(language: String) -> Vec<(String, Vec<String>)> {
log::debug!("Loading translations for language `{}`...", language);
let result = load_locale(&language);
match result {
Ok(catalog) => {
let map = catalog.nalltext();
let mut result = Vec::with_capacity(map.len());
for (key, val) in map.iter() {
result.push((key.to_owned().into(), val.iter().map(|x| x.into()).collect()));
}
result
},
Err(e) => {
log::error!("Failed to load translations for language `{}`: {}", language, e);
vec![]
}
}
}
#[cfg(feature = "translate")]
fn load_locale(lang: &str) -> Result<gettext_ng::Catalog, gettext_ng::Error> {
let path = crate::api::dirs::plugin().unwrap_or_else(|| "".into()).join("translations").join(format!("{}.mo", lang));
let file = std::fs::File::open(path).map_err(|e| gettext_ng::Error::Io(e))?;
gettext_ng::Catalog::parse(file)
}
#[cfg(test)]
mod tests {
#[allow(unused_imports)]
use super::*;
}

53
usdpl-back/src/lib.rs
View file

@ -5,42 +5,59 @@
//!
#![warn(missing_docs)]
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
#[cfg(not(any(feature = "decky")))]
mod api_any;
mod api_common;
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
mod api_crankshaft;
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
#[cfg(all(feature = "decky", not(any(feature = "any"))))]
mod api_decky;
mod callable;
//mod errors;
mod instance;
mod rpc;
mod services_impl;
pub use callable::{Callable, MutCallable, AsyncCallable};
pub(crate) use callable::WrappedCallable;
pub use instance::Instance;
//mod errors;
mod websockets;
pub use websockets::WebsocketServer as Server;
//pub use errors::{ServerError, ServerResult};
#[allow(missing_docs)]
#[allow(dead_code)]
pub(crate) mod services {
include!(concat!(env!("OUT_DIR"), "/mod.rs"));
}
/// USDPL backend API.
/// This contains functionality used exclusively by the back-end.
pub mod api {
pub use super::api_common::*;
/// Standard interfaces not specific to a single plugin loader
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
pub mod any { pub use super::super::api_any::*; }
/// Crankshaft-specific interfaces (FIXME)
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
pub mod crankshaft { pub use super::super::api_crankshaft::*; }
#[cfg(not(any(feature = "decky")))]
pub mod any {
pub use super::super::api_any::*;
}
/// Decky-specific interfaces
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
pub mod decky { pub use super::super::api_decky::*; }
#[cfg(all(feature = "decky", not(any(feature = "any"))))]
pub mod decky {
pub use super::super::api_decky::*;
}
}
/// usdpl-core re-export
pub mod core {
pub use usdpl_core::*;
}
/// nrpc re-export
pub mod nrpc {
pub use nrpc::*;
}
/*/// nRPC-generated exports
#[allow(missing_docs)]
#[allow(dead_code)]
pub mod services {
include!(concat!(env!("OUT_DIR"), "/mod.rs"));
}*/

5
usdpl-back/src/rpc/mod.rs Normal file
View file

@ -0,0 +1,5 @@
mod registry;
pub use registry::{ServiceRegistry, StaticServiceRegistry};
mod websocket_stream;
pub use websocket_stream::ws_stream;

43
usdpl-back/src/rpc/registry.rs Normal file
View file

@ -0,0 +1,43 @@
use async_lock::Mutex;
use std::collections::HashMap;
use std::sync::Arc;
use nrpc::{ServerService, ServiceError, ServiceServerStream};
pub type StaticServiceRegistry = ServiceRegistry<'static>;
#[derive(Default, Clone)]
pub struct ServiceRegistry<'a> {
entries: HashMap<String, Arc<Mutex<Box<dyn ServerService<'a> + Send + 'a>>>>,
}
impl<'a> ServiceRegistry<'a> {
pub async fn call_descriptor<'b: 'a>(
&mut self,
descriptor: &str,
method: &str,
input: ServiceServerStream<'a, bytes::Bytes>,
) -> Result<ServiceServerStream<'a, bytes::Bytes>, ServiceError> {
if let Some(service) = self.entries.get(descriptor) {
let mut service_lock = service.lock_arc().await;
let output = service_lock.call(method, input).await?;
Ok(output.into())
} else {
Err(ServiceError::ServiceNotFound)
}
}
pub fn register<S: ServerService<'a> + Send + 'a>(&mut self, service: S) -> &mut Self {
let key = service.descriptor().to_owned();
self.entries
.insert(key, Arc::new(Mutex::new(Box::new(service))));
self
}
pub fn with_builtins() -> Self {
let mut reg = Self::default();
reg.register(crate::services::usdpl::DevToolsServer::new(crate::services_impl::DevTools{}))
.register(crate::services::usdpl::TranslationsServer::new(crate::services_impl::Translations{}));
reg
}
}

34
usdpl-back/src/rpc/websocket_stream.rs Normal file
View file

@ -0,0 +1,34 @@
use core::marker::Unpin;
use std::sync::Arc;
use tokio::{net::TcpStream, sync::Mutex};
use ratchet_rs::{WebSocket, Message, Error as RatchetError, Extension};
use nrpc::ServiceError;
use nrpc::_helpers::futures::Stream;
use nrpc::_helpers::bytes::{BytesMut, Bytes};
struct WsStreamState<T: Extension + Unpin>{
ws: Arc<Mutex<WebSocket<TcpStream, T>>>,
buf: BytesMut,
}
pub fn ws_stream<'a, T: Extension + Unpin + 'a>(ws: Arc<Mutex<WebSocket<TcpStream, T>>>) -> impl Stream<Item = Result<Bytes, ServiceError>> + 'a {
nrpc::_helpers::futures::stream::unfold(WsStreamState { ws, buf: BytesMut::new() }, |mut state| async move {
let mut locked_ws = state.ws.lock().await;
if locked_ws.is_closed() || !locked_ws.is_active() {
None
} else {
let result = locked_ws.read(&mut state.buf).await;
drop(locked_ws);
match result {
Ok(Message::Binary) => Some((Ok(state.buf.clone().freeze()), state)),
Ok(_) => Some((Err(ServiceError::Method(Box::new(RatchetError::with_cause(
ratchet_rs::ErrorKind::Protocol,
"Websocket text messages are not accepted",
)))), state)),
Err(e) => Some((Err(ServiceError::Method(Box::new(e))), state))
}
}
})
}

22
usdpl-back/src/services_impl/dev_tools.rs Normal file
View file

@ -0,0 +1,22 @@
use crate::services::usdpl as generated;
/// Built-in dev tools service implementation
pub(crate) struct DevTools {}
#[async_trait::async_trait]
impl<'a> generated::IDevTools<'a> for DevTools {
async fn log(
&mut self,
input: generated::LogMessage,
) -> Result<generated::Empty, Box<dyn std::error::Error + Send>> {
match input.level {
lvl if lvl == generated::LogLevel::Trace as _ => log::trace!("{}", input.msg),
lvl if lvl == generated::LogLevel::Debug as _ => log::debug!("{}", input.msg),
lvl if lvl == generated::LogLevel::Info as _ => log::info!("{}", input.msg),
lvl if lvl == generated::LogLevel::Warn as _ => log::warn!("{}", input.msg),
lvl if lvl == generated::LogLevel::Error as _ => log::error!("{}", input.msg),
lvl => return Err(Box::<dyn std::error::Error + Send + Sync>::from(format!("Unexpected input log level {}", lvl)))
}
Ok(generated::Empty{ ok: true })
}
}

5
usdpl-back/src/services_impl/mod.rs Normal file
View file

@ -0,0 +1,5 @@
mod dev_tools;
pub(crate) use dev_tools::DevTools;
mod translations;
pub(crate) use translations::Translations;

31
usdpl-back/src/services_impl/translations.rs Normal file
View file

@ -0,0 +1,31 @@
use crate::services::usdpl as generated;
/// Built-in translation service implementation
pub(crate) struct Translations {}
#[async_trait::async_trait]
impl<'a> generated::ITranslations<'a> for Translations {
async fn get_language(
&mut self,
input: generated::LanguageRequest,
) -> Result<generated::TranslationsReply, Box<dyn std::error::Error + Send>> {
let catalog = load_locale(&input.lang).map_err(|e| Box::new(e) as _)?;
let catalog_map = catalog.nalltext();
let mut map = std::collections::HashMap::with_capacity(catalog_map.len());
for (key, val) in catalog_map.into_iter() {
if val.len() > 1 {
log::warn!("Translations key {} for language {} has plural entries which aren't currently supported", key, input.lang);
}
if let Some(val_0) = val.get(0) {
map.insert(key.to_owned(), val_0.to_owned());
}
}
Ok(generated::TranslationsReply { translations: map })
}
}
fn load_locale(lang: &str) -> Result<gettext_ng::Catalog, gettext_ng::Error> {
let path = crate::api::dirs::plugin().unwrap_or_else(|| "".into()).join("translations").join(format!("{}.mo", lang));
let file = std::fs::File::open(path).map_err(|e| gettext_ng::Error::Io(e))?;
gettext_ng::Catalog::parse(file)
}

175
usdpl-back/src/websockets.rs Normal file
View file

@ -0,0 +1,175 @@
use ratchet_rs::deflate::DeflateExtProvider;
use ratchet_rs::{Error as RatchetError, ProtocolRegistry, WebSocketConfig};
use tokio::net::{TcpListener, TcpStream};
use nrpc::_helpers::futures::StreamExt;
use crate::rpc::StaticServiceRegistry;
struct MethodDescriptor<'a> {
service: &'a str,
method: &'a str,
}
/// Handler for communication to and from the front-end
pub struct WebsocketServer {
services: StaticServiceRegistry,
port: u16,
}
impl WebsocketServer {
/// Initialise an instance of the back-end websocket server
pub fn new(port_usdpl: u16) -> Self {
Self {
services: StaticServiceRegistry::with_builtins(),
port: port_usdpl,
}
}
/// Get the service registry that the server handles
pub fn registry(&mut self) -> &'_ mut StaticServiceRegistry {
&mut self.services
}
/// Register a nRPC service for this server to handle
pub fn register<S: nrpc::ServerService<'static> + Send + 'static>(mut self, service: S) -> Self {
self.services.register(service);
self
}
/// Run the web server forever, asynchronously
pub async fn run(&self) -> std::io::Result<()> {
#[cfg(debug_assertions)]
let addr = (std::net::Ipv4Addr::UNSPECIFIED, self.port);
#[cfg(not(debug_assertions))]
let addr = (std::net::Ipv4Addr::LOCALHOST, self.port);
let tcp = TcpListener::bind(addr).await?;
while let Ok((stream, _addr_do_not_use)) = tcp.accept().await {
tokio::spawn(error_logger("USDPL websocket server error", Self::connection_handler(self.services.clone(), stream)));
}
Ok(())
}
#[cfg(feature = "blocking")]
/// Run the server forever, blocking the current thread
pub fn run_blocking(self) -> std::io::Result<()> {
let runner = tokio::runtime::Builder::new_multi_thread()
.enable_all()
.build()?;
runner.block_on(self.run())
}
async fn connection_handler(
mut services: StaticServiceRegistry,
stream: TcpStream,
) -> Result<(), RatchetError> {
log::debug!("connection_handler invoked!");
let upgraded = ratchet_rs::accept_with(
stream,
WebSocketConfig::default(),
DeflateExtProvider::default(),
ProtocolRegistry::new(["usdpl-nrpc"])?,
)
.await?
.upgrade()
.await?;
let request_path = upgraded.request.uri().path();
log::debug!("accepted new connection on uri {}", request_path);
let websocket = std::sync::Arc::new(tokio::sync::Mutex::new(upgraded.websocket));
let descriptor = Self::parse_uri_path(request_path)
.map_err(|e| RatchetError::with_cause(ratchet_rs::ErrorKind::Protocol, e))?;
let input_stream = Box::new(nrpc::_helpers::futures::stream::StreamExt::boxed(crate::rpc::ws_stream(websocket.clone())));
let output_stream = services
.call_descriptor(
descriptor.service,
descriptor.method,
input_stream,
)
.await
.map_err(|e| {
RatchetError::with_cause(ratchet_rs::ErrorKind::Protocol, e.to_string())
})?;
output_stream.for_each(|result| async {
match result {
Ok(msg) => {
let mut ws_lock = websocket.lock().await;
if let Err(e) = ws_lock.write_binary(msg).await {
log::error!("websocket error while writing response on uri {}: {}", request_path, e);
}
},
Err(e) => {
log::error!("service error while writing response on uri {}: {}", request_path, e);
}
}
}).await;
websocket.lock().await.close(ratchet_rs::CloseReason {
code: ratchet_rs::CloseCode::Normal,
description: None,
}).await?;
/*let mut buf = BytesMut::new();
loop {
match websocket.read(&mut buf).await? {
Message::Text => {
return Err(RatchetError::with_cause(
ratchet_rs::ErrorKind::Protocol,
"Websocket text messages are not accepted",
))
}
Message::Binary => {
log::debug!("got binary ws message on uri {}", request_path);
let response = services
.call_descriptor(
descriptor.service,
descriptor.method,
buf.clone().freeze(),
)
.await
.map_err(|e| {
RatchetError::with_cause(ratchet_rs::ErrorKind::Protocol, e.to_string())
})?;
log::debug!("service completed response on uri {}", request_path);
websocket.write_binary(response).await?;
}
Message::Ping(x) => websocket.write_pong(x).await?,
Message::Pong(_) => {}
Message::Close(_) => break,
}
}*/
log::debug!("ws connection {} closed", request_path);
Ok(())
}
fn parse_uri_path<'a>(path: &'a str) -> Result<MethodDescriptor<'a>, &'static str> {
let mut iter = path.trim_matches('/').split('/');
if let Some(service) = iter.next() {
if let Some(method) = iter.next() {
if iter.next().is_none() {
return Ok(MethodDescriptor { service, method });
} else {
Err("URL path has too many separators")
}
} else {
Err("URL path has no method")
}
} else {
Err("URL path has no service")
}
}
}
async fn error_logger<E: std::error::Error>(msg: &'static str, f: impl core::future::Future<Output=Result<(), E>>) {
if let Err(e) = f.await {
log::error!("{}: {}", msg, e);
}
}

23
usdpl-build/Cargo.toml Normal file
View file

@ -0,0 +1,23 @@
[package]
name = "usdpl-build"
version = "0.11.0"
edition = "2021"
authors = ["NGnius <ngniusness@gmail.com>"]
license = "GPL-3.0-only"
repository = "https://git.ngni.us/NG-SD-Plugins/usdpl-rs"
readme = "../README.md"
description = "Universal Steam Deck Plugin Library core"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
nrpc-build = { version = "0.10", path = "../../nRPC/nrpc-build" }
prost-build = "0.11"
prost-types = "0.11"
# code gen
prettyplease = "0.2"
quote = "1.0"
syn = "2.0"
proc-macro2 = "1.0"

27
usdpl-build/protos/debug.proto Normal file
View file

@ -0,0 +1,27 @@
syntax = "proto3";
package usdpl;
// The translation service
service DevTools {
// Retrieves all translations for the provided 4-letter code
rpc Log (LogMessage) returns (Empty);
}
enum LogLevel {
Trace = 0;
Debug = 1;
Info = 2;
Warn = 3;
Error = 4;
}
// The request message containing the log message
message LogMessage {
LogLevel level = 1;
string msg = 2;
}
message Empty {
bool ok = 1;
}

19
usdpl-build/protos/translations.proto Normal file
View file

@ -0,0 +1,19 @@
syntax = "proto3";
package usdpl;
// The translation service
service Translations {
// Retrieves all translations for the provided 4-letter code
rpc GetLanguage (LanguageRequest) returns (TranslationsReply) {}
}
// The request message containing the language code
message LanguageRequest {
string lang = 1;
}
// The response message containing all translations for the language
message TranslationsReply {
map<string, string> translations = 1;
}

20
usdpl-build/src/back/mod.rs Normal file
View file

@ -0,0 +1,20 @@
pub fn build(
custom_protos: impl Iterator<Item = String>,
custom_dirs: impl Iterator<Item = String>,
) {
nrpc_build::compile_servers(
custom_protos,
crate::proto_out_paths(custom_dirs),
)
}
pub fn build_with_custom_builtins(
custom_protos: impl Iterator<Item = String>,
custom_dirs: impl Iterator<Item = String>,
) {
crate::dump_protos_out().unwrap();
nrpc_build::compile_servers(
crate::all_proto_filenames(crate::proto_builtins_out_path(), custom_protos),
crate::proto_out_paths(custom_dirs),
)
}

45
usdpl-build/src/front/mod.rs Normal file
View file

@ -0,0 +1,45 @@
mod preprocessor;
pub use preprocessor::WasmProtoPreprocessor;
mod service_generator;
pub use service_generator::WasmServiceGenerator;
mod shared_state;
pub(crate) use shared_state::SharedState;
pub fn build(
custom_protos: impl Iterator<Item = String>,
custom_dirs: impl Iterator<Item = String>,
) {
let shared_state = SharedState::new();
crate::dump_protos_out().unwrap();
nrpc_build::Transpiler::new(
crate::all_proto_filenames(crate::proto_builtins_out_path(), custom_protos),
crate::proto_out_paths(custom_dirs),
)
.unwrap()
.generate_client()
.with_preprocessor(nrpc_build::AbstractImpl::outer(
WasmProtoPreprocessor::with_state(&shared_state),
))
.with_service_generator(nrpc_build::AbstractImpl::outer(
WasmServiceGenerator::with_state(&shared_state),
))
.transpile()
.unwrap()
}
pub fn build_min(
custom_protos: impl Iterator<Item = String>,
custom_dirs: impl Iterator<Item = String>,
) {
crate::dump_protos_out().unwrap();
nrpc_build::Transpiler::new(
crate::all_proto_filenames(crate::proto_builtins_out_path(), custom_protos),
crate::proto_out_paths(custom_dirs),
)
.unwrap()
.generate_client()
.transpile()
.unwrap()
}

24
usdpl-build/src/front/preprocessor.rs Normal file
View file

@ -0,0 +1,24 @@
use nrpc_build::IPreprocessor;
//use prost_build::{Service, ServiceGenerator};
use prost_types::FileDescriptorSet;
use super::SharedState;
pub struct WasmProtoPreprocessor {
shared: SharedState,
}
impl WasmProtoPreprocessor {
pub fn with_state(state: &SharedState) -> Self {
Self {
shared: state.clone(),
}
}
}
impl IPreprocessor for WasmProtoPreprocessor {
fn process(&mut self, fds: &mut FileDescriptorSet) -> proc_macro2::TokenStream {
self.shared.lock().expect("Cannot lock shared state").fds = Some(fds.clone());
quote::quote! {}
}
}

1117
usdpl-build/src/front/service_generator.rs Normal file
View file

File diff suppressed because it is too large Load diff

24
usdpl-build/src/front/shared_state.rs Normal file
View file

@ -0,0 +1,24 @@
use std::sync::{Arc, Mutex};
use prost_types::FileDescriptorSet;
#[derive(Clone)]
pub struct SharedState(Arc<Mutex<SharedProtoData>>);
impl SharedState {
pub fn new() -> Self {
Self(Arc::new(Mutex::new(SharedProtoData { fds: None })))
}
}
impl std::ops::Deref for SharedState {
type Target = Arc<Mutex<SharedProtoData>>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
pub struct SharedProtoData {
pub fds: Option<FileDescriptorSet>,
}

7
usdpl-build/src/lib.rs Normal file
View file

@ -0,0 +1,7 @@
pub mod back;
pub mod front;
mod proto_files;
pub use proto_files::{
all_proto_filenames, dump_protos, dump_protos_out, proto_builtins_out_path, proto_out_paths,
};

86
usdpl-build/src/proto_files.rs Normal file
View file

@ -0,0 +1,86 @@
use std::path::{Path, PathBuf};
struct IncludedFileStr<'a> {
filename: &'a str,
contents: &'a str,
}
const ADDITIONAL_PROTOBUFS_ENV_VAR: &'static str = "USDPL_PROTOS_PATH";
const DEBUG_PROTO: IncludedFileStr<'static> = IncludedFileStr {
filename: "debug.proto",
contents: include_str!("../protos/debug.proto"),
};
const TRANSLATIONS_PROTO: IncludedFileStr<'static> = IncludedFileStr {
filename: "translations.proto",
contents: include_str!("../protos/translations.proto"),
};
const ALL_PROTOS: [IncludedFileStr<'static>; 2] = [DEBUG_PROTO, TRANSLATIONS_PROTO];
pub fn proto_builtins_out_path() -> PathBuf {
PathBuf::from(std::env::var("OUT_DIR").expect("Not in a build.rs context (missing $OUT_DIR)"))
.join("protos")
}
pub fn proto_out_paths(additionals: impl Iterator<Item = String>) -> impl Iterator<Item = String> {
std::iter::once(proto_builtins_out_path())
.map(|x| x.to_str().unwrap().to_owned())
.chain(custom_protos_dirs(additionals).into_iter())
}
fn custom_protos_dirs(additionals: impl Iterator<Item = String>) -> Vec<String> {
let dirs = std::env::var(ADDITIONAL_PROTOBUFS_ENV_VAR).unwrap_or_else(|_| "".to_owned());
dirs.split(':')
.filter(|x| std::fs::read_dir(x).is_ok())
.map(|x| x.to_owned())
.chain(additionals)
.collect()
}
fn custom_protos_filenames() -> Vec<String> {
let dirs = std::env::var(ADDITIONAL_PROTOBUFS_ENV_VAR).unwrap_or_else(|_| "".to_owned());
dirs.split(':')
.map(std::fs::read_dir)
.filter(|x| x.is_ok())
.flat_map(|x| x.unwrap())
.filter(|x| x.is_ok())
.map(|x| x.unwrap().path())
.filter(|x| {
if let Some(ext) = x.extension() {
ext.to_ascii_lowercase() == "proto" && x.is_file()
} else {
false
}
})
.filter_map(|x| x.to_str().map(|x| x.to_owned()))
.collect()
}
pub fn all_proto_filenames(
p: impl AsRef<Path> + 'static,
additionals: impl Iterator<Item = String>,
) -> impl Iterator<Item = String> {
//let p = p.as_ref();
ALL_PROTOS
.iter()
.map(move |x| p.as_ref().join(x.filename).to_str().unwrap().to_owned())
.chain(custom_protos_filenames())
.chain(additionals)
}
pub fn dump_protos(p: impl AsRef<Path>) -> std::io::Result<()> {
let p = p.as_ref();
for f in ALL_PROTOS {
let fullpath = p.join(f.filename);
std::fs::write(fullpath, f.contents)?;
}
Ok(())
}
pub fn dump_protos_out() -> std::io::Result<()> {
let path = proto_builtins_out_path();
std::fs::create_dir_all(&path)?;
dump_protos(&path)
}

12
usdpl-core/Cargo.toml
View file

@ -1,22 +1,22 @@
[package]
name = "usdpl-core"
version = "0.10.0"
version = "0.11.0"
authors = ["NGnius <ngniusness@gmail.com>"]
edition = "2021"
license = "GPL-3.0-only"
repository = "https://github.com/NGnius/usdpl-rs"
readme = "README.md"
description = "Universal Steam Deck Plugin Library core"
repository = "https://git.ngni.us/NG-SD-Plugins/usdpl-rs"
readme = "../README.md"
description = "Universal Steam Deck Plugin Library core designed for all architectures"
[features]
default = []
decky = []
crankshaft = []
encrypt = ["aes-gcm-siv"]
translate = []
[dependencies]
base64 = "0.13"
aes-gcm-siv = { version = "0.10", optional = true, default-features = false, features = ["alloc", "aes"] }
# nrpc = "0.2"
[dev-dependencies]
hex-literal = "0.3.4"

7
usdpl-core/src/api_common/target.rs
View file

@ -4,8 +4,6 @@ pub enum Platform {
Any,
/// Decky aka PluginLoader platform
Decky,
/// Crankshaft platform
Crankshaft,
}
impl Platform {
@ -16,10 +14,6 @@ impl Platform {
{
Self::Decky
}
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
{
Self::Crankshaft
}
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
{
Self::Any
@ -32,7 +26,6 @@ impl std::fmt::Display for Platform {
match self {
Self::Any => write!(f, "any"),
Self::Decky => write!(f, "decky"),
Self::Crankshaft => write!(f, "crankshaft"),
}
}
}

1
usdpl-core/src/api_crankshaft/mod.rs
View file

@ -1 +0,0 @@

19
usdpl-core/src/lib.rs
View file

@ -2,29 +2,18 @@
//! This contains serialization functionality and networking datatypes.
#![warn(missing_docs)]
mod remote_call;
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
#[cfg(not(any(feature = "decky")))]
mod api_any;
mod api_common;
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
mod api_crankshaft;
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
#[cfg(all(feature = "decky", not(any(feature = "any"))))]
mod api_decky;
pub mod serdes;
pub mod socket;
pub use remote_call::{RemoteCall, RemoteCallResponse};
/// USDPL core API.
/// This contains functionality used in both the back-end and front-end.
pub mod api {
#[cfg(not(any(feature = "decky", feature = "crankshaft")))]
#[cfg(not(any(feature = "decky")))]
pub use super::api_any::*;
pub use super::api_common::*;
#[cfg(all(feature = "crankshaft", not(any(feature = "decky"))))]
pub use super::api_crankshaft::*;
#[cfg(all(feature = "decky", not(any(feature = "crankshaft"))))]
#[cfg(all(feature = "decky", not(any(feature = "any"))))]
pub use super::api_decky::*;
}

111
usdpl-core/src/remote_call.rs
View file

@ -1,111 +0,0 @@
use std::io::{Read, Write};
use crate::serdes::{DumpError, Dumpable, LoadError, Loadable, Primitive};
/// Remote call packet representing a function to call on the back-end, sent from the front-end
pub struct RemoteCall {
/// The call id assigned by the front-end
pub id: u64,
/// The function's name
pub function: String,
/// The function's input parameters
pub parameters: Vec<Primitive>,
}
impl Loadable for RemoteCall {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let (id_num, len0) = u64::load(buffer)?;
let (function_name, len1) = String::load(buffer)?;
let (params, len2) = Vec::<Primitive>::load(buffer)?;
Ok((
Self {
id: id_num,
function: function_name,
parameters: params,
},
len0 + len1 + len2,
))
}
}
impl Dumpable for RemoteCall {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
let len0 = self.id.dump(buffer)?;
let len1 = self.function.dump(buffer)?;
let len2 = self.parameters.dump(buffer)?;
Ok(len0 + len1 + len2)
}
}
/// Remote call response packet representing the response from a remote call after the back-end has executed it.
pub struct RemoteCallResponse {
/// The call id from the RemoteCall
pub id: u64,
/// The function's result
pub response: Vec<Primitive>,
}
impl Loadable for RemoteCallResponse {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let (id_num, len0) = u64::load(buffer)?;
let (response_var, len1) = Vec::<Primitive>::load(buffer)?;
Ok((
Self {
id: id_num,
response: response_var,
},
len0 + len1,
))
}
}
impl Dumpable for RemoteCallResponse {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
let len0 = self.id.dump(buffer)?;
let len1 = self.response.dump(buffer)?;
Ok(len0 + len1)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn remote_call_idempotence_test() {
let call = RemoteCall{
id: 42,
function: "something very long just in case this causes unexpected issues".into(),
parameters: vec!["param1".into(), 42f64.into()],
};
let mut buffer = String::with_capacity(crate::socket::PACKET_BUFFER_SIZE);
let len = call.dump_base64(&mut buffer).unwrap();
println!("base64 dumped: `{}` (len: {})", buffer, len);
let (loaded_call, loaded_len) = RemoteCall::load_base64(buffer.as_bytes()).unwrap();
assert_eq!(len, loaded_len, "Expected load and dump lengths to match");
assert_eq!(loaded_call.id, call.id, "RemoteCall.id does not match");
assert_eq!(loaded_call.function, call.function, "RemoteCall.function does not match");
if let Primitive::String(loaded) = &loaded_call.parameters[0] {
if let Primitive::String(original) = &call.parameters[0] {
assert_eq!(loaded, original, "RemoteCall.parameters[0] does not match");
} else {
panic!("Original call parameter 0 is not String")
}
} else {
panic!("Loaded call parameter 0 is not String")
}
if let Primitive::F64(loaded) = &loaded_call.parameters[1] {
if let Primitive::F64(original) = &call.parameters[1] {
assert_eq!(loaded, original, "RemoteCall.parameters[1] does not match");
} else {
panic!("Original call parameter 1 is not f64")
}
} else {
panic!("Loaded call parameter 1 is not f64")
}
}
}

166
usdpl-core/src/serdes/dump_impl.rs
View file

@ -1,166 +0,0 @@
use std::io::Write;
use super::{DumpError, Dumpable};
impl Dumpable for String {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
let str_bytes = self.as_bytes();
let len_bytes = (str_bytes.len() as u32).to_le_bytes();
let size1 = buffer.write(&len_bytes).map_err(DumpError::Io)?;
let size2 = buffer.write(&str_bytes).map_err(DumpError::Io)?;
Ok(size1 + size2)
}
}
impl<T: Dumpable> Dumpable for Vec<T> {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
let len_bytes = (self.len() as u32).to_le_bytes();
let mut total = buffer.write(&len_bytes).map_err(DumpError::Io)?;
for obj in self.iter() {
let len = obj.dump(buffer)?;
total += len;
}
Ok(total)
}
}
impl<T0: Dumpable, T1: Dumpable> Dumpable for (T0, T1) {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
Ok(
self.0.dump(buffer)?
+ self.1.dump(buffer)?
)
}
}
impl<T0: Dumpable, T1: Dumpable, T2: Dumpable> Dumpable for (T0, T1, T2) {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
Ok(
self.0.dump(buffer)?
+ self.1.dump(buffer)?
+ self.2.dump(buffer)?
)
}
}
impl<T0: Dumpable, T1: Dumpable, T2: Dumpable, T3: Dumpable> Dumpable for (T0, T1, T2, T3) {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
Ok(
self.0.dump(buffer)?
+ self.1.dump(buffer)?
+ self.2.dump(buffer)?
+ self.3.dump(buffer)?
)
}
}
impl<T0: Dumpable, T1: Dumpable, T2: Dumpable, T3: Dumpable, T4: Dumpable> Dumpable for (T0, T1, T2, T3, T4) {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
Ok(
self.0.dump(buffer)?
+ self.1.dump(buffer)?
+ self.2.dump(buffer)?
+ self.3.dump(buffer)?
+ self.4.dump(buffer)?
)
}
}
impl Dumpable for bool {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
buffer.write(&[*self as u8]).map_err(DumpError::Io)
}
}
impl Dumpable for u8 {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
buffer.write(&[*self]).map_err(DumpError::Io)
}
}
/*impl Dumpable for i8 {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
buffer.write(&self.to_le_bytes()).map_err(DumpError::Io)
}
}*/
macro_rules! int_impl {
($type:ty) => {
impl Dumpable for $type {
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError> {
buffer.write(&self.to_le_bytes()).map_err(DumpError::Io)
}
}
};
}
int_impl! {u16}
int_impl! {u32}
int_impl! {u64}
int_impl! {u128}
int_impl! {i8}
int_impl! {i16}
int_impl! {i32}
int_impl! {i64}
int_impl! {i128}
int_impl! {f32}
int_impl! {f64}
#[cfg(test)]
mod tests {
use super::*;
macro_rules! test_impl {
($fn_name:ident, $data:expr, $expected_len:literal, $expected_dump:expr) => {
#[test]
fn $fn_name() {
let data = $data;
let mut buffer = Vec::with_capacity(128);
let write_len = data.dump(&mut buffer).expect("Dump not ok");
assert_eq!(write_len, $expected_len, "Wrong amount written");
assert_eq!(&buffer[..write_len], $expected_dump);
println!("Dumped {:?}", buffer.as_slice());
}
};
}
test_impl! {string_dump_test, "test".to_string(), 8, &[4, 0, 0, 0, 116, 101, 115, 116]}
test_impl! {
vec_dump_test,
vec![
"".to_string(),
"test1".to_string(),
"test2".to_string()
],
26,
&[3, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 5, 0, 0, 0, 116, 101, 115, 116, 50]
}
test_impl! {tuple2_dump_test, (0u8, 1u8), 2, &[0, 1]}
test_impl! {tuple3_dump_test, (0u8, 1u8, 2u8), 3, &[0, 1, 2]}
test_impl! {tuple4_dump_test, (0u8, 1u8, 2u8, 3u8), 4, &[0, 1, 2, 3]}
test_impl! {tuple5_dump_test, (0u8, 1u8, 2u8, 3u8, 4u8), 5, &[0, 1, 2, 3, 4]}
test_impl! {bool_true_dump_test, true, 1, &[1]}
test_impl! {bool_false_dump_test, false, 1, &[0]}
// testing macro-generated code isn't particularly useful, but do it anyway
test_impl! {u8_dump_test, 42u8, 1, &[42]}
test_impl! {u16_dump_test, 42u16, 2, &[42, 0]}
test_impl! {u32_dump_test, 42u32, 4, &[42, 0, 0, 0]}
test_impl! {u64_dump_test, 42u64, 8, &[42, 0, 0, 0, 0, 0, 0, 0]}
test_impl! {u128_dump_test, 42u128, 16, &[42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
test_impl! {i8_dump_test, 42i8, 1, &[42]}
test_impl! {i16_dump_test, 42i16, 2, &[42, 0]}
test_impl! {i32_dump_test, 42i32, 4, &[42, 0, 0, 0]}
test_impl! {i64_dump_test, 42i64, 8, &[42, 0, 0, 0, 0, 0, 0, 0]}
test_impl! {i128_dump_test, 42i128, 16, &[42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]}
test_impl! {f32_dump_test, 42f32, 4, &[0, 0, 40, 66]}
test_impl! {f64_dump_test, 42f64, 8, &[0, 0, 0, 0, 0, 0, 69, 64]}
}

195
usdpl-core/src/serdes/load_impl.rs
View file

@ -1,195 +0,0 @@
use std::io::Read;
use super::{LoadError, Loadable};
impl Loadable for String {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut u32_bytes: [u8; 4] = [u8::MAX; 4];
buffer.read_exact(&mut u32_bytes).map_err(LoadError::Io)?;
let str_size = u32::from_le_bytes(u32_bytes) as usize;
//let mut str_buf = String::with_capacity(str_size);
let mut str_buf = Vec::with_capacity(str_size);
let mut byte_buf = [u8::MAX; 1];
for _ in 0..str_size {
buffer.read_exact(&mut byte_buf).map_err(LoadError::Io)?;
str_buf.push(byte_buf[0]);
}
//let size2 = buffer.read_to_string(&mut str_buf).map_err(LoadError::Io)?;
Ok((
String::from_utf8(str_buf).map_err(|_| LoadError::InvalidData)?,
str_size + 4,
))
}
}
impl<T: Loadable> Loadable for Vec<T> {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut u32_bytes: [u8; 4] = [u8::MAX; 4];
buffer.read_exact(&mut u32_bytes).map_err(LoadError::Io)?;
let count = u32::from_le_bytes(u32_bytes) as usize;
let mut cursor = 4;
let mut items = Vec::with_capacity(count);
for _ in 0..count {
let (obj, len) = T::load(buffer)?;
cursor += len;
items.push(obj);
}
Ok((items, cursor))
}
}
impl<T0: Loadable, T1: Loadable> Loadable for (T0, T1) {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let (t0, len0) = T0::load(buffer)?;
let (t1, len1) = T1::load(buffer)?;
Ok((
(t0, t1),
len0 + len1
))
}
}
impl<T0: Loadable, T1: Loadable, T2: Loadable> Loadable for (T0, T1, T2) {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let (t0, len0) = T0::load(buffer)?;
let (t1, len1) = T1::load(buffer)?;
let (t2, len2) = T2::load(buffer)?;
Ok((
(t0, t1, t2),
len0 + len1 + len2
))
}
}
impl<T0: Loadable, T1: Loadable, T2: Loadable, T3: Loadable> Loadable for (T0, T1, T2, T3) {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let (t0, len0) = T0::load(buffer)?;
let (t1, len1) = T1::load(buffer)?;
let (t2, len2) = T2::load(buffer)?;
let (t3, len3) = T3::load(buffer)?;
Ok((
(t0, t1, t2, t3),
len0 + len1 + len2 + len3
))
}
}
impl<T0: Loadable, T1: Loadable, T2: Loadable, T3: Loadable, T4: Loadable> Loadable for (T0, T1, T2, T3, T4) {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let (t0, len0) = T0::load(buffer)?;
let (t1, len1) = T1::load(buffer)?;
let (t2, len2) = T2::load(buffer)?;
let (t3, len3) = T3::load(buffer)?;
let (t4, len4) = T4::load(buffer)?;
Ok((
(t0, t1, t2, t3, t4),
len0 + len1 + len2 + len3 + len4
))
}
}
impl Loadable for bool {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut byte = [u8::MAX; 1];
buffer.read_exact(&mut byte).map_err(LoadError::Io)?;
Ok((byte[0] != 0, 1))
}
}
impl Loadable for u8 {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut byte = [u8::MAX; 1];
buffer.read_exact(&mut byte).map_err(LoadError::Io)?;
Ok((byte[0], 1))
}
}
impl Loadable for i8 {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut byte = [u8::MAX; 1];
buffer.read_exact(&mut byte).map_err(LoadError::Io)?;
Ok((i8::from_le_bytes(byte), 1))
}
}
macro_rules! int_impl {
($type:ty, $size:literal) => {
impl Loadable for $type {
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut bytes: [u8; $size] = [u8::MAX; $size];
buffer.read_exact(&mut bytes).map_err(LoadError::Io)?;
let i = <$type>::from_le_bytes(bytes);
Ok((i, $size))
}
}
};
}
int_impl! {u16, 2}
int_impl! {u32, 4}
int_impl! {u64, 8}
int_impl! {u128, 16}
int_impl! {i16, 2}
int_impl! {i32, 4}
int_impl! {i64, 8}
int_impl! {i128, 16}
int_impl! {f32, 4}
int_impl! {f64, 8}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
macro_rules! test_impl {
($fn_name:ident, $data:expr, $type:ty, $expected_len:literal, $expected_load:expr) => {
#[test]
fn $fn_name() {
let buffer_data = $data;
let mut buffer = Vec::with_capacity(buffer_data.len());
buffer.extend_from_slice(&buffer_data);
let (obj, read_len) = <$type>::load(&mut Cursor::new(buffer)).expect("Load not ok");
assert_eq!(read_len, $expected_len, "Wrong amount read");
assert_eq!(obj, $expected_load, "Loaded value not as expected");
println!("Loaded {:?}", obj);
}
};
}
test_impl! {string_load_test, [4u8, 0, 0, 0, 116, 101, 115, 116, 0, 128], String, 8, "test"}
test_impl! {
vec_load_test,
[3u8, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 5, 0, 0, 0, 116, 101, 115, 116, 50],
Vec<String>,
26,
vec![
"".to_string(),
"test1".to_string(),
"test2".to_string()
]
}
test_impl! {tuple2_load_test, [0, 1], (u8, u8), 2, (0, 1)}
test_impl! {bool_true_load_test, [1], bool, 1, true}
test_impl! {bool_false_load_test, [0], bool, 1, false}
// testing macro-generated code isn't particularly useful, but do it anyway
test_impl! {u8_load_test, [42], u8, 1, 42u8}
test_impl! {u16_load_test, [42, 0], u16, 2, 42u16}
test_impl! {u32_load_test, [42, 0, 0, 0], u32, 4, 42u32}
test_impl! {u64_load_test, [42, 0, 0, 0, 0, 0, 0, 0], u64, 8, 42u64}
test_impl! {u128_load_test, [42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], u128, 16, 42u128}
test_impl! {i8_load_test, [42], i8, 1, 42i8}
test_impl! {i16_load_test, [42, 0], i16, 2, 42i16}
test_impl! {i32_load_test, [42, 0, 0, 0], i32, 4, 42i32}
test_impl! {i64_load_test, [42, 0, 0, 0, 0, 0, 0, 0], i64, 8, 42i64}
test_impl! {i128_load_test, [42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], i128, 16, 42i128}
test_impl! {f32_load_test, [0, 0, 40, 66], f32, 4, 42f32}
test_impl! {f64_load_test, [0, 0, 0, 0, 0, 0, 69, 64], f64, 8, 42f64}
}

10
usdpl-core/src/serdes/mod.rs
View file

@ -1,10 +0,0 @@
//! Serialization and deserialization functionality.
//! Little endian is preferred.
mod dump_impl;
mod load_impl;
mod primitive;
mod traits;
pub use primitive::Primitive;
pub use traits::{DumpError, Dumpable, LoadError, Loadable};

162
usdpl-core/src/serdes/primitive.rs
View file

@ -1,162 +0,0 @@
use std::io::{Read, Write};
use super::{DumpError, Dumpable, LoadError, Loadable};
/// Primitive types supported for communication between the USDPL back- and front-end.
/// These are used for sending over the TCP connection.
pub enum Primitive {
/// Null or unsupported object
Empty,
/// String-like
String(String),
/// f32
F32(f32),
/// f64
F64(f64),
/// u32
U32(u32),
/// u64
U64(u64),
/// i32
I32(i32),
/// i64
I64(i64),
/// boolean
Bool(bool),
/// Non-primitive in Json format
Json(String),
}
impl Primitive {
/// Discriminant -- first byte of a dumped primitive
const fn discriminant(&self) -> u8 {
match self {
Self::Empty => 1,
Self::String(_) => 2,
Self::F32(_) => 3,
Self::F64(_) => 4,
Self::U32(_) => 5,
Self::U64(_) => 6,
Self::I32(_) => 7,
Self::I64(_) => 8,
Self::Bool(_) => 9,
Self::Json(_) => 10,
}
}
}
impl Loadable for Primitive {
fn load(buf: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut discriminant_buf = [u8::MAX; 1];
buf.read_exact(&mut discriminant_buf).map_err(LoadError::Io)?;
let mut result: (Self, usize) = match discriminant_buf[0] {
//0 => (None, 0),
1 => (Self::Empty, 0),
2 => String::load(buf).map(|(obj, len)| (Self::String(obj), len))?,
3 => f32::load(buf).map(|(obj, len)| (Self::F32(obj), len))?,
4 => f64::load(buf).map(|(obj, len)| (Self::F64(obj), len))?,
5 => u32::load(buf).map(|(obj, len)| (Self::U32(obj), len))?,
6 => u64::load(buf).map(|(obj, len)| (Self::U64(obj), len))?,
7 => i32::load(buf).map(|(obj, len)| (Self::I32(obj), len))?,
8 => i64::load(buf).map(|(obj, len)| (Self::I64(obj), len))?,
9 => bool::load(buf).map(|(obj, len)| (Self::Bool(obj), len))?,
10 => String::load(buf).map(|(obj, len)| (Self::Json(obj), len))?,
_ => return Err(LoadError::InvalidData),
};
result.1 += 1;
Ok(result)
}
}
impl Dumpable for Primitive {
fn dump(&self, buf: &mut dyn Write) -> Result<usize, DumpError> {
let size1 = buf.write(&[self.discriminant()]).map_err(DumpError::Io)?;
let result = match self {
Self::Empty => Ok(0),
Self::String(s) => s.dump(buf),
Self::F32(x) => x.dump(buf),
Self::F64(x) => x.dump(buf),
Self::U32(x) => x.dump(buf),
Self::U64(x) => x.dump(buf),
Self::I32(x) => x.dump(buf),
Self::I64(x) => x.dump(buf),
Self::Bool(x) => x.dump(buf),
Self::Json(x) => x.dump(buf),
}?;
Ok(size1 + result)
}
}
impl std::convert::Into<Primitive> for &str {
fn into(self) -> Primitive {
Primitive::String(self.to_string())
}
}
impl std::convert::Into<Primitive> for () {
fn into(self) -> Primitive {
Primitive::Empty
}
}
macro_rules! into_impl {
($type:ty, $variant:ident) => {
impl std::convert::Into<Primitive> for $type {
fn into(self) -> Primitive {
Primitive::$variant(self)
}
}
}
}
into_impl! {String, String}
into_impl! {bool, Bool}
into_impl! {u32, U32}
into_impl! {u64, U64}
into_impl! {i32, I32}
into_impl! {i64, I64}
into_impl! {f32, F32}
into_impl! {f64, F64}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Cursor;
#[test]
fn string_idempotence_test() {
let data = "Test";
let primitive = Primitive::String(data.to_string());
let mut buffer = Vec::with_capacity(128);
let write_len = primitive.dump(&mut buffer).expect("Dump not ok");
let (obj, read_len) = Primitive::load(&mut Cursor::new(buffer)).expect("Load not ok");
assert_eq!(
write_len, read_len,
"Amount written and amount read do not match"
);
if let Primitive::String(result) = obj {
assert_eq!(data, result, "Data written and read does not match");
} else {
panic!("Read non-string primitive");
}
}
#[test]
fn empty_idempotence_test() {
let primitive = Primitive::Empty;
let mut buffer = Vec::with_capacity(128);
let write_len = primitive.dump(&mut buffer).expect("Dump not ok");
let (obj, read_len) = Primitive::load(&mut Cursor::new(buffer)).expect("Load not ok");
assert_eq!(
write_len, read_len,
"Amount written and amount read do not match"
);
if let Primitive::Empty = obj {
//assert_eq!(data, result, "Data written and read does not match");
} else {
panic!("Read non-string primitive");
}
}
}

142
usdpl-core/src/serdes/traits.rs
View file

@ -1,142 +0,0 @@
use std::io::{Read, Write, Cursor};
use base64::{decode_config_buf, encode_config_buf, Config};
const B64_CONF: Config = Config::new(base64::CharacterSet::Standard, true);
#[cfg(feature = "encrypt")]
const ASSOCIATED_DATA: &[u8] = b"usdpl-core-data";
#[cfg(feature = "encrypt")]
use aes_gcm_siv::aead::{AeadInPlace, NewAead};
/// Errors from Loadable::load
#[derive(Debug)]
pub enum LoadError {
/// Buffer smaller than expected
TooSmallBuffer,
/// Unexpected/corrupted data encountered
InvalidData,
/// Encrypted data cannot be decrypted
#[cfg(feature = "encrypt")]
DecryptionError,
/// Read error
Io(std::io::Error),
/// Unimplemented
#[cfg(debug_assertions)]
Todo,
}
impl std::fmt::Display for LoadError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::TooSmallBuffer => write!(f, "LoadError: TooSmallBuffer"),
Self::InvalidData => write!(f, "LoadError: InvalidData"),
#[cfg(feature = "encrypt")]
Self::DecryptionError => write!(f, "LoadError: DecryptionError"),
Self::Io(err) => write!(f, "LoadError: Io({})", err),
#[cfg(debug_assertions)]
Self::Todo => write!(f, "LoadError: TODO!"),
}
}
}
/// Load an object from the buffer
pub trait Loadable: Sized {
/// Read the buffer, building the object and returning the amount of bytes read.
/// If anything is wrong with the buffer, Err should be returned.
fn load(buffer: &mut dyn Read) -> Result<(Self, usize), LoadError>;
/// Load data from a base64-encoded buffer
fn load_base64(buffer: &[u8]) -> Result<(Self, usize), LoadError> {
let mut buffer2 = Vec::with_capacity(crate::socket::PACKET_BUFFER_SIZE);
decode_config_buf(buffer, B64_CONF, &mut buffer2)
.map_err(|_| LoadError::InvalidData)?;
let mut cursor = Cursor::new(buffer2);
Self::load(&mut cursor)
}
/// Load data from an encrypted base64-encoded buffer
#[cfg(feature = "encrypt")]
fn load_encrypted(buffer: &[u8], key: &[u8], nonce: &[u8]) -> Result<(Self, usize), LoadError> {
//println!("encrypted buffer: {}", String::from_utf8(buffer.to_vec()).unwrap());
let key = aes_gcm_siv::Key::from_slice(key);
let cipher = aes_gcm_siv::Aes256GcmSiv::new(key);
let nonce = aes_gcm_siv::Nonce::from_slice(nonce);
let mut decoded_buf = Vec::with_capacity(crate::socket::PACKET_BUFFER_SIZE);
base64::decode_config_buf(buffer, B64_CONF, &mut decoded_buf)
.map_err(|_| LoadError::InvalidData)?;
//println!("Decoded buf: {:?}", decoded_buf);
cipher.decrypt_in_place(nonce, ASSOCIATED_DATA, &mut decoded_buf).map_err(|_| LoadError::DecryptionError)?;
//println!("Decrypted buf: {:?}", decoded_buf);
let mut cursor = Cursor::new(decoded_buf);
Self::load(&mut cursor)
}
}
/// Errors from Dumpable::dump
#[derive(Debug)]
pub enum DumpError {
/// Buffer not big enough to dump data into
TooSmallBuffer,
/// Data cannot be dumped
Unsupported,
/// Data cannot be encrypted
#[cfg(feature = "encrypt")]
EncryptionError,
/// Write error
Io(std::io::Error),
/// Unimplemented
#[cfg(debug_assertions)]
Todo,
}
impl std::fmt::Display for DumpError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::TooSmallBuffer => write!(f, "DumpError: TooSmallBuffer"),
Self::Unsupported => write!(f, "DumpError: Unsupported"),
#[cfg(feature = "encrypt")]
Self::EncryptionError => write!(f, "DumpError: EncryptionError"),
Self::Io(err) => write!(f, "DumpError: Io({})", err),
#[cfg(debug_assertions)]
Self::Todo => write!(f, "DumpError: TODO!"),
}
}
}
/// Dump an object into the buffer
pub trait Dumpable {
/// Write the object to the buffer, returning the amount of bytes written.
/// If anything is wrong, false should be returned.
fn dump(&self, buffer: &mut dyn Write) -> Result<usize, DumpError>;
/// Dump data as base64-encoded.
/// Useful for transmitting data as text.
fn dump_base64(&self, buffer: &mut String) -> Result<usize, DumpError> {
let mut buffer2 = Vec::with_capacity(crate::socket::PACKET_BUFFER_SIZE);
let len = self.dump(&mut buffer2)?;
encode_config_buf(&buffer2[..len], B64_CONF, buffer);
Ok(len)
}
/// Dump data as an encrypted base64-encoded buffer
#[cfg(feature = "encrypt")]
fn dump_encrypted(&self, buffer: &mut Vec<u8>, key: &[u8], nonce: &[u8]) -> Result<usize, DumpError> {
let mut buffer2 = Vec::with_capacity(crate::socket::PACKET_BUFFER_SIZE);
let size = self.dump(&mut buffer2)?;
buffer2.truncate(size);
//println!("Buf: {:?}", buffer2);
let key = aes_gcm_siv::Key::from_slice(key);
let cipher = aes_gcm_siv::Aes256GcmSiv::new(key);
let nonce = aes_gcm_siv::Nonce::from_slice(nonce);
cipher.encrypt_in_place(nonce, ASSOCIATED_DATA, &mut buffer2).map_err(|_| DumpError::EncryptionError)?;
//println!("Encrypted slice: {:?}", &buffer2);
let mut base64_buf = String::with_capacity(crate::socket::PACKET_BUFFER_SIZE);
encode_config_buf(buffer2.as_slice(), B64_CONF, &mut base64_buf);
//println!("base64 len: {}", base64_buf.as_bytes().len());
buffer.extend_from_slice(base64_buf.as_bytes());
//let string = String::from_utf8(buffer.as_slice().to_vec()).unwrap();
//println!("Encoded slice: {}", string);
Ok(base64_buf.len())
}
}

166
usdpl-core/src/socket.rs
View file

@ -1,166 +0,0 @@
//! Web messaging
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
use std::io::{Read, Write};
use crate::serdes::{DumpError, Dumpable, LoadError, Loadable};
use crate::{RemoteCall, RemoteCallResponse};
/// Host IP address for web browsers
pub const HOST_STR: &str = "localhost";
/// Host IP address
pub const HOST: Ipv4Addr = Ipv4Addr::new(127, 0, 0, 1);
/// Standard max packet size
pub const PACKET_BUFFER_SIZE: usize = 1024;
/// Encryption nonce size
pub const NONCE_SIZE: usize = 12;
/// Address and port
#[inline]
pub fn socket_addr(port: u16) -> SocketAddr {
SocketAddr::V4(SocketAddrV4::new(HOST, port))
}
/// Accepted Packet types and the data they contain
pub enum Packet {
/// A remote call
Call(RemoteCall),
/// A reponse to a remote call
CallResponse(RemoteCallResponse),
/// Unused
KeepAlive,
/// Invalid
Invalid,
/// General message
Message(String),
/// Response to an unsupported packet
Unsupported,
/// Broken packet type, useful for testing
Bad,
/// Many packets merged into one
Many(Vec<Packet>),
/// Translation data dump
#[cfg(feature = "translate")]
Translations(Vec<(String, Vec<String>)>),
/// Request translations for language
#[cfg(feature = "translate")]
Language(String),
}
impl Packet {
/// Byte representing the packet type -- the first byte of any packet in USDPL
const fn discriminant(&self) -> u8 {
match self {
Self::Call(_) => 1,
Self::CallResponse(_) => 2,
Self::KeepAlive => 3,
Self::Invalid => 4,
Self::Message(_) => 5,
Self::Unsupported => 6,
Self::Bad => 7,
Self::Many(_) => 8,
#[cfg(feature = "translate")]
Self::Translations(_) => 9,
#[cfg(feature = "translate")]
Self::Language(_) => 10,
}
}
}
impl Loadable for Packet {
fn load(buf: &mut dyn Read) -> Result<(Self, usize), LoadError> {
let mut discriminant_buf = [u8::MAX; 1];
buf.read_exact(&mut discriminant_buf).map_err(LoadError::Io)?;
let mut result: (Self, usize) = match discriminant_buf[0] {
//0 => (None, 0),
1 => {
let (obj, len) = RemoteCall::load(buf)?;
(Self::Call(obj), len)
}
2 => {
let (obj, len) = RemoteCallResponse::load(buf)?;
(Self::CallResponse(obj), len)
}
3 => (Self::KeepAlive, 0),
4 => (Self::Invalid, 0),
5 => {
let (obj, len) = String::load(buf)?;
(Self::Message(obj), len)
}
6 => (Self::Unsupported, 0),
7 => return Err(LoadError::InvalidData),
8 => {
let (obj, len) = <_>::load(buf)?;
(Self::Many(obj), len)
},
#[cfg(feature = "translate")]
9 => {
let (obj, len) = <_>::load(buf)?;
(Self::Translations(obj), len)
},
#[cfg(feature = "translate")]
10 => {
let (obj, len) = <_>::load(buf)?;
(Self::Language(obj), len)
},
_ => return Err(LoadError::InvalidData),
};
result.1 += 1;
Ok(result)
}
}
impl Dumpable for Packet {
fn dump(&self, buf: &mut dyn Write) -> Result<usize, DumpError> {
let size1 = buf.write(&[self.discriminant()]).map_err(DumpError::Io)?;
let result = match self {
Self::Call(c) => c.dump(buf),
Self::CallResponse(c) => c.dump(buf),
Self::KeepAlive => Ok(0),
Self::Invalid => Ok(0),
Self::Message(s) => s.dump(buf),
Self::Unsupported => Ok(0),
Self::Bad => return Err(DumpError::Unsupported),
Self::Many(v) => v.dump(buf),
#[cfg(feature = "translate")]
Self::Translations(tr) => tr.dump(buf),
#[cfg(feature = "translate")]
Self::Language(l) => l.dump(buf),
}?;
Ok(size1 + result)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "encrypt")]
#[test]
fn encryption_integration_test() {
let key = hex_literal::hex!("59C4E408F27250B3147E7724511824F1D28ED7BEF43CF7103ACE747F77A2B265");
let nonce = [0u8; NONCE_SIZE];
let packet = Packet::Call(RemoteCall{
id: 42,
function: "test".into(),
parameters: Vec::new(),
});
let mut buffer = Vec::with_capacity(PACKET_BUFFER_SIZE);
let len = packet.dump_encrypted(&mut buffer, &key, &nonce).unwrap();
println!("buffer: {}", String::from_utf8(buffer.as_slice()[..len].to_vec()).unwrap());
let (packet_out, _len) = Packet::load_encrypted(&buffer.as_slice()[..len], &key, &nonce).unwrap();
if let Packet::Call(call_out) = packet_out {
if let Packet::Call(call_in) = packet {
assert_eq!(call_in.id, call_out.id, "Input and output packets do not match");
assert_eq!(call_in.function, call_out.function, "Input and output packets do not match");
assert_eq!(call_in.parameters.len(), call_out.parameters.len(), "Input and output packets do not match");
} else {
panic!("Packet in not a Call");
}
} else {
panic!("Packet out not a Call!");
}
}
}

23
usdpl-front/Cargo.toml
View file

@ -1,27 +1,28 @@
[package]
name = "usdpl-front"
version = "0.10.1"
authors = ["NGnius (Graham) <ngniusness@gmail.com>"]
version = "0.11.0"
authors = ["NGnius <ngniusness@gmail.com>"]
edition = "2021"
license = "GPL-3.0-only"
repository = "https://github.com/NGnius/usdpl-rs"
readme = "README.md"
repository = "https://git.ngni.us/NG-SD-Plugins/usdpl-rs"
readme = "../README.md"
description = "Universal Steam Deck Plugin Library front-end designed for WASM"
[lib]
crate-type = ["cdylib", "rlib"]
[features]
default = ["translate"]
default = []
decky = ["usdpl-core/decky"]
crankshaft = ["usdpl-core/crankshaft"]
debug = ["console_error_panic_hook"]
encrypt = ["usdpl-core/encrypt", "obfstr", "hex"]
translate = ["usdpl-core/translate"]
#encrypt = ["usdpl-core/encrypt", "obfstr", "hex"]
[dependencies]
wasm-bindgen = "0.2"
wasm-bindgen-futures = "0.4"
gloo-net = { version = "0.4", features = ["websocket"] }
futures = "0.3"
futures-channel = "0.3"
# The `console_error_panic_hook` crate provides better debugging of panics by
# logging them with `console.error`. This is great for development, but requires
@ -36,13 +37,17 @@ web-sys = { version = "0.3", features = [
'RequestMode',
'Response',
'Window',
'console',
]}
js-sys = { version = "0.3" }
obfstr = { version = "0.3", optional = true }
hex = { version = "0.4", optional = true }
usdpl-core = { version = "0.10", path = "../usdpl-core" }
nrpc = { version = "0.10", path = "../../nRPC/nrpc", default-features = false}
usdpl-core = { version = "0.11", path = "../usdpl-core" }
prost = "0.11"
log = "0.4"
[dev-dependencies]
wasm-bindgen-test = { version = "0.3.13" }

168
usdpl-front/src/client_handler.rs Normal file
View file

@ -0,0 +1,168 @@
use std::sync::atomic::{AtomicU64, Ordering};
use futures::{SinkExt, StreamExt, future::{select, Either}};
use gloo_net::websocket::{futures::WebSocket, Message};
use nrpc::{ClientHandler, ServiceError, ServiceClientStream, _helpers::async_trait, _helpers::bytes};
use wasm_bindgen_futures::spawn_local;
static LAST_ID: AtomicU64 = AtomicU64::new(0);
/// Websocket client.
/// In most cases, this shouldn't be used directly, but generated code will use this.
pub struct WebSocketHandler {
port: u16,
}
#[inline]
fn ws_is_alive(ws_state: &gloo_net::websocket::State) -> bool {
match ws_state {
gloo_net::websocket::State::Connecting | gloo_net::websocket::State::Open => true,
gloo_net::websocket::State::Closing | gloo_net::websocket::State::Closed => false,
}
}
async fn send_recv_ws<'a>(mut tx: futures_channel::mpsc::Sender<Result<bytes::Bytes, String>>, url: String, mut input: ServiceClientStream<'a, bytes::Bytes>) {
let ws = match WebSocket::open_with_protocol(&url, "usdpl-nrpc").map_err(|e| e.to_string()) {
Ok(x) => x,
Err(e) => {
log::error!("ws open error: {}", e);
tx.send(Err(e.to_string())).await.unwrap_or(());
return;
}
};
log::debug!("ws opened successfully with url `{}`", url);
let (mut input_done, mut output_done) = (false, false);
let mut last_ws_state = ws.state();
log::debug!("ws with url `{}` initial state: {:?}", url, last_ws_state);
let (mut ws_sink, mut ws_stream) = ws.split();
let (mut left, mut right) = (input.next(), ws_stream.next());
while ws_is_alive(&last_ws_state) {
if !input_done && !output_done {
log::debug!("Input and output streams are both alive");
match select(left, right).await {
Either::Left((next, outstanding)) => {
log::debug!("Got message to send over websocket");
if let Some(next) = next {
match next {
Ok(next) => {
if let Err(e) = ws_sink.send(Message::Bytes(next.into())).await {
tx.send(Err(e.to_string())).await.unwrap_or(());
}
},
Err(e) => tx.send(Err(e.to_string())).await.unwrap_or(())
}
} else {
input_done = true;
}
right = outstanding;
left = input.next();
},
Either::Right((response, outstanding)) => {
log::debug!("Received message from websocket");
if let Some(next) = response {
match next {
Ok(Message::Bytes(b)) => tx.send(Ok(b.into())).await.unwrap_or(()),
Ok(_) => tx.send(Err("Message::Text not allowed".into())).await.unwrap_or(()),
Err(e) => tx.send(Err(e.to_string())).await.unwrap_or(()),
}
} else {
output_done = true;
}
left = outstanding;
let ws = ws_stream.reunite(ws_sink).unwrap();
last_ws_state = ws.state();
(ws_sink, ws_stream) = ws.split();
right = ws_stream.next();
}
}
} else if input_done {
log::debug!("Input stream is complete");
if let Some(next) = right.await {
log::debug!("Received message from websocket");
match next {
Ok(Message::Bytes(b)) => tx.send(Ok(b.into())).await.unwrap_or(()),
Ok(_) => tx.send(Err("Message::Text not allowed".into())).await.unwrap_or(()),
Err(e) => tx.send(Err(e.to_string())).await.unwrap_or(()),
}
} else {
output_done = true;
}
//left = outstanding;
let ws = ws_stream.reunite(ws_sink).unwrap();
last_ws_state = ws.state();
(ws_sink, ws_stream) = ws.split();
right = ws_stream.next();
} else {
// output_done is true
log::debug!("Output stream is complete");
if let Some(next) = left.await {
log::debug!("Got message to send over websocket");
match next {
Ok(next) => {
if let Err(e) = ws_sink.send(Message::Bytes(next.into())).await {
tx.send(Err(e.to_string())).await.unwrap_or(());
}
},
Err(e) => tx.send(Err(e.to_string())).await.unwrap_or(())
}
} else {
input_done = true;
}
//right = outstanding;
let ws = ws_stream.reunite(ws_sink).unwrap();
last_ws_state = ws.state();
(ws_sink, ws_stream) = ws.split();
left = input.next();
right = ws_stream.next(); // this should always resolve to None (but compiler is unhappy without this)
}
}
log::debug!("ws with url `{}` has closed", url);
}
#[derive(Debug)]
struct ErrorStr(String);
impl std::fmt::Display for ErrorStr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Error message: {}", self.0)
}
}
impl std::error::Error for ErrorStr {}
const CHANNEL_BOUND: usize = 4;
impl WebSocketHandler {
/// Instantiate the web socket client for connecting on the specified port
pub fn new(port: u16) -> Self {
Self { port }
}
}
#[async_trait::async_trait(?Send)]
impl ClientHandler<'static> for WebSocketHandler {
async fn call<'a: 'static>(
&self,
package: &str,
service: &str,
method: &str,
input: ServiceClientStream<'a, bytes::Bytes>,
) -> Result<ServiceClientStream<'a, bytes::Bytes>, ServiceError> {
let id = LAST_ID.fetch_add(1, Ordering::SeqCst);
let url = format!(
"ws://usdpl-ws-{}.localhost:{}/{}.{}/{}",
id, self.port, package, service, method,
);
log::debug!("doing send/receive on ws url `{}`", url);
let (tx, rx) = futures_channel::mpsc::channel(CHANNEL_BOUND);
spawn_local(send_recv_ws(tx, url, input));
Ok(Box::new(rx.map(|buf_result: Result<bytes::Bytes, String>| buf_result
.map(|buf| bytes::Bytes::from(buf))
.map_err(|e| ServiceError::Method(Box::new(ErrorStr(e)))))))
}
}

104
usdpl-front/src/connection.rs
View file

@ -1,104 +0,0 @@
//use std::net::TcpStream;
//use std::io::{Read, Write};
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;
use wasm_bindgen_futures::JsFuture;
//use web_sys::{WebSocket, MessageEvent, ErrorEvent};
use js_sys::JsString;
use web_sys::{Request, RequestInit, RequestMode, Response};
//use wasm_rs_shared_channel::{Expects, spsc::{Receiver, Sender}};
use usdpl_core::serdes::{Dumpable, Loadable, Primitive};
use usdpl_core::socket;
#[cfg(feature = "encrypt")]
const NONCE: [u8; socket::NONCE_SIZE]= [0u8; socket::NONCE_SIZE];
pub async fn send_recv_packet(
id: u64,
packet: socket::Packet,
port: u16,
#[cfg(feature = "encrypt")]
key: Vec<u8>,
) -> Result<socket::Packet, JsValue> {
let mut opts = RequestInit::new();
opts.method("POST");
opts.mode(RequestMode::Cors);
let url = format!("http://usdpl{}.{}:{}/usdpl/call", id, socket::HOST_STR, port);
#[allow(unused_variables)]
let (buffer, len) = dump_to_buffer(packet, #[cfg(feature = "encrypt")] key.as_slice())?;
let string: String = String::from_utf8_lossy(buffer.as_slice()).into();
#[cfg(feature="debug")]
crate::imports::console_log(&format!("Dumped base64 `{}` len:{}", string, len));
opts.body(Some(&string.into()));
let request = Request::new_with_str_and_init(&url, &opts)?;
//request.headers().set("Accept", "text/base64")?;
//.set("Authorization", "wasm TODO_KEY")?;
let window = web_sys::window().unwrap();
let resp_value = JsFuture::from(window.fetch_with_request(&request)).await?;
let resp: Response = resp_value.dyn_into()?;
let text = JsFuture::from(resp.text()?).await?;
let string: JsString = text.dyn_into()?;
let rust_str = string.as_string().unwrap();
#[cfg(feature="debug")]
crate::imports::console_log(&format!("Received base64 `{}` len:{}", rust_str, rust_str.len()));
#[cfg(not(feature = "encrypt"))]
{Ok(socket::Packet::load_base64(rust_str.as_bytes())
.map_err(super::convert::str_to_js)?
.0)}
#[cfg(feature = "encrypt")]
{Ok(socket::Packet::load_encrypted(rust_str.as_bytes(), key.as_slice(), &NONCE)
.map_err(super::convert::str_to_js)?
.0)}
}
pub async fn send_call(
id: u64,
packet: socket::Packet,
port: u16,
#[cfg(feature = "encrypt")]
key: Vec<u8>,
) -> Result<Vec<Primitive>, JsValue> {
let packet = send_recv_packet(id, packet, port, #[cfg(feature = "encrypt")] key).await?;
match packet
{
socket::Packet::CallResponse(resp) => Ok(resp.response),
_ => {
//imports::console_warn(&format!("USDPL warning: Got non-call-response message from {}", resp.url()));
Err("Expected call response message, got something else".into())
}
}
}
#[cfg(feature = "encrypt")]
fn dump_to_buffer(packet: socket::Packet, key: &[u8]) -> Result<(Vec<u8>, usize), JsValue> {
let mut buffer = Vec::with_capacity(socket::PACKET_BUFFER_SIZE);
//buffer.extend_from_slice(&[0u8; socket::PACKET_BUFFER_SIZE]);
let len = packet
.dump_encrypted(&mut buffer, key, &NONCE)
.map_err(super::convert::str_to_js)?;
Ok((buffer, len))
}
#[cfg(not(feature = "encrypt"))]
fn dump_to_buffer(packet: socket::Packet) -> Result<(Vec<u8>, usize), JsValue> {
let mut buffer = String::with_capacity(socket::PACKET_BUFFER_SIZE);
//buffer.extend_from_slice(&[0u8; socket::PACKET_BUFFER_SIZE]);
let len = packet
.dump_base64(&mut buffer)
.map_err(super::convert::str_to_js)?;
Ok((buffer.as_bytes().to_vec(), len))
}

52
usdpl-front/src/console_logs.rs Normal file
View file

@ -0,0 +1,52 @@
pub(crate) struct BuiltInLogger {
min_level: log::Level,
}
impl BuiltInLogger {
pub const fn new(min: log::Level) -> Self {
Self {
min_level: min,
}
}
}
impl log::Log for BuiltInLogger {
fn enabled(&self, metadata: &log::Metadata) -> bool {
metadata.level() <= self.min_level
}
fn log(&self, record: &log::Record) {
if self.enabled(record.metadata()) {
match record.level() {
log::Level::Error => web_sys::console::error_1(&fmt_msg(record).into()),
log::Level::Warn => web_sys::console::warn_1(&fmt_msg(record).into()),
log::Level::Info => web_sys::console::log_1(&fmt_msg(record).into()),
log::Level::Debug => web_sys::console::debug_1(&fmt_msg(record).into()),
log::Level::Trace => web_sys::console::debug_1(&fmt_msg(record).into()),
}
}
}
fn flush(&self) {}
}
fn fmt_msg(record: &log::Record) -> String {
#[cfg(feature = "debug")]
{ format!("[{}]({}) {}", record.level(), file_line_info(record), record.args()) }
#[cfg(not(feature = "debug"))]
{ format!("[{}]({}) {}", record.level(), module_line_info(record), record.args()) }
}
#[cfg(feature = "debug")]
fn file_line_info(record: &log::Record) -> String {
let filepath = record.file().unwrap_or("<unknown file>");
let line = record.line().map(|l| l.to_string()).unwrap_or_else(|| "line?".to_string());
format!("{}:{}", filepath, line)
}
#[cfg(not(feature = "debug"))]
fn module_line_info(record: &log::Record) -> String {
let target = record.target();
let line = record.line().map(|l| l.to_string()).unwrap_or_else(|| "line?".to_string());
format!("{}:{}", target, line)
}

20
usdpl-front/src/convert.rs
View file

@ -1,10 +1,10 @@
use js_sys::JsString;
use js_sys::JSON::{parse, stringify};
//use js_sys::JsString;
//use js_sys::JSON::{parse, stringify};
use wasm_bindgen::prelude::JsValue;
use usdpl_core::serdes::Primitive;
//use usdpl_core::serdes::Primitive;
pub(crate) fn primitive_to_js(primitive: Primitive) -> JsValue {
/*pub(crate) fn primitive_to_js(primitive: Primitive) -> JsValue {
match primitive {
Primitive::Empty => JsValue::null(),
Primitive::String(s) => JsValue::from_str(&s),
@ -33,8 +33,16 @@ pub(crate) fn js_to_primitive(val: JsValue) -> Primitive {
} else {
Primitive::Empty
}
}
}*/
pub(crate) fn str_to_js<S: std::string::ToString>(s: S) -> JsString {
/*pub(crate) fn str_to_js<S: std::string::ToString>(s: S) -> JsString {
s.to_string().into()
}*/
pub(crate) fn js_to_str(js: JsValue) -> String {
if let Some(s) = js.as_string() {
s
} else {
format!("{:?}", js)
}
}

16
usdpl-front/src/imports.rs
View file

@ -1,16 +0,0 @@
use wasm_bindgen::prelude::*;
#[wasm_bindgen]
extern "C" {
#[cfg(feature = "debug")]
#[wasm_bindgen(js_namespace = console, js_name = log)]
pub fn console_log(s: &str);
#[cfg(feature = "debug")]
#[wasm_bindgen(js_namespace = console, js_name = warn)]
pub fn console_warn(s: &str);
#[cfg(feature = "debug")]
#[wasm_bindgen(js_namespace = console, js_name = error)]
pub fn console_error(s: &str);
}

195
usdpl-front/src/lib.rs
View file

@ -5,29 +5,33 @@
//!
#![warn(missing_docs)]
mod connection;
mod client_handler;
pub use client_handler::WebSocketHandler;
mod console_logs;
mod convert;
mod imports;
pub mod wasm;
use std::sync::atomic::{AtomicU64, Ordering};
#[allow(missing_docs)]
pub mod _helpers {
pub use js_sys;
pub use wasm_bindgen;
pub use wasm_bindgen_futures;
pub use log;
pub use futures;
pub use nrpc;
}
use js_sys::Array;
use wasm_bindgen::prelude::*;
use usdpl_core::{socket::Packet, RemoteCall};
//const REMOTE_CALL_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
//const REMOTE_PORT: std::sync::atomic::AtomicU16 = std::sync::atomic::AtomicU16::new(31337);
#[cfg(feature = "debug")]
const DEFAULT_MIN_LEVEL: log::Level = log::Level::Trace;
#[cfg(not(feature = "debug"))]
const DEFAULT_MIN_LEVEL: log::Level = log::Level::Info;
static mut CTX: UsdplContext = UsdplContext {
port: 31337,
id: AtomicU64::new(0),
#[cfg(feature = "encrypt")]
key: Vec::new(),
};
const DEFAULT_LOGGER: console_logs::BuiltInLogger = console_logs::BuiltInLogger::new(DEFAULT_MIN_LEVEL);
static mut CACHE: Option<std::collections::HashMap<String, JsValue>> = None;
#[cfg(feature = "translate")]
static mut TRANSLATIONS: Option<std::collections::HashMap<String, Vec<String>>> = None;
#[cfg(feature = "encrypt")]
@ -35,49 +39,42 @@ fn encryption_key() -> Vec<u8> {
hex::decode(obfstr::obfstr!(env!("USDPL_ENCRYPTION_KEY"))).unwrap()
}
//#[wasm_bindgen]
#[derive(Debug)]
struct UsdplContext {
port: u16,
id: AtomicU64,
#[cfg(feature = "encrypt")]
key: Vec<u8>,
}
fn get_port() -> u16 {
unsafe { CTX.port }
}
#[cfg(feature = "encrypt")]
fn get_key() -> Vec<u8> {
unsafe { CTX.key.clone() }
}
fn increment_id() -> u64 {
let atomic = unsafe { &CTX.id };
atomic.fetch_add(1, Ordering::SeqCst)
}
static INIT_DONE: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
/// Initialize the front-end library
#[wasm_bindgen]
pub fn init_usdpl(port: u16) {
#[cfg(feature = "console_error_panic_hook")]
console_error_panic_hook::set_once();
//REMOTE_PORT.store(port, std::sync::atomic::Ordering::SeqCst);
unsafe {
CTX = UsdplContext {
port: port,
id: AtomicU64::new(0),
#[cfg(feature = "encrypt")]
key: encryption_key(),
};
}
//#[wasm_bindgen]
pub fn init_usdpl() {
if !INIT_DONE.swap(true, std::sync::atomic::Ordering::SeqCst) {
#[cfg(feature = "console_error_panic_hook")]
console_error_panic_hook::set_once();
unsafe {
CACHE = Some(std::collections::HashMap::new());
log::set_logger(&DEFAULT_LOGGER)
.map_err(|e| web_sys::console::error_1(&format!("Failed to setup USDPL logger: {}", e).into()))
.unwrap_or(());
log::set_max_level(log::LevelFilter::Trace);
log::debug!("init_usdpl() log configured");
unsafe {
CACHE = Some(std::collections::HashMap::new());
}
log::info!("USDPL init succeeded: {}", build_info());
} else {
log::info!("USDPL init was re-attempted");
}
}
fn build_info() -> String {
format!("{} v{} ({}) for {} by {}, more: {}",
env!("CARGO_PKG_NAME"),
env!("CARGO_PKG_VERSION"),
env!("CARGO_PKG_LICENSE"),
target_usdpl(),
env!("CARGO_PKG_AUTHORS"),
env!("CARGO_PKG_REPOSITORY"),
)
}
/// Get the targeted plugin framework, or "any" if unknown
#[wasm_bindgen]
pub fn target_usdpl() -> String {
@ -94,7 +91,11 @@ pub fn version_usdpl() -> String {
#[wasm_bindgen]
pub fn set_value(key: String, value: JsValue) -> JsValue {
unsafe {
CACHE.as_mut().unwrap().insert(key, value).unwrap_or(JsValue::NULL)
CACHE
.as_mut()
.unwrap()
.insert(key, value)
.unwrap_or(JsValue::NULL)
}
}
@ -102,90 +103,12 @@ pub fn set_value(key: String, value: JsValue) -> JsValue {
#[wasm_bindgen]
pub fn get_value(key: String) -> JsValue {
unsafe {
CACHE.as_ref().unwrap().get(&key).map(|x| x.to_owned()).unwrap_or(JsValue::UNDEFINED)
}
}
/// Call a function on the back-end.
/// Returns null (None) if this fails for any reason.
#[wasm_bindgen]
pub async fn call_backend(name: String, parameters: Vec<JsValue>) -> JsValue {
#[cfg(feature = "debug")]
imports::console_log(&format!(
"call_backend({}, [params; {}])",
name,
parameters.len()
));
let next_id = increment_id();
let mut params = Vec::with_capacity(parameters.len());
for val in parameters {
params.push(convert::js_to_primitive(val));
}
let port = get_port();
#[cfg(feature = "debug")]
imports::console_log(&format!("USDPL: Got port {}", port));
let results = connection::send_call(
next_id,
Packet::Call(RemoteCall {
id: next_id,
function: name.clone(),
parameters: params,
}),
port,
#[cfg(feature = "encrypt")]
get_key()
)
.await;
let results = match results {
Ok(x) => x,
#[allow(unused_variables)]
Err(e) => {
#[cfg(feature = "debug")]
imports::console_error(&format!("USDPL: Got error while calling {}: {:?}", name, e));
return JsValue::NULL;
}
};
let results_js = Array::new_with_length(results.len() as _);
let mut i = 0;
for item in results {
results_js.set(i as _, convert::primitive_to_js(item));
i += 1;
}
results_js.into()
}
/// Initialize translation strings for the front-end
#[wasm_bindgen]
pub async fn init_tr(locale: String) {
let next_id = increment_id();
match connection::send_recv_packet(
next_id,
Packet::Language(locale.clone()),
get_port(),
#[cfg(feature = "encrypt")]
get_key()
).await {
Ok(Packet::Translations(translations)) => {
#[cfg(feature = "debug")]
imports::console_log(&format!("USDPL: Got translations for {}", locale));
// convert translations into map
let mut tr_map = std::collections::HashMap::with_capacity(translations.len());
for (key, val) in translations {
tr_map.insert(key, val);
}
unsafe { TRANSLATIONS = Some(tr_map) }
},
Ok(_) => {
#[cfg(feature = "debug")]
imports::console_error(&format!("USDPL: Got wrong packet response for init_tr"));
unsafe { TRANSLATIONS = None }
},
#[allow(unused_variables)]
Err(e) => {
#[cfg(feature = "debug")]
imports::console_error(&format!("USDPL: Got wrong error for init_tr: {:#?}", e));
unsafe { TRANSLATIONS = None }
}
CACHE
.as_ref()
.unwrap()
.get(&key)
.map(|x| x.to_owned())
.unwrap_or(JsValue::UNDEFINED)
}
}

94
usdpl-front/src/wasm/arrays.rs Normal file
View file

@ -0,0 +1,94 @@
use js_sys::Array;
use super::{FromWasmable, IntoWasmable};
macro_rules! numbers_array {
($num_ty: ident) => {
impl FromWasmable<Array> for Vec<$num_ty> {
fn from_wasm(js: Array) -> Self {
let mut result = Vec::with_capacity(js.length() as usize);
js.for_each(&mut |val, _index, _arr| {
// according to MDN, this is guaranteed to be in order so index can be ignored
if let Some(val) = val.as_f64() {
result.push(val as $num_ty);
}
});
result
}
}
impl IntoWasmable<Array> for Vec<$num_ty> {
fn into_wasm(self) -> Array {
let result = Array::new();
for val in self {
result.push(&val.into());
}
result
}
}
};
}
numbers_array! { f64 }
numbers_array! { f32 }
numbers_array! { isize }
numbers_array! { usize }
numbers_array! { i8 }
numbers_array! { i16 }
numbers_array! { i32 }
numbers_array! { i64 }
numbers_array! { i128 }
numbers_array! { u8 }
numbers_array! { u16 }
numbers_array! { u32 }
numbers_array! { u64 }
numbers_array! { u128 }
impl FromWasmable<Array> for Vec<String> {
fn from_wasm(js: Array) -> Self {
let mut result = Vec::with_capacity(js.length() as usize);
js.for_each(&mut |val, _index, _arr| {
// according to MDN, this is guaranteed to be in order so index can be ignored
if let Some(val) = val.as_string() {
result.push(val);
}
});
result
}
}
impl IntoWasmable<Array> for Vec<String> {
fn into_wasm(self) -> Array {
let result = Array::new();
for val in self {
result.push(&val.into());
}
result
}
}
impl FromWasmable<Array> for Vec<bool> {
fn from_wasm(js: Array) -> Self {
let mut result = Vec::with_capacity(js.length() as usize);
js.for_each(&mut |val, _index, _arr| {
// according to MDN, this is guaranteed to be in order so index can be ignored
if let Some(val) = val.as_bool() {
result.push(val);
}
});
result
}
}
impl IntoWasmable<Array> for Vec<bool> {
fn into_wasm(self) -> Array {
let result = Array::new();
for val in self {
result.push(&val.into());
}
result
}
}

74
usdpl-front/src/wasm/js_function_stream.rs Normal file
View file

@ -0,0 +1,74 @@
use core::pin::Pin;
use core::future::Future;
use futures::{Stream, task::{Poll, Context}};
use wasm_bindgen_futures::JsFuture;
use wasm_bindgen::JsValue;
use js_sys::{Function, Promise};
use nrpc::ServiceError;
use super::FromWasmStreamableType;
use crate::convert::js_to_str;
/// futures::Stream wrapper for a JS async function that generates a new T-like value every call
pub struct JsFunctionStream<T: FromWasmStreamableType + Unpin + 'static> {
function: Function,
promise: Option<JsFuture>,
_idc: std::marker::PhantomData<T>,
}
impl <T: FromWasmStreamableType + Unpin + 'static> JsFunctionStream<T> {
/// Construct the function stream wrapper
pub fn from_function(f: Function) -> Self {
Self {
function: f,
promise: None,
_idc: std::marker::PhantomData::default(),
}
}
}
impl <T: FromWasmStreamableType + Unpin + 'static> Stream for JsFunctionStream<T> {
type Item = Result<T, ServiceError>;
fn poll_next(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> {
// this is horrible, I'm sorry
let js_poll = if let Some(mut promise) = self.promise.take() {
let mut pin = Pin::new(&mut promise);
JsFuture::poll(pin.as_mut(), cx)
} else {
let function_result = match self.function.call0(&JsValue::undefined()) {
Ok(x) => x,
Err(e) => return Poll::Ready(Some(Err(ServiceError::Method(s_to_err(format!("JS function call error: {}", js_to_str(e)))))))
};
let js_promise = Promise::from(function_result);
let mut js_future = JsFuture::from(js_promise);
let mut pin = Pin::new(&mut js_future);
let poll = JsFuture::poll(pin.as_mut(), cx);
self.promise = Some(js_future);
poll
};
js_poll.map(|t| match t {
Ok(t) => {
if t.is_null() || t.is_undefined() {
None
} else {
Some(T::from_wasm_streamable(t).map_err(|e| ServiceError::Method(s_to_err(format!("JS type conversion error: {}", e)))))
}
},
Err(e) => Some(Err(ServiceError::Method(s_to_err(format!("JS function promise error: {}", js_to_str(e))))))
})
}
}
fn s_to_err(s: String) -> Box<(dyn std::error::Error + Send + Sync + 'static)> {
s.into()
}
fn _check_service_stream<T: FromWasmStreamableType + Unpin + 'static>(js_stream: JsFunctionStream<T>) {
let _: nrpc::ServiceClientStream<'static, T> = Box::new(js_stream);
}

99
usdpl-front/src/wasm/maps.rs Normal file
View file

@ -0,0 +1,99 @@
use std::collections::HashMap;
use js_sys::Map;
use super::{FromWasmable, IntoWasmable};
macro_rules! numbers_map {
($num_ty: ident) => {
impl FromWasmable<Map> for HashMap<String, $num_ty> {
fn from_wasm(js: Map) -> Self {
let mut result = HashMap::with_capacity(js.size() as usize);
js.for_each(&mut |key, val| {
if let Some(key) = key.as_string() {
if let Some(val) = val.as_f64() {
result.insert(key, val as $num_ty);
}
}
});
result
}
}
impl IntoWasmable<Map> for HashMap<String, $num_ty> {
fn into_wasm(self) -> Map {
let result = Map::new();
for (key, val) in self {
result.set(&key.into(), &val.into());
}
result
}
}
};
}
numbers_map! { f64 }
numbers_map! { f32 }
numbers_map! { isize }
numbers_map! { usize }
numbers_map! { i8 }
numbers_map! { i16 }
numbers_map! { i32 }
numbers_map! { i64 }
numbers_map! { i128 }
numbers_map! { u8 }
numbers_map! { u16 }
numbers_map! { u32 }
numbers_map! { u64 }
numbers_map! { u128 }
impl FromWasmable<Map> for HashMap<String, String> {
fn from_wasm(js: Map) -> Self {
let mut result = HashMap::with_capacity(js.size() as usize);
js.for_each(&mut |key, val| {
if let Some(key) = key.as_string() {
if let Some(val) = val.as_string() {
result.insert(key, val);
}
}
});
result
}
}
impl IntoWasmable<Map> for HashMap<String, String> {
fn into_wasm(self) -> Map {
let result = Map::new();
for (key, val) in self {
result.set(&key.into(), &val.into());
}
result
}
}
impl FromWasmable<Map> for HashMap<String, bool> {
fn from_wasm(js: Map) -> Self {
let mut result = HashMap::with_capacity(js.size() as usize);
js.for_each(&mut |key, val| {
if let Some(key) = key.as_string() {
if let Some(val) = val.as_bool() {
result.insert(key, val);
}
}
});
result
}
}
impl IntoWasmable<Map> for HashMap<String, bool> {
fn into_wasm(self) -> Map {
let result = Map::new();
for (key, val) in self {
result.set(&key.into(), &val.into());
}
result
}
}

11
usdpl-front/src/wasm/mod.rs Normal file
View file

@ -0,0 +1,11 @@
//! WASM <-> Rust interop utilities
mod arrays;
mod js_function_stream;
mod maps;
mod streaming;
mod trivials;
mod wasm_traits;
pub use js_function_stream::JsFunctionStream;
pub use wasm_traits::*;
pub use streaming::*;

192
usdpl-front/src/wasm/streaming.rs Normal file
View file

@ -0,0 +1,192 @@
use wasm_bindgen::JsValue;
/// Convert Rust type to WASM-compatible type involved in nRPC streaming
pub trait IntoWasmStreamableType {
/// Required method
fn into_wasm_streamable(self) -> JsValue;
}
#[derive(Debug)]
/// Conversion error from FromWasmStreamableType
pub enum WasmStreamableConversionError {
/// JSValue underlying type is incorrect
UnexpectedType {
/// Expected Javascript type
expected: JsType,
/// Actual Javascript type
got: JsType,
},
}
impl core::fmt::Display for WasmStreamableConversionError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::UnexpectedType { expected, got } => write!(f, "Unexpected type {}, expected {}", expected, got),
}
}
}
impl std::error::Error for WasmStreamableConversionError {}
/// Approximation of all possible JS types detectable through Wasm
#[allow(missing_docs)]
#[derive(Debug)]
pub enum JsType {
Number,
String,
Bool,
Array,
BigInt,
Function,
Symbol,
Undefined,
Null,
Object,
Unknown,
}
impl core::fmt::Display for JsType {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Number => write!(f, "number"),
Self::String => write!(f, "string"),
Self::Bool => write!(f, "boolean"),
Self::Array => write!(f, "array"),
Self::BigInt => write!(f, "bigint"),
Self::Function => write!(f, "function"),
Self::Symbol => write!(f, "symbol"),
Self::Undefined => write!(f, "undefined"),
Self::Null => write!(f, "null"),
Self::Object => write!(f, "object"),
Self::Unknown => write!(f, "<unknown>"),
}
}
}
impl JsType {
/// Guess the JS type of the parameter.
/// This is not guaranteed to be correct, but is intended to give more information
/// in debug and error messages
pub fn guess(js: &JsValue) -> JsType {
if js.as_f64().is_some() {
Self::Number
} else if js.as_string().is_some() {
Self::String
} else if js.as_bool().is_some() {
Self::Bool
} else if js.is_array() {
Self::Array
} else if js.is_bigint() {
Self::BigInt
} else if js.is_function() {
Self::Function
} else if js.is_symbol() {
Self::Symbol
} else if js.is_undefined() {
Self::Undefined
} else if js.is_null() {
Self::Null
} else if js.is_object() {
Self::Object
} else {
Self::Unknown
}
}
}
/// Convert WASM-compatible type involved in nRPC streaming to Rust-centric type
pub trait FromWasmStreamableType: Sized {
/// Required method
fn from_wasm_streamable(js: JsValue) -> Result<Self, WasmStreamableConversionError>;
}
macro_rules! trivial_convert_number {
($ty: ty) => {
impl FromWasmStreamableType for $ty {
fn from_wasm_streamable(js: JsValue) -> Result<Self, WasmStreamableConversionError> {
if let Some(num) = js.as_f64() {
Ok(num as $ty)
} else {
Err(WasmStreamableConversionError::UnexpectedType {
expected: JsType::Number,
got: JsType::guess(&js),
})
}
}
}
impl IntoWasmStreamableType for $ty {
fn into_wasm_streamable(self) -> JsValue {
self.into()
}
}
};
}
trivial_convert_number! { f64 }
trivial_convert_number! { f32 }
trivial_convert_number! { isize }
trivial_convert_number! { usize }
trivial_convert_number! { i8 }
trivial_convert_number! { i16 }
trivial_convert_number! { i32 }
trivial_convert_number! { i64 }
trivial_convert_number! { i128 }
trivial_convert_number! { u8 }
trivial_convert_number! { u16 }
trivial_convert_number! { u32 }
trivial_convert_number! { u64 }
trivial_convert_number! { u128 }
impl FromWasmStreamableType for String {
fn from_wasm_streamable(js: JsValue) -> Result<Self, WasmStreamableConversionError> {
if let Some(s) = js.as_string() {
Ok(s)
} else {
Err(WasmStreamableConversionError::UnexpectedType {
expected: JsType::String,
got: JsType::guess(&js),
})
}
}
}
impl IntoWasmStreamableType for String {
fn into_wasm_streamable(self) -> JsValue {
self.into()
}
}
impl FromWasmStreamableType for bool {
fn from_wasm_streamable(js: JsValue) -> Result<Self, WasmStreamableConversionError> {
if let Some(b) = js.as_bool() {
Ok(b)
} else {
Err(WasmStreamableConversionError::UnexpectedType {
expected: JsType::Bool,
got: JsType::guess(&js),
})
}
}
}
impl IntoWasmStreamableType for bool {
fn into_wasm_streamable(self) -> JsValue {
self.into()
}
}
impl FromWasmStreamableType for () {
fn from_wasm_streamable(_js: JsValue) -> Result<Self, WasmStreamableConversionError> {
Ok(())
}
}
impl IntoWasmStreamableType for () {
fn into_wasm_streamable(self) -> JsValue {
JsValue::undefined()
}
}

40
usdpl-front/src/wasm/trivials.rs Normal file
View file

@ -0,0 +1,40 @@
use super::{FromWasmable, IntoWasmable};
macro_rules! trivial_convert {
($ty: ty) => {
impl FromWasmable<$ty> for $ty {
fn from_wasm(js: $ty) -> Self {
js
}
}
impl IntoWasmable<$ty> for $ty {
fn into_wasm(self) -> $ty {
self
}
}
};
}
trivial_convert! { f64 }
trivial_convert! { f32 }
trivial_convert! { isize }
trivial_convert! { usize }
trivial_convert! { i8 }
trivial_convert! { i16 }
trivial_convert! { i32 }
trivial_convert! { i64 }
trivial_convert! { i128 }
trivial_convert! { u8 }
trivial_convert! { u16 }
trivial_convert! { u32 }
trivial_convert! { u64 }
trivial_convert! { u128 }
trivial_convert! { bool }
trivial_convert! { String }
trivial_convert! { () }

40
usdpl-front/src/wasm/wasm_traits.rs Normal file
View file

@ -0,0 +1,40 @@
/// A Rust type which supports Into/FromWasmAbi or WasmDescribe
pub trait KnownWasmCompatible {}
/// Convert Rust type to WASM-compatible type
pub trait IntoWasmable<T: KnownWasmCompatible> {
/// Required method
fn into_wasm(self) -> T;
}
/// Convert WASM-compatible type to Rust-centric type
pub trait FromWasmable<T: KnownWasmCompatible> {
/// Required method
fn from_wasm(js: T) -> Self;
}
impl KnownWasmCompatible for f64 {}
impl KnownWasmCompatible for f32 {}
impl KnownWasmCompatible for isize {}
impl KnownWasmCompatible for usize {}
impl KnownWasmCompatible for i8 {}
impl KnownWasmCompatible for i16 {}
impl KnownWasmCompatible for i32 {}
impl KnownWasmCompatible for i64 {}
impl KnownWasmCompatible for i128 {}
impl KnownWasmCompatible for u8 {}
impl KnownWasmCompatible for u16 {}
impl KnownWasmCompatible for u32 {}
impl KnownWasmCompatible for u64 {}
impl KnownWasmCompatible for u128 {}
impl KnownWasmCompatible for bool {}
impl KnownWasmCompatible for String {}
impl KnownWasmCompatible for () {}
impl KnownWasmCompatible for js_sys::Map {}
impl KnownWasmCompatible for js_sys::Array {}