From 95902d9d64ad96c99819e6738ac69900742ae7b1 Mon Sep 17 00:00:00 2001 From: Atul Bhosale Date: Tue, 24 Sep 2019 23:37:16 +0700 Subject: [PATCH] Format code using 'cargo fmt' --- build.rs | 12 +- create_snapshot/src/main.rs | 28 +- distributed-fly/src/kms.rs | 90 +- distributed-fly/src/main.rs | 3 +- distributed-fly/src/release.rs | 538 +-- libfly/build.rs | 106 +- libfly/src/lib.rs | 11 +- src/bin/fly/commands/mod.rs | 18 +- src/bin/fly/errors.rs | 84 +- src/bin/fly/main.rs | 54 +- src/cache_store.rs | 69 +- src/data_store.rs | 44 +- src/disk_fs.rs | 9 +- src/errors.rs | 228 +- src/lib.rs | 8 +- src/msg_generated.rs | 8274 +++++++++++++++++--------------- src/ops/cache.rs | 351 +- src/ops/dns.rs | 909 ++-- src/ops/modules.rs | 2 +- src/postgres_data.rs | 669 ++- src/redis_cache.rs | 1323 ++--- src/redis_cache_notifier.rs | 20 +- src/runtime.rs | 902 ++-- src/runtime_permissions.rs | 26 +- src/settings.rs | 76 +- src/sqlite_cache.rs | 990 ++-- src/sqlite_data.rs | 412 +- src/utils.rs | 328 +- src/v8env.rs | 36 +- 29 files changed, 8032 insertions(+), 7588 deletions(-) diff --git a/build.rs b/build.rs index fbc69ab..5bddaf3 100644 --- a/build.rs +++ b/build.rs @@ -1,6 +1,12 @@ use std::process::Command; fn main() { - let output = Command::new("sh").arg("./scripts/build-version.sh").output().unwrap(); - println!("cargo:rustc-env=BUILD_VERSION={}", String::from_utf8(output.stdout).unwrap()); -} \ No newline at end of file + let output = Command::new("sh") + .arg("./scripts/build-version.sh") + .output() + .unwrap(); + println!( + "cargo:rustc-env=BUILD_VERSION={}", + String::from_utf8(output.stdout).unwrap() + ); +} diff --git a/create_snapshot/src/main.rs b/create_snapshot/src/main.rs index 7fc9753..c742cb5 100644 --- a/create_snapshot/src/main.rs +++ b/create_snapshot/src/main.rs @@ -15,22 +15,22 @@ pub unsafe extern "C" fn c_get_next_stream_id() -> c_uint { } fn main() { - unsafe { js_init() }; + unsafe { js_init() }; - let args: Vec = env::args().collect(); - let filename = args[1].as_str(); - let mut file = File::open(filename).unwrap(); - let mut contents = String::new(); - file.read_to_string(&mut contents).unwrap(); - let cfilename = CString::new(filename).unwrap(); - let ccontents = CString::new(contents).unwrap(); - let snap = unsafe { js_create_snapshot(cfilename.as_ptr(), ccontents.as_ptr()) }; + let args: Vec = env::args().collect(); + let filename = args[1].as_str(); + let mut file = File::open(filename).unwrap(); + let mut contents = String::new(); + file.read_to_string(&mut contents).unwrap(); + let cfilename = CString::new(filename).unwrap(); + let ccontents = CString::new(contents).unwrap(); + let snap = unsafe { js_create_snapshot(cfilename.as_ptr(), ccontents.as_ptr()) }; - let bytes: Vec = - unsafe { slice::from_raw_parts(snap.ptr as *const u8, snap.len as usize) }.to_vec(); + let bytes: Vec = + unsafe { slice::from_raw_parts(snap.ptr as *const u8, snap.len as usize) }.to_vec(); - let out = &args[2]; - let mut outfile = File::create(&Path::new(out.as_str())).unwrap(); + let out = &args[2]; + let mut outfile = File::create(&Path::new(out.as_str())).unwrap(); - outfile.write_all(bytes.as_slice()).unwrap(); + outfile.write_all(bytes.as_slice()).unwrap(); } diff --git a/distributed-fly/src/kms.rs b/distributed-fly/src/kms.rs index 8414d5a..029f946 100644 --- a/distributed-fly/src/kms.rs +++ b/distributed-fly/src/kms.rs @@ -8,67 +8,67 @@ use r2d2_redis::redis; use sha2::{Digest, Sha256}; lazy_static! { - static ref KMS_CLIENT: KmsClient = KmsClient::new(Region::UsEast1); + static ref KMS_CLIENT: KmsClient = KmsClient::new(Region::UsEast1); } static CACHE_PREFIX: &str = "local:kms:"; pub fn decrypt(blob: Vec) -> Result>, rusoto_kms::DecryptError> { - debug!("decrypting value via KMS"); - if let Some(plaintext) = plaintext_cache(&blob) { - debug!("found in cache, aborting decryption"); - return Ok(Some(plaintext)); - } - let req = DecryptRequest { - ciphertext_blob: blob.clone(), - encryption_context: None, - grant_tokens: None, - }; - let res = KMS_CLIENT.decrypt(req).sync()?; - if let Some(plaintext) = res.plaintext { - set_plaintext_cache(&blob, &plaintext); - Ok(Some(plaintext)) - } else { - Ok(None) - } + debug!("decrypting value via KMS"); + if let Some(plaintext) = plaintext_cache(&blob) { + debug!("found in cache, aborting decryption"); + return Ok(Some(plaintext)); + } + let req = DecryptRequest { + ciphertext_blob: blob.clone(), + encryption_context: None, + grant_tokens: None, + }; + let res = KMS_CLIENT.decrypt(req).sync()?; + if let Some(plaintext) = res.plaintext { + set_plaintext_cache(&blob, &plaintext); + Ok(Some(plaintext)) + } else { + Ok(None) + } } fn format_cache_key(blob: &Vec) -> String { - format!("{}{:x}", CACHE_PREFIX, Sha256::digest(blob.as_slice())) + format!("{}{:x}", CACHE_PREFIX, Sha256::digest(blob.as_slice())) } fn set_plaintext_cache(blob: &Vec, plaintext: &Vec) { - if let Ok(conn) = REDIS_POOL.get() { - if let Err(e) = redis::cmd("SET") - .arg(format_cache_key(blob)) - .arg(plaintext.as_slice()) - .query::<()>(&*conn) - { - error!("error setting kms cache key: {}", e); + if let Ok(conn) = REDIS_POOL.get() { + if let Err(e) = redis::cmd("SET") + .arg(format_cache_key(blob)) + .arg(plaintext.as_slice()) + .query::<()>(&*conn) + { + error!("error setting kms cache key: {}", e); + } } - } } fn plaintext_cache(blob: &Vec) -> Option> { - match REDIS_POOL.get() { - Err(e) => { - error!("error getting redis conn for kms: {}", e); - None - } - Ok(conn) => { - match redis::cmd("GET") - .arg(format_cache_key(blob)) - .query::>>(&*conn) - { + match REDIS_POOL.get() { Err(e) => { - error!("error querying redis for kms: {}", e); - None + error!("error getting redis conn for kms: {}", e); + None + } + Ok(conn) => { + match redis::cmd("GET") + .arg(format_cache_key(blob)) + .query::>>(&*conn) + { + Err(e) => { + error!("error querying redis for kms: {}", e); + None + } + Ok(maybe_vec) => match maybe_vec { + Some(vec) => Some(vec), + None => None, + }, + } } - Ok(maybe_vec) => match maybe_vec { - Some(vec) => Some(vec), - None => None, - }, - } } - } } diff --git a/distributed-fly/src/main.rs b/distributed-fly/src/main.rs index 4e52944..93fb195 100644 --- a/distributed-fly/src/main.rs +++ b/distributed-fly/src/main.rs @@ -239,8 +239,7 @@ fn main() { Conn::Tcp(c) => (c.peer_addr(), false), Conn::Tls(c) => (c.get_ref().get_ref().peer_addr(), true), }; - let remote_addr = remote_addr - .unwrap_or_else(|_| "0.0.0.0:0".parse().unwrap()); + let remote_addr = remote_addr.unwrap_or_else(|_| "0.0.0.0:0".parse().unwrap()); service_fn(move |req| { serve_http(tls, req, unsafe { SELECTOR.as_ref().unwrap() }, remote_addr) }) diff --git a/distributed-fly/src/release.rs b/distributed-fly/src/release.rs index 87d4301..6d4d149 100644 --- a/distributed-fly/src/release.rs +++ b/distributed-fly/src/release.rs @@ -17,291 +17,291 @@ use super::REDIS_POOL; use std::thread; lazy_static! { - static ref RELEASES_BY_APP: RwLock> = RwLock::new(HashMap::new()); - static ref APP_BY_HOSTNAME: RwLock> = RwLock::new(HashMap::new()); + static ref RELEASES_BY_APP: RwLock> = RwLock::new(HashMap::new()); + static ref APP_BY_HOSTNAME: RwLock> = RwLock::new(HashMap::new()); } #[derive(Debug, PartialEq, Deserialize, Clone)] pub struct Release { - pub id: i32, - pub app: String, - pub app_id: i32, - pub version: i32, - pub files: Vec, - pub source: String, - pub config: Value, - pub secrets: Value, - pub libs: Option>, + pub id: i32, + pub app: String, + pub app_id: i32, + pub version: i32, + pub files: Vec, + pub source: String, + pub config: Value, + pub secrets: Value, + pub libs: Option>, } impl Release { - pub fn get(host: &str) -> Result, String> { - match find_cached_release(host) { - Some(r) => Ok(Some(r)), - None => { - let conn = match REDIS_POOL.get() { - Ok(c) => c, - Err(e) => return Err(format!("error getting pool connection: {}", e)), - }; - let app_key: String = match redis::cmd("HGET") - .arg("app_hosts") - .arg(host) - .query::>(&*conn) - { - Ok(s) => match s { - Some(s) => s, - None => return Ok(None), - }, - Err(e) => return Err(format!("error getting app host: {}", e)), - }; - if app_key.is_empty() { - return Ok(None); - } - info!("got key! {}", app_key); - { - match APP_BY_HOSTNAME.write() { - Ok(mut w) => { - w.insert(host.to_string(), app_key.clone()); - debug!("inserted {} => {} in app_by_hostname", host, app_key); - } - Err(e) => error!("could not acquire app_by_hostname lock: {}", e), - } - } - match get_by_app_key(&*conn, app_key.as_str())? { - Some(rel) => { - let mut w = match RELEASES_BY_APP.write() { - Ok(w) => w, - Err(e) => { - error!("poisoned RELEASES_BY_APP lock! {}", e); - e.into_inner() - } - }; + pub fn get(host: &str) -> Result, String> { + match find_cached_release(host) { + Some(r) => Ok(Some(r)), + None => { + let conn = match REDIS_POOL.get() { + Ok(c) => c, + Err(e) => return Err(format!("error getting pool connection: {}", e)), + }; + let app_key: String = match redis::cmd("HGET") + .arg("app_hosts") + .arg(host) + .query::>(&*conn) + { + Ok(s) => match s { + Some(s) => s, + None => return Ok(None), + }, + Err(e) => return Err(format!("error getting app host: {}", e)), + }; + if app_key.is_empty() { + return Ok(None); + } + info!("got key! {}", app_key); + { + match APP_BY_HOSTNAME.write() { + Ok(mut w) => { + w.insert(host.to_string(), app_key.clone()); + debug!("inserted {} => {} in app_by_hostname", host, app_key); + } + Err(e) => error!("could not acquire app_by_hostname lock: {}", e), + } + } + match get_by_app_key(&*conn, app_key.as_str())? { + Some(rel) => { + let mut w = match RELEASES_BY_APP.write() { + Ok(w) => w, + Err(e) => { + error!("poisoned RELEASES_BY_APP lock! {}", e); + e.into_inner() + } + }; - w.insert(app_key, rel.clone()); - Ok(Some(rel)) - } - None => Ok(None), + w.insert(app_key, rel.clone()); + Ok(Some(rel)) + } + None => Ok(None), + } + } } - } } - } - pub fn parsed_config(&self) -> Result { - let mut conf: Vec<(Value, Value)> = vec![]; + pub fn parsed_config(&self) -> Result { + let mut conf: Vec<(Value, Value)> = vec![]; - match self.config { - Value::Map(ref map) => { - for tup in map { - conf.push(parse_config_entry(&tup, &self.secrets)); - } - } - _ => warn!("config is not a msgpack map..."), - }; + match self.config { + Value::Map(ref map) => { + for tup in map { + conf.push(parse_config_entry(&tup, &self.secrets)); + } + } + _ => warn!("config is not a msgpack map..."), + }; - serde_json::to_string(&Value::Map(conf)) - } + serde_json::to_string(&Value::Map(conf)) + } } fn get_by_app_key(conn: &redis::Connection, app_key: &str) -> Result, String> { - let buf: Vec = match conn.get(format!("{}:release:latest", app_key)) { - Ok(v) => v, - Err(e) => return Err(format!("{}", e)), - }; - if buf.is_empty() { - // TODO: Maybe this should be an error - return Ok(None); - } - let mut de = Deserializer::new(&buf[..]); - match Deserialize::deserialize(&mut de) { - Ok(rel) => Ok(Some(rel)), - Err(e) => return Err(format!("{}", e)), - } + let buf: Vec = match conn.get(format!("{}:release:latest", app_key)) { + Ok(v) => v, + Err(e) => return Err(format!("{}", e)), + }; + if buf.is_empty() { + // TODO: Maybe this should be an error + return Ok(None); + } + let mut de = Deserializer::new(&buf[..]); + match Deserialize::deserialize(&mut de) { + Ok(rel) => Ok(Some(rel)), + Err(e) => return Err(format!("{}", e)), + } } fn parse_config_entry(entry: &(Value, Value), secrets: &Value) -> (Value, Value) { - if let Value::Map(ref map) = entry.1 { - if map.len() == 1 { - if let Value::String(ref name) = map[0].0 { - if name.as_str() == Some("fromSecret") { - if let Value::String(ref secret_utf8_name) = map[0].1 { - if let Some(secret_name) = secret_utf8_name.as_str() { - if let Some(plaintext) = get_secret(secrets, secret_name) { - (entry.0.clone(), plaintext.into()) - } else { - entry.clone() - } + if let Value::Map(ref map) = entry.1 { + if map.len() == 1 { + if let Value::String(ref name) = map[0].0 { + if name.as_str() == Some("fromSecret") { + if let Value::String(ref secret_utf8_name) = map[0].1 { + if let Some(secret_name) = secret_utf8_name.as_str() { + if let Some(plaintext) = get_secret(secrets, secret_name) { + (entry.0.clone(), plaintext.into()) + } else { + entry.clone() + } + } else { + entry.clone() + } + } else { + entry.clone() + } + } else { + entry.clone() + } } else { - entry.clone() + entry.clone() } - } else { - entry.clone() - } } else { - entry.clone() + let mut new_entry: Vec<(Value, Value)> = Vec::with_capacity(map.len()); + for t in map { + new_entry.push(parse_config_entry(t, secrets)); + } + (entry.0.clone(), Value::Map(new_entry)) } - } else { - entry.clone() - } } else { - let mut new_entry: Vec<(Value, Value)> = Vec::with_capacity(map.len()); - for t in map { - new_entry.push(parse_config_entry(t, secrets)); - } - (entry.0.clone(), Value::Map(new_entry)) + entry.clone() } - } else { - entry.clone() - } } fn get_secret<'a>(secrets: &'a Value, name: &str) -> Option { - match secrets { - Value::Map(s) => { - for (k, v) in s { - if let Value::String(ks) = k { - if let Some(sname) = ks.as_str() { - if sname == name { - if let Value::String(vs) = v { - return match base64::decode(vs.as_bytes()) { - Ok(bytes) => match decrypt(bytes) { - Err(e) => { - error!("error decrypting secret: {}", e); - None - } - Ok(maybe_plain) => match maybe_plain { - None => None, - Some(plain) => match String::from_utf8(plain) { - Ok(s) => Some(s), - Err(e) => { - error!("error decoding decrypted plaintext into string: {}", e); - None + match secrets { + Value::Map(s) => { + for (k, v) in s { + if let Value::String(ks) = k { + if let Some(sname) = ks.as_str() { + if sname == name { + if let Value::String(vs) = v { + return match base64::decode(vs.as_bytes()) { + Ok(bytes) => match decrypt(bytes) { + Err(e) => { + error!("error decrypting secret: {}", e); + None + } + Ok(maybe_plain) => match maybe_plain { + None => None, + Some(plain) => match String::from_utf8(plain) { + Ok(s) => Some(s), + Err(e) => { + error!("error decoding decrypted plaintext into string: {}", e); + None + } + }, + }, + }, + Err(e) => { + error!("error decoding base64: {}", e); + None + } + }; + } } - }, - }, - }, - Err(e) => { - error!("error decoding base64: {}", e); - None - } - }; - } + } + } } - } + None } - } - None + _ => None, } - _ => None, - } } fn find_cached_release(host: &str) -> Option { - match APP_BY_HOSTNAME.read() { - Err(e) => { - error!("error acquiring lock on app key cache: {}", e); - None - } - Ok(guard) => match guard.get(host) { - Some(key) => match RELEASES_BY_APP.read() { + match APP_BY_HOSTNAME.read() { Err(e) => { - error!("error acquiring lock on releases cache: {}", e); - None + error!("error acquiring lock on app key cache: {}", e); + None } - Ok(r) => match r.get(key) { - Some(r) => Some(r.clone()), - None => None, + Ok(guard) => match guard.get(host) { + Some(key) => match RELEASES_BY_APP.read() { + Err(e) => { + error!("error acquiring lock on releases cache: {}", e); + None + } + Ok(r) => match r.get(key) { + Some(r) => Some(r.clone()), + None => None, + }, + }, + None => None, }, - }, - None => None, - }, - } + } } use std::time; fn sleep_a_bit() { - thread::sleep(time::Duration::from_secs(5)); // probably want to do backoff later + thread::sleep(time::Duration::from_secs(5)); // probably want to do backoff later } pub fn start_new_release_check() { - thread::Builder::new() - .name("redis-release-pubsub".to_string()) - .spawn(|| { - let mut last_updated_at = time::SystemTime::now() - .duration_since(time::UNIX_EPOCH) - .unwrap() - .as_secs(); - while !is_interrupting() { - let redis_url = { GLOBAL_SETTINGS.read().unwrap().redis_url.clone() }; - let client = match redis::Client::open(redis_url.as_str()) { - Ok(c) => c, - Err(e) => { - error!("unable to connect to redis for release checking: {}", e); - sleep_a_bit(); - continue; - } - }; - let mut con = match client.get_connection() { - Ok(c) => c, - Err(e) => { - error!( - "unable to get the redis connection for release checking: {}", - e - ); - sleep_a_bit(); - continue; - } - }; - let mut pubsub = con.as_pubsub(); - match pubsub.subscribe("__keyspace@0__:notifications") { - Ok(_) => {} - Err(e) => { - error!("unable to subscribe to redis keyspace notifications: {}", e); - sleep_a_bit(); - continue; - } - }; - info!("subscribed to keyspace notifications"); + thread::Builder::new() + .name("redis-release-pubsub".to_string()) + .spawn(|| { + let mut last_updated_at = time::SystemTime::now() + .duration_since(time::UNIX_EPOCH) + .unwrap() + .as_secs(); + while !is_interrupting() { + let redis_url = { GLOBAL_SETTINGS.read().unwrap().redis_url.clone() }; + let client = match redis::Client::open(redis_url.as_str()) { + Ok(c) => c, + Err(e) => { + error!("unable to connect to redis for release checking: {}", e); + sleep_a_bit(); + continue; + } + }; + let mut con = match client.get_connection() { + Ok(c) => c, + Err(e) => { + error!( + "unable to get the redis connection for release checking: {}", + e + ); + sleep_a_bit(); + continue; + } + }; + let mut pubsub = con.as_pubsub(); + match pubsub.subscribe("__keyspace@0__:notifications") { + Ok(_) => {} + Err(e) => { + error!("unable to subscribe to redis keyspace notifications: {}", e); + sleep_a_bit(); + continue; + } + }; + info!("subscribed to keyspace notifications"); - while !is_interrupting() { - let msg = match pubsub.get_message() { - Ok(m) => m, - Err(e) => { - error!("error getting message from pubsub: {}", e); - sleep_a_bit(); - continue; - } - }; - let payload: String = match msg.get_payload() { - Ok(p) => p, - Err(e) => { - error!("error getting payload from pubsub message: {}", e); - sleep_a_bit(); - continue; - } - }; - info!("channel '{}': {}", msg.get_channel_name(), payload); - let now = time::SystemTime::now() - .duration_since(time::UNIX_EPOCH) - .unwrap() - .as_secs(); - match REDIS_POOL.get() { - Err(e) => error!("could not acquire redis conn: {}", e), - Ok(conn) => match redis::cmd("ZRANGEBYSCORE") - .arg("notifications") - .arg(last_updated_at) - .arg(now) - .query::>(&*conn) - { - Err(e) => error!("error getting notifications range: {}", e), - Ok(notifications) => { - for n in notifications.iter() { - match serde_json::from_str::(n.as_str()) { - Err(e) => error!("could not parse notification: {}", e), - Ok(notif) => { - use self::NotificationAction::*; - if notif.key.starts_with("app:") { - match notif.action { + while !is_interrupting() { + let msg = match pubsub.get_message() { + Ok(m) => m, + Err(e) => { + error!("error getting message from pubsub: {}", e); + sleep_a_bit(); + continue; + } + }; + let payload: String = match msg.get_payload() { + Ok(p) => p, + Err(e) => { + error!("error getting payload from pubsub message: {}", e); + sleep_a_bit(); + continue; + } + }; + info!("channel '{}': {}", msg.get_channel_name(), payload); + let now = time::SystemTime::now() + .duration_since(time::UNIX_EPOCH) + .unwrap() + .as_secs(); + match REDIS_POOL.get() { + Err(e) => error!("could not acquire redis conn: {}", e), + Ok(conn) => match redis::cmd("ZRANGEBYSCORE") + .arg("notifications") + .arg(last_updated_at) + .arg(now) + .query::>(&*conn) + { + Err(e) => error!("error getting notifications range: {}", e), + Ok(notifications) => { + for n in notifications.iter() { + match serde_json::from_str::(n.as_str()) { + Err(e) => error!("could not parse notification: {}", e), + Ok(notif) => { + use self::NotificationAction::*; + if notif.key.starts_with("app:") { + match notif.action { Delete => match RELEASES_BY_APP.write() { Ok(mut guard) => { guard.remove(notif.key.as_str()); @@ -321,18 +321,18 @@ pub fn start_new_release_check() { Err(e) => error!("error getting app by key: {}", e), }, } - } else if notif.key.starts_with("app_hosts") { - use serde_json::Value; - match notif.context { - Value::Array(arr) => { - let hostnames: Vec = arr - .iter() - .map(|v| match v { - Value::String(h) => h.clone(), - _ => unimplemented!(), - }) - .collect(); - match notif.action { + } else if notif.key.starts_with("app_hosts") { + use serde_json::Value; + match notif.context { + Value::Array(arr) => { + let hostnames: Vec = arr + .iter() + .map(|v| match v { + Value::String(h) => h.clone(), + _ => unimplemented!(), + }) + .collect(); + match notif.action { Delete => match APP_BY_HOSTNAME.write() { Ok(mut guard) => { for h in hostnames.iter() { @@ -364,33 +364,33 @@ pub fn start_new_release_check() { } } } - } - _ => unimplemented!(), - } - } - } - } + } + _ => unimplemented!(), + } + } + } + } + } + last_updated_at = now; + } + }, + }; } - last_updated_at = now; - } - }, - }; - } - } - }) - .unwrap(); + } + }) + .unwrap(); } #[derive(Debug, Deserialize)] struct ReleaseNotification { - action: NotificationAction, - key: String, - context: serde_json::Value, + action: NotificationAction, + key: String, + context: serde_json::Value, } #[derive(Debug, Deserialize)] #[serde(rename_all = "lowercase")] enum NotificationAction { - Delete, - Update, + Delete, + Update, } diff --git a/libfly/build.rs b/libfly/build.rs index 99d71b3..47f006f 100644 --- a/libfly/build.rs +++ b/libfly/build.rs @@ -2,64 +2,64 @@ use std::env; use std::path::Path; fn main() { - let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap(); + let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap(); - println!("cargo:rerun-if-changed=binding.cc"); - println!("cargo:rerun-if-changed=src/lib.rs"); - println!("cargo:rerun-if-changed=v8/out.gn/lib/obj"); + println!("cargo:rerun-if-changed=binding.cc"); + println!("cargo:rerun-if-changed=src/lib.rs"); + println!("cargo:rerun-if-changed=v8/out.gn/lib/obj"); - // let config = cbindgen::Config { - // autogen_warning: Some(String::from("// Auto-generated, don't edit!")), - // include_version: true, - // include_guard: Some(String::from("libfly")), - // includes: vec![String::from("runtime.h")], - // export: cbindgen::ExportConfig { - // exclude: vec![String::from("js_runtime")], - // ..Default::default() - // }, - // language: cbindgen::Language::Cxx, - // ..Default::default() - // }; + // let config = cbindgen::Config { + // autogen_warning: Some(String::from("// Auto-generated, don't edit!")), + // include_version: true, + // include_guard: Some(String::from("libfly")), + // includes: vec![String::from("runtime.h")], + // export: cbindgen::ExportConfig { + // exclude: vec![String::from("js_runtime")], + // ..Default::default() + // }, + // language: cbindgen::Language::Cxx, + // ..Default::default() + // }; - // cbindgen::Builder::new() - // .with_crate(crate_dir.clone()) - // .with_documentation(true) - // .with_config(config) - // .generate() - // .expect("Unable to generate bindings") - // .write_to_file("binding.h"); + // cbindgen::Builder::new() + // .with_crate(crate_dir.clone()) + // .with_documentation(true) + // .with_config(config) + // .generate() + // .expect("Unable to generate bindings") + // .write_to_file("binding.h"); - let mut b = cc::Build::new(); - - b.file("binding.cc") - .include(Path::new("v8/include/")) - .cpp(true) - .static_flag(true) - .extra_warnings(false) - .flag("--std=c++11"); + let mut b = cc::Build::new(); - if cfg!(target_env = "musl") { - b.flag("-static-libstdc++") - .cpp_link_stdlib(None) - .static_crt(true); - } - - b.compile("libfly.a"); + b.file("binding.cc") + .include(Path::new("v8/include/")) + .cpp(true) + .static_flag(true) + .extra_warnings(false) + .flag("--std=c++11"); - if cfg!(target_env = "musl") { - println!("cargo:rustc-link-search=native=/usr/lib"); - println!("cargo:rustc-link-lib=static=stdc++"); - } - println!( - "cargo:rustc-link-search=native={}/v8/out.gn/lib/obj", - crate_dir - ); - println!("cargo:rustc-link-lib=static=v8_monolith"); + if cfg!(target_env = "musl") { + b.flag("-static-libstdc++") + .cpp_link_stdlib(None) + .static_crt(true); + } - // if cfg!(any(target_os = "macos", target_os = "freebsd")) { - // println!("cargo:rustc-link-lib=c++"); - // } else { - // println!("cargo:rustc-link-search=native=/usr/lib/x86_64-linux-gnu"); - // println!("cargo:rustc-link-lib=static=c++"); - // } + b.compile("libfly.a"); + + if cfg!(target_env = "musl") { + println!("cargo:rustc-link-search=native=/usr/lib"); + println!("cargo:rustc-link-lib=static=stdc++"); + } + println!( + "cargo:rustc-link-search=native={}/v8/out.gn/lib/obj", + crate_dir + ); + println!("cargo:rustc-link-lib=static=v8_monolith"); + + // if cfg!(any(target_os = "macos", target_os = "freebsd")) { + // println!("cargo:rustc-link-lib=c++"); + // } else { + // println!("cargo:rustc-link-search=native=/usr/lib/x86_64-linux-gnu"); + // println!("cargo:rustc-link-lib=static=c++"); + // } } diff --git a/libfly/src/lib.rs b/libfly/src/lib.rs index 581fb6c..c331c53 100644 --- a/libfly/src/lib.rs +++ b/libfly/src/lib.rs @@ -93,7 +93,11 @@ pub fn version() -> String { type RecvCb = unsafe extern "C" fn(rt: *const js_runtime, buf: fly_buf, data_buf: fly_buf); type PrintCb = unsafe extern "C" fn(rt: *const js_runtime, lvl: i8, msg: *const c_char); -type ResolveCb = unsafe extern "C" fn(rt: *const js_runtime, specifier: *const c_char, referer_identity_hash: i32) -> js_compiled_module; +type ResolveCb = unsafe extern "C" fn( + rt: *const js_runtime, + specifier: *const c_char, + referer_identity_hash: i32, +) -> js_compiled_module; extern "C" { pub fn js_init(); @@ -110,7 +114,10 @@ extern "C" { pub fn js_eval(rt: *const js_runtime, filename: *const c_char, code: *const c_char) -> bool; pub fn js_run_module(rt: *const js_runtime, module_data: js_compiled_module) -> bool; - pub fn js_compile_module(rt: *const js_runtime, module_data: js_module_data) -> js_compile_module_result; + pub fn js_compile_module( + rt: *const js_runtime, + module_data: js_module_data, + ) -> js_compile_module_result; } #[no_mangle] diff --git a/src/bin/fly/commands/mod.rs b/src/bin/fly/commands/mod.rs index a21fb9b..04f5d80 100644 --- a/src/bin/fly/commands/mod.rs +++ b/src/bin/fly/commands/mod.rs @@ -1,19 +1,19 @@ use crate::util::*; pub fn commands() -> Vec { - vec![http::cli(), test::cli(), dns::cli(), eval::cli()] + vec![http::cli(), test::cli(), dns::cli(), eval::cli()] } pub fn command_exec(name: &str) -> Option { - let exec = match name { - "dns" => dns::exec, - "eval" => eval::exec, - "http" => http::exec, - "test" => test::exec, - _ => return None, - }; + let exec = match name { + "dns" => dns::exec, + "eval" => eval::exec, + "http" => http::exec, + "test" => test::exec, + _ => return None, + }; - Some(exec) + Some(exec) } pub mod dns; diff --git a/src/bin/fly/errors.rs b/src/bin/fly/errors.rs index 2cafa05..881a45a 100644 --- a/src/bin/fly/errors.rs +++ b/src/bin/fly/errors.rs @@ -6,76 +6,76 @@ pub type FlyCliResult = Result; #[derive(Debug)] pub struct FlyCliError { - repr: Repr, + repr: Repr, } #[derive(Debug)] enum Repr { - Simple(String), - IoErr(io::Error), - ClapError(clap::Error), + Simple(String), + IoErr(io::Error), + ClapError(clap::Error), } impl fmt::Display for FlyCliError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.repr { - Repr::IoErr(ref err) => err.fmt(f), - Repr::Simple(ref s) => write!(f, "{}", s), - Repr::ClapError(ref err) => err.fmt(f), + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.repr { + Repr::IoErr(ref err) => err.fmt(f), + Repr::Simple(ref s) => write!(f, "{}", s), + Repr::ClapError(ref err) => err.fmt(f), + } } - } } impl std::error::Error for FlyCliError { - fn description(&self) -> &str { - match self.repr { - Repr::IoErr(ref err) => err.description(), - Repr::Simple(ref s) => s.as_str(), - Repr::ClapError(ref err) => err.description(), + fn description(&self) -> &str { + match self.repr { + Repr::IoErr(ref err) => err.description(), + Repr::Simple(ref s) => s.as_str(), + Repr::ClapError(ref err) => err.description(), + } } - } - fn cause(&self) -> Option<&std::error::Error> { - match self.repr { - Repr::IoErr(ref err) => Some(err), - Repr::Simple(_) => None, - Repr::ClapError(ref err) => Some(err), + fn cause(&self) -> Option<&std::error::Error> { + match self.repr { + Repr::IoErr(ref err) => Some(err), + Repr::Simple(_) => None, + Repr::ClapError(ref err) => Some(err), + } } - } } impl From for FlyCliError { - #[inline] - fn from(err: io::Error) -> FlyCliError { - FlyCliError { - repr: Repr::IoErr(err), + #[inline] + fn from(err: io::Error) -> FlyCliError { + FlyCliError { + repr: Repr::IoErr(err), + } } - } } impl From for FlyCliError { - #[inline] - fn from(err: clap::Error) -> FlyCliError { - FlyCliError { - repr: Repr::ClapError(err), + #[inline] + fn from(err: clap::Error) -> FlyCliError { + FlyCliError { + repr: Repr::ClapError(err), + } } - } } impl From<&str> for FlyCliError { - #[inline] - fn from(err: &str) -> FlyCliError { - FlyCliError { - repr: Repr::Simple(err.to_owned()), + #[inline] + fn from(err: &str) -> FlyCliError { + FlyCliError { + repr: Repr::Simple(err.to_owned()), + } } - } } impl From<()> for FlyCliError { - #[inline] - fn from(_: ()) -> FlyCliError { - FlyCliError { - repr: Repr::Simple("Errored with non message error.".to_string()), + #[inline] + fn from(_: ()) -> FlyCliError { + FlyCliError { + repr: Repr::Simple("Errored with non message error.".to_string()), + } } - } } diff --git a/src/bin/fly/main.rs b/src/bin/fly/main.rs index 5e7cb9c..bea7f7a 100644 --- a/src/bin/fly/main.rs +++ b/src/bin/fly/main.rs @@ -10,39 +10,39 @@ use clap::AppSettings; use slog::{Drain, Level}; fn main() -> FlyCliResult<()> { - let logger = build_logger(); - let _guard = slog_scope::set_global_logger(logger); - slog_stdlog::init().unwrap(); + let logger = build_logger(); + let _guard = slog_scope::set_global_logger(logger); + slog_stdlog::init().unwrap(); - let args = cli().get_matches(); - let (cmd, subcommand_args) = args.subcommand(); - let exec_fn = commands::command_exec(cmd).expect("Unknown command"); + let args = cli().get_matches(); + let (cmd, subcommand_args) = args.subcommand(); + let exec_fn = commands::command_exec(cmd).expect("Unknown command"); - exec_fn(subcommand_args.unwrap()) + exec_fn(subcommand_args.unwrap()) } fn cli() -> App { - App::new("fly") - .global_settings(&[ - AppSettings::DeriveDisplayOrder, - AppSettings::DontCollapseArgsInUsage, - AppSettings::ArgRequiredElseHelp, - AppSettings::UnifiedHelpMessage, - ]) - .about("Edge application runtime") - .subcommands(commands::commands()) + App::new("fly") + .global_settings(&[ + AppSettings::DeriveDisplayOrder, + AppSettings::DontCollapseArgsInUsage, + AppSettings::ArgRequiredElseHelp, + AppSettings::UnifiedHelpMessage, + ]) + .about("Edge application runtime") + .subcommands(commands::commands()) } fn build_logger() -> slog::Logger { - fly::logging::build_routing_logger( - slog_term::term_full() - .filter_level(fly::logging::log_level_from_env( - "FLY_LOG_LEVEL", - Level::Warning, - )) - .fuse(), - slog_term::term_full() - .filter_level(fly::logging::log_level_from_env("LOG_LEVEL", Level::Info)) - .fuse(), - ) + fly::logging::build_routing_logger( + slog_term::term_full() + .filter_level(fly::logging::log_level_from_env( + "FLY_LOG_LEVEL", + Level::Warning, + )) + .fuse(), + slog_term::term_full() + .filter_level(fly::logging::log_level_from_env("LOG_LEVEL", Level::Info)) + .fuse(), + ) } diff --git a/src/cache_store.rs b/src/cache_store.rs index b425e6c..11143ea 100644 --- a/src/cache_store.rs +++ b/src/cache_store.rs @@ -7,54 +7,55 @@ pub type CacheStream = Box, Error = CacheError> + Send>; pub type EmptyCacheFuture = Box + Send>; pub trait CacheStore { - fn get(&self, key: String) -> Box, Error = CacheError> + Send>; - - fn set( - &self, - key: String, - data_stream: Box, Error = ()> + Send>, - opts: CacheSetOptions, - ) -> EmptyCacheFuture; - - fn del(&self, key: String) -> EmptyCacheFuture; - fn expire(&self, key: String, ttl: u32) -> EmptyCacheFuture; - fn ttl(&self, key: String) -> Box + Send>; - fn purge_tag(&self, tag: String) -> EmptyCacheFuture; - fn set_tags(&self, key: String, tags: Vec) -> EmptyCacheFuture; - - fn notify( - &self, - op: CacheOperation, - value: String, - ) -> Box + Send>; - fn set_meta(&self, key: String, meta: String) -> EmptyCacheFuture; + fn get(&self, key: String) + -> Box, Error = CacheError> + Send>; + + fn set( + &self, + key: String, + data_stream: Box, Error = ()> + Send>, + opts: CacheSetOptions, + ) -> EmptyCacheFuture; + + fn del(&self, key: String) -> EmptyCacheFuture; + fn expire(&self, key: String, ttl: u32) -> EmptyCacheFuture; + fn ttl(&self, key: String) -> Box + Send>; + fn purge_tag(&self, tag: String) -> EmptyCacheFuture; + fn set_tags(&self, key: String, tags: Vec) -> EmptyCacheFuture; + + fn notify( + &self, + op: CacheOperation, + value: String, + ) -> Box + Send>; + fn set_meta(&self, key: String, meta: String) -> EmptyCacheFuture; } #[derive(Debug)] pub enum CacheError { - Unknown, - NotFound, - Failure(String), - IoErr(io::Error), + Unknown, + NotFound, + Failure(String), + IoErr(io::Error), } #[derive(Debug)] pub struct CacheSetOptions { - pub ttl: Option, - pub tags: Option>, - pub meta: Option, + pub ttl: Option, + pub tags: Option>, + pub meta: Option, } pub struct CacheEntry { - pub meta: Option, - pub stream: CacheStream, + pub meta: Option, + pub stream: CacheStream, } impl From for CacheError { - #[inline] - fn from(err: io::Error) -> CacheError { - CacheError::IoErr(err) - } + #[inline] + fn from(err: io::Error) -> CacheError { + CacheError::IoErr(err) + } } pub type CacheResult = Result; diff --git a/src/data_store.rs b/src/data_store.rs index 02978c1..8ac1217 100644 --- a/src/data_store.rs +++ b/src/data_store.rs @@ -1,32 +1,32 @@ use futures::Future; pub trait DataStore { - fn get( - &self, - coll: String, - key: String, - ) -> Box, Error = DataError> + Send>; - fn del(&self, coll: String, key: String) -> Box + Send>; - fn put( - &self, - coll: String, - key: String, - data: String, - ) -> Box + Send>; - fn incr( - &self, - coll: String, - key: String, - field: String, - amount: i32, - ) -> Box + Send>; - fn drop_coll(&self, coll: String) -> Box + Send>; + fn get( + &self, + coll: String, + key: String, + ) -> Box, Error = DataError> + Send>; + fn del(&self, coll: String, key: String) -> Box + Send>; + fn put( + &self, + coll: String, + key: String, + data: String, + ) -> Box + Send>; + fn incr( + &self, + coll: String, + key: String, + field: String, + amount: i32, + ) -> Box + Send>; + fn drop_coll(&self, coll: String) -> Box + Send>; } #[derive(Debug, PartialEq)] pub enum DataError { - Unknown, - Failure(String), + Unknown, + Failure(String), } pub type DataResult = Result; diff --git a/src/disk_fs.rs b/src/disk_fs.rs index 264963e..6ee926f 100644 --- a/src/disk_fs.rs +++ b/src/disk_fs.rs @@ -59,18 +59,21 @@ impl FsStore for DiskFsStore { if let Err(e) = btxerr.clone().unbounded_send(Err(e.into())) { error!("error sending into channel: {}", e); } - }).for_each(move |chunk| { + }) + .for_each(move |chunk| { if let Err(e) = btx.clone().unbounded_send(Ok(chunk.to_vec())) { error!("error sending into channel: {}", e); } Ok(()) - }).and_then(|_| Ok(())), + }) + .and_then(|_| Ok(())), ); if let Err(_) = tx.send(Ok(Some(Box::new( brx.map_err(|_| { FsError::Failure("error receiving fs chunk".to_string()) - }).and_then(|chunk_res| match chunk_res { + }) + .and_then(|chunk_res| match chunk_res { Ok(c) => Ok(c), Err(e) => Err(e), }), diff --git a/src/errors.rs b/src/errors.rs index ff57864..ce8e5a5 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -9,163 +9,163 @@ pub type FlyResult = Result; #[derive(Debug)] pub struct FlyError { - repr: Repr, + repr: Repr, } #[derive(Debug)] enum Repr { - Simple(ErrorKind, String), - IoErr(io::Error), - UrlErr(url::ParseError), - HyperErr(hyper::Error), + Simple(ErrorKind, String), + IoErr(io::Error), + UrlErr(url::ParseError), + HyperErr(hyper::Error), } pub fn new(kind: ErrorKind, msg: String) -> FlyError { - FlyError { - repr: Repr::Simple(kind, msg), - } + FlyError { + repr: Repr::Simple(kind, msg), + } } impl FlyError { - pub fn kind(&self) -> ErrorKind { - match self.repr { - Repr::Simple(kind, ref _msg) => kind, - Repr::IoErr(ref err) => { - use std::io::ErrorKind::*; - match err.kind() { - NotFound => ErrorKind::NotFound, - PermissionDenied => ErrorKind::PermissionDenied, - ConnectionRefused => ErrorKind::ConnectionRefused, - ConnectionReset => ErrorKind::ConnectionReset, - ConnectionAborted => ErrorKind::ConnectionAborted, - NotConnected => ErrorKind::NotConnected, - AddrInUse => ErrorKind::AddrInUse, - AddrNotAvailable => ErrorKind::AddrNotAvailable, - BrokenPipe => ErrorKind::BrokenPipe, - AlreadyExists => ErrorKind::AlreadyExists, - WouldBlock => ErrorKind::WouldBlock, - InvalidInput => ErrorKind::InvalidInput, - InvalidData => ErrorKind::InvalidData, - TimedOut => ErrorKind::TimedOut, - Interrupted => ErrorKind::Interrupted, - WriteZero => ErrorKind::WriteZero, - Other => ErrorKind::Other, - UnexpectedEof => ErrorKind::UnexpectedEof, - _ => unreachable!(), - } - } - Repr::UrlErr(ref err) => { - use url::ParseError::*; - match err { - EmptyHost => ErrorKind::EmptyHost, - IdnaError => ErrorKind::IdnaError, - InvalidPort => ErrorKind::InvalidPort, - InvalidIpv4Address => ErrorKind::InvalidIpv4Address, - InvalidIpv6Address => ErrorKind::InvalidIpv6Address, - InvalidDomainCharacter => ErrorKind::InvalidDomainCharacter, - RelativeUrlWithoutBase => ErrorKind::RelativeUrlWithoutBase, - RelativeUrlWithCannotBeABaseBase => ErrorKind::RelativeUrlWithCannotBeABaseBase, - SetHostOnCannotBeABaseUrl => ErrorKind::SetHostOnCannotBeABaseUrl, - Overflow => ErrorKind::Overflow, + pub fn kind(&self) -> ErrorKind { + match self.repr { + Repr::Simple(kind, ref _msg) => kind, + Repr::IoErr(ref err) => { + use std::io::ErrorKind::*; + match err.kind() { + NotFound => ErrorKind::NotFound, + PermissionDenied => ErrorKind::PermissionDenied, + ConnectionRefused => ErrorKind::ConnectionRefused, + ConnectionReset => ErrorKind::ConnectionReset, + ConnectionAborted => ErrorKind::ConnectionAborted, + NotConnected => ErrorKind::NotConnected, + AddrInUse => ErrorKind::AddrInUse, + AddrNotAvailable => ErrorKind::AddrNotAvailable, + BrokenPipe => ErrorKind::BrokenPipe, + AlreadyExists => ErrorKind::AlreadyExists, + WouldBlock => ErrorKind::WouldBlock, + InvalidInput => ErrorKind::InvalidInput, + InvalidData => ErrorKind::InvalidData, + TimedOut => ErrorKind::TimedOut, + Interrupted => ErrorKind::Interrupted, + WriteZero => ErrorKind::WriteZero, + Other => ErrorKind::Other, + UnexpectedEof => ErrorKind::UnexpectedEof, + _ => unreachable!(), + } + } + Repr::UrlErr(ref err) => { + use url::ParseError::*; + match err { + EmptyHost => ErrorKind::EmptyHost, + IdnaError => ErrorKind::IdnaError, + InvalidPort => ErrorKind::InvalidPort, + InvalidIpv4Address => ErrorKind::InvalidIpv4Address, + InvalidIpv6Address => ErrorKind::InvalidIpv6Address, + InvalidDomainCharacter => ErrorKind::InvalidDomainCharacter, + RelativeUrlWithoutBase => ErrorKind::RelativeUrlWithoutBase, + RelativeUrlWithCannotBeABaseBase => ErrorKind::RelativeUrlWithCannotBeABaseBase, + SetHostOnCannotBeABaseUrl => ErrorKind::SetHostOnCannotBeABaseUrl, + Overflow => ErrorKind::Overflow, + } + } + Repr::HyperErr(ref err) => { + // For some reason hyper::errors::Kind is private. + if err.is_parse() { + ErrorKind::HttpParse + } else if err.is_user() { + ErrorKind::HttpUser + } else if err.is_canceled() { + ErrorKind::HttpCanceled + } else if err.is_closed() { + ErrorKind::HttpClosed + } else { + ErrorKind::HttpOther + } + } } - } - Repr::HyperErr(ref err) => { - // For some reason hyper::errors::Kind is private. - if err.is_parse() { - ErrorKind::HttpParse - } else if err.is_user() { - ErrorKind::HttpUser - } else if err.is_canceled() { - ErrorKind::HttpCanceled - } else if err.is_closed() { - ErrorKind::HttpClosed - } else { - ErrorKind::HttpOther - } - } } - } } impl fmt::Display for FlyError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.repr { - Repr::IoErr(ref err) => err.fmt(f), - Repr::UrlErr(ref err) => err.fmt(f), - Repr::HyperErr(ref err) => err.fmt(f), - Repr::Simple(_kind, ref s) => write!(f, "{}", s), + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.repr { + Repr::IoErr(ref err) => err.fmt(f), + Repr::UrlErr(ref err) => err.fmt(f), + Repr::HyperErr(ref err) => err.fmt(f), + Repr::Simple(_kind, ref s) => write!(f, "{}", s), + } } - } } impl std::error::Error for FlyError { - fn description(&self) -> &str { - match self.repr { - Repr::IoErr(ref err) => err.description(), - Repr::UrlErr(ref err) => err.description(), - Repr::HyperErr(ref err) => err.description(), - Repr::Simple(_kind, ref s) => s.as_str(), + fn description(&self) -> &str { + match self.repr { + Repr::IoErr(ref err) => err.description(), + Repr::UrlErr(ref err) => err.description(), + Repr::HyperErr(ref err) => err.description(), + Repr::Simple(_kind, ref s) => s.as_str(), + } } - } - fn cause(&self) -> Option<&std::error::Error> { - match self.repr { - Repr::IoErr(ref err) => Some(err), - Repr::UrlErr(ref err) => Some(err), - Repr::HyperErr(ref err) => Some(err), - Repr::Simple(_, _) => None, + fn cause(&self) -> Option<&std::error::Error> { + match self.repr { + Repr::IoErr(ref err) => Some(err), + Repr::UrlErr(ref err) => Some(err), + Repr::HyperErr(ref err) => Some(err), + Repr::Simple(_, _) => None, + } } - } } impl From for FlyError { - #[inline] - fn from(err: io::Error) -> FlyError { - FlyError { - repr: Repr::IoErr(err), + #[inline] + fn from(err: io::Error) -> FlyError { + FlyError { + repr: Repr::IoErr(err), + } } - } } impl From for FlyError { - #[inline] - fn from(err: url::ParseError) -> FlyError { - FlyError { - repr: Repr::UrlErr(err), + #[inline] + fn from(err: url::ParseError) -> FlyError { + FlyError { + repr: Repr::UrlErr(err), + } } - } } impl From for FlyError { - #[inline] - fn from(err: hyper::Error) -> FlyError { - FlyError { - repr: Repr::HyperErr(err), + #[inline] + fn from(err: hyper::Error) -> FlyError { + FlyError { + repr: Repr::HyperErr(err), + } } - } } impl From for FlyError { - #[inline] - fn from(err: String) -> FlyError { - FlyError { - repr: Repr::Simple(ErrorKind::String, err), + #[inline] + fn from(err: String) -> FlyError { + FlyError { + repr: Repr::Simple(ErrorKind::String, err), + } } - } } impl From<()> for FlyError { - #[inline] - fn from(_: ()) -> FlyError { - FlyError { - repr: Repr::Simple( - ErrorKind::String, - "Errored with non message error.".to_string(), - ), + #[inline] + fn from(_: ()) -> FlyError { + FlyError { + repr: Repr::Simple( + ErrorKind::String, + "Errored with non message error.".to_string(), + ), + } } - } } pub fn permission_denied() -> FlyError { - new(ErrorKind::PermissionDenied, "permission denied".to_owned()) + new(ErrorKind::PermissionDenied, "permission denied".to_owned()) } diff --git a/src/lib.rs b/src/lib.rs index 9c481dc..4089817 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -20,23 +20,23 @@ use std::os::raw::c_uint; #[no_mangle] pub unsafe extern "C" fn c_get_next_stream_id() -> c_uint { - get_next_stream_id() + get_next_stream_id() } pub fn get_next_stream_id() -> u32 { - NEXT_EVENT_ID.fetch_add(1, std::sync::atomic::Ordering::SeqCst) as u32 + NEXT_EVENT_ID.fetch_add(1, std::sync::atomic::Ordering::SeqCst) as u32 } pub static BUILD_VERSION: &str = env!("BUILD_VERSION"); -pub mod js; -pub mod v8env; pub mod errors; +pub mod js; pub mod msg; pub mod ops; pub mod runtime; pub mod runtime_permissions; pub mod utils; +pub mod v8env; pub mod acme_store; pub mod cache_store; diff --git a/src/msg_generated.rs b/src/msg_generated.rs index a62d60c..ac760fb 100644 --- a/src/msg_generated.rs +++ b/src/msg_generated.rs @@ -9,49 +9,48 @@ extern crate flatbuffers; #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum DnsRecordType { - A = 0, - AAAA = 1, - ANY = 2, - AXFR = 3, - CAA = 4, - CNAME = 5, - IXFR = 6, - MX = 7, - NS = 8, - NULL = 9, - OPT = 10, - PTR = 11, - SOA = 12, - SRV = 13, - TLSA = 14, - TXT = 15, - + A = 0, + AAAA = 1, + ANY = 2, + AXFR = 3, + CAA = 4, + CNAME = 5, + IXFR = 6, + MX = 7, + NS = 8, + NULL = 9, + OPT = 10, + PTR = 11, + SOA = 12, + SRV = 13, + TLSA = 14, + TXT = 15, } const ENUM_MIN_DNS_RECORD_TYPE: i8 = 0; const ENUM_MAX_DNS_RECORD_TYPE: i8 = 15; impl<'a> flatbuffers::Follow<'a> for DnsRecordType { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for DnsRecordType { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const DnsRecordType; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const DnsRecordType; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const DnsRecordType; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const DnsRecordType; + unsafe { *p } + } } impl flatbuffers::Push for DnsRecordType { @@ -63,101 +62,86 @@ impl flatbuffers::Push for DnsRecordType { } #[allow(non_camel_case_types)] -const ENUM_VALUES_DNS_RECORD_TYPE:[DnsRecordType; 16] = [ - DnsRecordType::A, - DnsRecordType::AAAA, - DnsRecordType::ANY, - DnsRecordType::AXFR, - DnsRecordType::CAA, - DnsRecordType::CNAME, - DnsRecordType::IXFR, - DnsRecordType::MX, - DnsRecordType::NS, - DnsRecordType::NULL, - DnsRecordType::OPT, - DnsRecordType::PTR, - DnsRecordType::SOA, - DnsRecordType::SRV, - DnsRecordType::TLSA, - DnsRecordType::TXT +const ENUM_VALUES_DNS_RECORD_TYPE: [DnsRecordType; 16] = [ + DnsRecordType::A, + DnsRecordType::AAAA, + DnsRecordType::ANY, + DnsRecordType::AXFR, + DnsRecordType::CAA, + DnsRecordType::CNAME, + DnsRecordType::IXFR, + DnsRecordType::MX, + DnsRecordType::NS, + DnsRecordType::NULL, + DnsRecordType::OPT, + DnsRecordType::PTR, + DnsRecordType::SOA, + DnsRecordType::SRV, + DnsRecordType::TLSA, + DnsRecordType::TXT, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_DNS_RECORD_TYPE:[&'static str; 16] = [ - "A", - "AAAA", - "ANY", - "AXFR", - "CAA", - "CNAME", - "IXFR", - "MX", - "NS", - "NULL", - "OPT", - "PTR", - "SOA", - "SRV", - "TLSA", - "TXT" +const ENUM_NAMES_DNS_RECORD_TYPE: [&'static str; 16] = [ + "A", "AAAA", "ANY", "AXFR", "CAA", "CNAME", "IXFR", "MX", "NS", "NULL", "OPT", "PTR", "SOA", + "SRV", "TLSA", "TXT", ]; pub fn enum_name_dns_record_type(e: DnsRecordType) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_DNS_RECORD_TYPE[index] + let index: usize = e as usize; + ENUM_NAMES_DNS_RECORD_TYPE[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum DnsResponseCode { - NoError = 0, - FormErr = 1, - ServFail = 2, - NXDomain = 3, - NotImp = 4, - Refused = 5, - YXDomain = 6, - YXRRSet = 7, - NXRRSet = 8, - NotAuth = 9, - NotZone = 10, - BADVERS = 11, - BADSIG = 12, - BADKEY = 13, - BADTIME = 14, - BADMODE = 15, - BADNAME = 16, - BADALG = 17, - BADTRUNC = 18, - BADCOOKIE = 19, - + NoError = 0, + FormErr = 1, + ServFail = 2, + NXDomain = 3, + NotImp = 4, + Refused = 5, + YXDomain = 6, + YXRRSet = 7, + NXRRSet = 8, + NotAuth = 9, + NotZone = 10, + BADVERS = 11, + BADSIG = 12, + BADKEY = 13, + BADTIME = 14, + BADMODE = 15, + BADNAME = 16, + BADALG = 17, + BADTRUNC = 18, + BADCOOKIE = 19, } const ENUM_MIN_DNS_RESPONSE_CODE: i8 = 0; const ENUM_MAX_DNS_RESPONSE_CODE: i8 = 19; impl<'a> flatbuffers::Follow<'a> for DnsResponseCode { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for DnsResponseCode { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const DnsResponseCode; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const DnsResponseCode; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const DnsResponseCode; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const DnsResponseCode; + unsafe { *p } + } } impl flatbuffers::Push for DnsResponseCode { @@ -169,31 +153,31 @@ impl flatbuffers::Push for DnsResponseCode { } #[allow(non_camel_case_types)] -const ENUM_VALUES_DNS_RESPONSE_CODE:[DnsResponseCode; 20] = [ - DnsResponseCode::NoError, - DnsResponseCode::FormErr, - DnsResponseCode::ServFail, - DnsResponseCode::NXDomain, - DnsResponseCode::NotImp, - DnsResponseCode::Refused, - DnsResponseCode::YXDomain, - DnsResponseCode::YXRRSet, - DnsResponseCode::NXRRSet, - DnsResponseCode::NotAuth, - DnsResponseCode::NotZone, - DnsResponseCode::BADVERS, - DnsResponseCode::BADSIG, - DnsResponseCode::BADKEY, - DnsResponseCode::BADTIME, - DnsResponseCode::BADMODE, - DnsResponseCode::BADNAME, - DnsResponseCode::BADALG, - DnsResponseCode::BADTRUNC, - DnsResponseCode::BADCOOKIE +const ENUM_VALUES_DNS_RESPONSE_CODE: [DnsResponseCode; 20] = [ + DnsResponseCode::NoError, + DnsResponseCode::FormErr, + DnsResponseCode::ServFail, + DnsResponseCode::NXDomain, + DnsResponseCode::NotImp, + DnsResponseCode::Refused, + DnsResponseCode::YXDomain, + DnsResponseCode::YXRRSet, + DnsResponseCode::NXRRSet, + DnsResponseCode::NotAuth, + DnsResponseCode::NotZone, + DnsResponseCode::BADVERS, + DnsResponseCode::BADSIG, + DnsResponseCode::BADKEY, + DnsResponseCode::BADTIME, + DnsResponseCode::BADMODE, + DnsResponseCode::BADNAME, + DnsResponseCode::BADALG, + DnsResponseCode::BADTRUNC, + DnsResponseCode::BADCOOKIE, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_DNS_RESPONSE_CODE:[&'static str; 20] = [ +const ENUM_NAMES_DNS_RESPONSE_CODE: [&'static str; 20] = [ "NoError", "FormErr", "ServFail", @@ -213,49 +197,48 @@ const ENUM_NAMES_DNS_RESPONSE_CODE:[&'static str; 20] = [ "BADNAME", "BADALG", "BADTRUNC", - "BADCOOKIE" + "BADCOOKIE", ]; pub fn enum_name_dns_response_code(e: DnsResponseCode) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_DNS_RESPONSE_CODE[index] + let index: usize = e as usize; + ENUM_NAMES_DNS_RESPONSE_CODE[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum DnsOpCode { - Query = 0, - Status = 1, - Notify = 2, - Update = 3, - + Query = 0, + Status = 1, + Notify = 2, + Update = 3, } const ENUM_MIN_DNS_OP_CODE: i8 = 0; const ENUM_MAX_DNS_OP_CODE: i8 = 3; impl<'a> flatbuffers::Follow<'a> for DnsOpCode { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for DnsOpCode { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const DnsOpCode; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const DnsOpCode; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const DnsOpCode; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const DnsOpCode; + unsafe { *p } + } } impl flatbuffers::Push for DnsOpCode { @@ -267,59 +250,53 @@ impl flatbuffers::Push for DnsOpCode { } #[allow(non_camel_case_types)] -const ENUM_VALUES_DNS_OP_CODE:[DnsOpCode; 4] = [ - DnsOpCode::Query, - DnsOpCode::Status, - DnsOpCode::Notify, - DnsOpCode::Update +const ENUM_VALUES_DNS_OP_CODE: [DnsOpCode; 4] = [ + DnsOpCode::Query, + DnsOpCode::Status, + DnsOpCode::Notify, + DnsOpCode::Update, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_DNS_OP_CODE:[&'static str; 4] = [ - "Query", - "Status", - "Notify", - "Update" -]; +const ENUM_NAMES_DNS_OP_CODE: [&'static str; 4] = ["Query", "Status", "Notify", "Update"]; pub fn enum_name_dns_op_code(e: DnsOpCode) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_DNS_OP_CODE[index] + let index: usize = e as usize; + ENUM_NAMES_DNS_OP_CODE[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum DnsMessageType { - Query = 0, - Response = 1, - + Query = 0, + Response = 1, } const ENUM_MIN_DNS_MESSAGE_TYPE: i8 = 0; const ENUM_MAX_DNS_MESSAGE_TYPE: i8 = 1; impl<'a> flatbuffers::Follow<'a> for DnsMessageType { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for DnsMessageType { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const DnsMessageType; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const DnsMessageType; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const DnsMessageType; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const DnsMessageType; + unsafe { *p } + } } impl flatbuffers::Push for DnsMessageType { @@ -331,58 +308,52 @@ impl flatbuffers::Push for DnsMessageType { } #[allow(non_camel_case_types)] -const ENUM_VALUES_DNS_MESSAGE_TYPE:[DnsMessageType; 2] = [ - DnsMessageType::Query, - DnsMessageType::Response -]; +const ENUM_VALUES_DNS_MESSAGE_TYPE: [DnsMessageType; 2] = + [DnsMessageType::Query, DnsMessageType::Response]; #[allow(non_camel_case_types)] -const ENUM_NAMES_DNS_MESSAGE_TYPE:[&'static str; 2] = [ - "Query", - "Response" -]; +const ENUM_NAMES_DNS_MESSAGE_TYPE: [&'static str; 2] = ["Query", "Response"]; pub fn enum_name_dns_message_type(e: DnsMessageType) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_DNS_MESSAGE_TYPE[index] + let index: usize = e as usize; + ENUM_NAMES_DNS_MESSAGE_TYPE[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum DnsClass { - IN = 0, - CH = 1, - HS = 2, - NONE = 3, - ANY = 4, - + IN = 0, + CH = 1, + HS = 2, + NONE = 3, + ANY = 4, } const ENUM_MIN_DNS_CLASS: i8 = 0; const ENUM_MAX_DNS_CLASS: i8 = 4; impl<'a> flatbuffers::Follow<'a> for DnsClass { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for DnsClass { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const DnsClass; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const DnsClass; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const DnsClass; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const DnsClass; + unsafe { *p } + } } impl flatbuffers::Push for DnsClass { @@ -394,69 +365,62 @@ impl flatbuffers::Push for DnsClass { } #[allow(non_camel_case_types)] -const ENUM_VALUES_DNS_CLASS:[DnsClass; 5] = [ - DnsClass::IN, - DnsClass::CH, - DnsClass::HS, - DnsClass::NONE, - DnsClass::ANY +const ENUM_VALUES_DNS_CLASS: [DnsClass; 5] = [ + DnsClass::IN, + DnsClass::CH, + DnsClass::HS, + DnsClass::NONE, + DnsClass::ANY, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_DNS_CLASS:[&'static str; 5] = [ - "IN", - "CH", - "HS", - "NONE", - "ANY" -]; +const ENUM_NAMES_DNS_CLASS: [&'static str; 5] = ["IN", "CH", "HS", "NONE", "ANY"]; pub fn enum_name_dns_class(e: DnsClass) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_DNS_CLASS[index] + let index: usize = e as usize; + ENUM_NAMES_DNS_CLASS[index] } #[allow(non_camel_case_types)] #[repr(u8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum DnsRecordData { - NONE = 0, - DnsA = 1, - DnsAaaa = 2, - DnsCname = 3, - DnsMx = 4, - DnsNs = 5, - DnsPtr = 6, - DnsSoa = 7, - DnsSrv = 8, - DnsTxt = 9, - + NONE = 0, + DnsA = 1, + DnsAaaa = 2, + DnsCname = 3, + DnsMx = 4, + DnsNs = 5, + DnsPtr = 6, + DnsSoa = 7, + DnsSrv = 8, + DnsTxt = 9, } const ENUM_MIN_DNS_RECORD_DATA: u8 = 0; const ENUM_MAX_DNS_RECORD_DATA: u8 = 9; impl<'a> flatbuffers::Follow<'a> for DnsRecordData { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for DnsRecordData { - #[inline] - fn to_little_endian(self) -> Self { - let n = u8::to_le(self as u8); - let p = &n as *const u8 as *const DnsRecordData; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = u8::from_le(self as u8); - let p = &n as *const u8 as *const DnsRecordData; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = u8::to_le(self as u8); + let p = &n as *const u8 as *const DnsRecordData; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = u8::from_le(self as u8); + let p = &n as *const u8 as *const DnsRecordData; + unsafe { *p } + } } impl flatbuffers::Push for DnsRecordData { @@ -468,36 +432,27 @@ impl flatbuffers::Push for DnsRecordData { } #[allow(non_camel_case_types)] -const ENUM_VALUES_DNS_RECORD_DATA:[DnsRecordData; 10] = [ - DnsRecordData::NONE, - DnsRecordData::DnsA, - DnsRecordData::DnsAaaa, - DnsRecordData::DnsCname, - DnsRecordData::DnsMx, - DnsRecordData::DnsNs, - DnsRecordData::DnsPtr, - DnsRecordData::DnsSoa, - DnsRecordData::DnsSrv, - DnsRecordData::DnsTxt +const ENUM_VALUES_DNS_RECORD_DATA: [DnsRecordData; 10] = [ + DnsRecordData::NONE, + DnsRecordData::DnsA, + DnsRecordData::DnsAaaa, + DnsRecordData::DnsCname, + DnsRecordData::DnsMx, + DnsRecordData::DnsNs, + DnsRecordData::DnsPtr, + DnsRecordData::DnsSoa, + DnsRecordData::DnsSrv, + DnsRecordData::DnsTxt, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_DNS_RECORD_DATA:[&'static str; 10] = [ - "NONE", - "DnsA", - "DnsAaaa", - "DnsCname", - "DnsMx", - "DnsNs", - "DnsPtr", - "DnsSoa", - "DnsSrv", - "DnsTxt" +const ENUM_NAMES_DNS_RECORD_DATA: [&'static str; 10] = [ + "NONE", "DnsA", "DnsAaaa", "DnsCname", "DnsMx", "DnsNs", "DnsPtr", "DnsSoa", "DnsSrv", "DnsTxt", ]; pub fn enum_name_dns_record_data(e: DnsRecordData) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_DNS_RECORD_DATA[index] + let index: usize = e as usize; + ENUM_NAMES_DNS_RECORD_DATA[index] } pub struct DnsRecordDataUnionTableOffset {} @@ -505,35 +460,34 @@ pub struct DnsRecordDataUnionTableOffset {} #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum ImageTransformType { - WebPEncode = 0, - Resize = 1, - + WebPEncode = 0, + Resize = 1, } const ENUM_MIN_IMAGE_TRANSFORM_TYPE: i8 = 0; const ENUM_MAX_IMAGE_TRANSFORM_TYPE: i8 = 1; impl<'a> flatbuffers::Follow<'a> for ImageTransformType { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for ImageTransformType { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const ImageTransformType; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const ImageTransformType; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const ImageTransformType; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const ImageTransformType; + unsafe { *p } + } } impl flatbuffers::Push for ImageTransformType { @@ -545,58 +499,52 @@ impl flatbuffers::Push for ImageTransformType { } #[allow(non_camel_case_types)] -const ENUM_VALUES_IMAGE_TRANSFORM_TYPE:[ImageTransformType; 2] = [ - ImageTransformType::WebPEncode, - ImageTransformType::Resize -]; +const ENUM_VALUES_IMAGE_TRANSFORM_TYPE: [ImageTransformType; 2] = + [ImageTransformType::WebPEncode, ImageTransformType::Resize]; #[allow(non_camel_case_types)] -const ENUM_NAMES_IMAGE_TRANSFORM_TYPE:[&'static str; 2] = [ - "WebPEncode", - "Resize" -]; +const ENUM_NAMES_IMAGE_TRANSFORM_TYPE: [&'static str; 2] = ["WebPEncode", "Resize"]; pub fn enum_name_image_transform_type(e: ImageTransformType) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_IMAGE_TRANSFORM_TYPE[index] + let index: usize = e as usize; + ENUM_NAMES_IMAGE_TRANSFORM_TYPE[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum ImageSamplingFilter { - Nearest = 0, - Triangle = 1, - CatmullRom = 2, - Gaussian = 3, - Lanczos3 = 4, - + Nearest = 0, + Triangle = 1, + CatmullRom = 2, + Gaussian = 3, + Lanczos3 = 4, } const ENUM_MIN_IMAGE_SAMPLING_FILTER: i8 = 0; const ENUM_MAX_IMAGE_SAMPLING_FILTER: i8 = 4; impl<'a> flatbuffers::Follow<'a> for ImageSamplingFilter { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for ImageSamplingFilter { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const ImageSamplingFilter; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const ImageSamplingFilter; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const ImageSamplingFilter; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const ImageSamplingFilter; + unsafe { *p } + } } impl flatbuffers::Push for ImageSamplingFilter { @@ -608,62 +556,56 @@ impl flatbuffers::Push for ImageSamplingFilter { } #[allow(non_camel_case_types)] -const ENUM_VALUES_IMAGE_SAMPLING_FILTER:[ImageSamplingFilter; 5] = [ - ImageSamplingFilter::Nearest, - ImageSamplingFilter::Triangle, - ImageSamplingFilter::CatmullRom, - ImageSamplingFilter::Gaussian, - ImageSamplingFilter::Lanczos3 +const ENUM_VALUES_IMAGE_SAMPLING_FILTER: [ImageSamplingFilter; 5] = [ + ImageSamplingFilter::Nearest, + ImageSamplingFilter::Triangle, + ImageSamplingFilter::CatmullRom, + ImageSamplingFilter::Gaussian, + ImageSamplingFilter::Lanczos3, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_IMAGE_SAMPLING_FILTER:[&'static str; 5] = [ - "Nearest", - "Triangle", - "CatmullRom", - "Gaussian", - "Lanczos3" -]; +const ENUM_NAMES_IMAGE_SAMPLING_FILTER: [&'static str; 5] = + ["Nearest", "Triangle", "CatmullRom", "Gaussian", "Lanczos3"]; pub fn enum_name_image_sampling_filter(e: ImageSamplingFilter) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_IMAGE_SAMPLING_FILTER[index] + let index: usize = e as usize; + ENUM_NAMES_IMAGE_SAMPLING_FILTER[index] } #[allow(non_camel_case_types)] #[repr(u8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum ImageTransformOptions { - NONE = 0, - ImageWebPEncode = 1, - ImageResize = 2, - + NONE = 0, + ImageWebPEncode = 1, + ImageResize = 2, } const ENUM_MIN_IMAGE_TRANSFORM_OPTIONS: u8 = 0; const ENUM_MAX_IMAGE_TRANSFORM_OPTIONS: u8 = 2; impl<'a> flatbuffers::Follow<'a> for ImageTransformOptions { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for ImageTransformOptions { - #[inline] - fn to_little_endian(self) -> Self { - let n = u8::to_le(self as u8); - let p = &n as *const u8 as *const ImageTransformOptions; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = u8::from_le(self as u8); - let p = &n as *const u8 as *const ImageTransformOptions; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = u8::to_le(self as u8); + let p = &n as *const u8 as *const ImageTransformOptions; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = u8::from_le(self as u8); + let p = &n as *const u8 as *const ImageTransformOptions; + unsafe { *p } + } } impl flatbuffers::Push for ImageTransformOptions { @@ -675,22 +617,19 @@ impl flatbuffers::Push for ImageTransformOptions { } #[allow(non_camel_case_types)] -const ENUM_VALUES_IMAGE_TRANSFORM_OPTIONS:[ImageTransformOptions; 3] = [ - ImageTransformOptions::NONE, - ImageTransformOptions::ImageWebPEncode, - ImageTransformOptions::ImageResize +const ENUM_VALUES_IMAGE_TRANSFORM_OPTIONS: [ImageTransformOptions; 3] = [ + ImageTransformOptions::NONE, + ImageTransformOptions::ImageWebPEncode, + ImageTransformOptions::ImageResize, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_IMAGE_TRANSFORM_OPTIONS:[&'static str; 3] = [ - "NONE", - "ImageWebPEncode", - "ImageResize" -]; +const ENUM_NAMES_IMAGE_TRANSFORM_OPTIONS: [&'static str; 3] = + ["NONE", "ImageWebPEncode", "ImageResize"]; pub fn enum_name_image_transform_options(e: ImageTransformOptions) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_IMAGE_TRANSFORM_OPTIONS[index] + let index: usize = e as usize; + ENUM_NAMES_IMAGE_TRANSFORM_OPTIONS[index] } pub struct ImageTransformOptionsUnionTableOffset {} @@ -698,76 +637,75 @@ pub struct ImageTransformOptionsUnionTableOffset {} #[repr(u8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum Any { - NONE = 0, - TimerStart = 1, - TimerReady = 2, - TimerClear = 3, - HttpRequest = 4, - HttpResponse = 5, - StreamChunk = 6, - HttpRequestStart = 7, - FetchHttpResponse = 8, - CacheGet = 9, - CacheGetReady = 10, - CacheSet = 11, - CacheSetReady = 12, - CacheDel = 13, - CacheExpire = 14, - CacheNotifyDel = 15, - CacheNotifyPurgeTag = 16, - CacheSetTags = 17, - CachePurgeTag = 18, - CacheSetMeta = 19, - CryptoDigest = 20, - CryptoDigestReady = 21, - CryptoRandomValues = 22, - CryptoRandomValuesReady = 23, - SourceMap = 24, - SourceMapReady = 25, - DataPut = 26, - DataGet = 27, - DataGetReady = 28, - DataDel = 29, - DataIncr = 30, - DataDropCollection = 31, - DnsQuery = 32, - DnsRequest = 33, - DnsResponse = 34, - AddEventListener = 35, - LoadModule = 36, - LoadModuleResp = 37, - ImageApplyTransforms = 38, - ImageReady = 39, - AcmeGetChallenge = 40, - AcmeGetChallengeReady = 41, - OsExit = 42, - + NONE = 0, + TimerStart = 1, + TimerReady = 2, + TimerClear = 3, + HttpRequest = 4, + HttpResponse = 5, + StreamChunk = 6, + HttpRequestStart = 7, + FetchHttpResponse = 8, + CacheGet = 9, + CacheGetReady = 10, + CacheSet = 11, + CacheSetReady = 12, + CacheDel = 13, + CacheExpire = 14, + CacheNotifyDel = 15, + CacheNotifyPurgeTag = 16, + CacheSetTags = 17, + CachePurgeTag = 18, + CacheSetMeta = 19, + CryptoDigest = 20, + CryptoDigestReady = 21, + CryptoRandomValues = 22, + CryptoRandomValuesReady = 23, + SourceMap = 24, + SourceMapReady = 25, + DataPut = 26, + DataGet = 27, + DataGetReady = 28, + DataDel = 29, + DataIncr = 30, + DataDropCollection = 31, + DnsQuery = 32, + DnsRequest = 33, + DnsResponse = 34, + AddEventListener = 35, + LoadModule = 36, + LoadModuleResp = 37, + ImageApplyTransforms = 38, + ImageReady = 39, + AcmeGetChallenge = 40, + AcmeGetChallengeReady = 41, + OsExit = 42, } const ENUM_MIN_ANY: u8 = 0; const ENUM_MAX_ANY: u8 = 42; impl<'a> flatbuffers::Follow<'a> for Any { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for Any { - #[inline] - fn to_little_endian(self) -> Self { - let n = u8::to_le(self as u8); - let p = &n as *const u8 as *const Any; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = u8::from_le(self as u8); - let p = &n as *const u8 as *const Any; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = u8::to_le(self as u8); + let p = &n as *const u8 as *const Any; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = u8::from_le(self as u8); + let p = &n as *const u8 as *const Any; + unsafe { *p } + } } impl flatbuffers::Push for Any { @@ -779,54 +717,54 @@ impl flatbuffers::Push for Any { } #[allow(non_camel_case_types)] -const ENUM_VALUES_ANY:[Any; 43] = [ - Any::NONE, - Any::TimerStart, - Any::TimerReady, - Any::TimerClear, - Any::HttpRequest, - Any::HttpResponse, - Any::StreamChunk, - Any::HttpRequestStart, - Any::FetchHttpResponse, - Any::CacheGet, - Any::CacheGetReady, - Any::CacheSet, - Any::CacheSetReady, - Any::CacheDel, - Any::CacheExpire, - Any::CacheNotifyDel, - Any::CacheNotifyPurgeTag, - Any::CacheSetTags, - Any::CachePurgeTag, - Any::CacheSetMeta, - Any::CryptoDigest, - Any::CryptoDigestReady, - Any::CryptoRandomValues, - Any::CryptoRandomValuesReady, - Any::SourceMap, - Any::SourceMapReady, - Any::DataPut, - Any::DataGet, - Any::DataGetReady, - Any::DataDel, - Any::DataIncr, - Any::DataDropCollection, - Any::DnsQuery, - Any::DnsRequest, - Any::DnsResponse, - Any::AddEventListener, - Any::LoadModule, - Any::LoadModuleResp, - Any::ImageApplyTransforms, - Any::ImageReady, - Any::AcmeGetChallenge, - Any::AcmeGetChallengeReady, - Any::OsExit +const ENUM_VALUES_ANY: [Any; 43] = [ + Any::NONE, + Any::TimerStart, + Any::TimerReady, + Any::TimerClear, + Any::HttpRequest, + Any::HttpResponse, + Any::StreamChunk, + Any::HttpRequestStart, + Any::FetchHttpResponse, + Any::CacheGet, + Any::CacheGetReady, + Any::CacheSet, + Any::CacheSetReady, + Any::CacheDel, + Any::CacheExpire, + Any::CacheNotifyDel, + Any::CacheNotifyPurgeTag, + Any::CacheSetTags, + Any::CachePurgeTag, + Any::CacheSetMeta, + Any::CryptoDigest, + Any::CryptoDigestReady, + Any::CryptoRandomValues, + Any::CryptoRandomValuesReady, + Any::SourceMap, + Any::SourceMapReady, + Any::DataPut, + Any::DataGet, + Any::DataGetReady, + Any::DataDel, + Any::DataIncr, + Any::DataDropCollection, + Any::DnsQuery, + Any::DnsRequest, + Any::DnsResponse, + Any::AddEventListener, + Any::LoadModule, + Any::LoadModuleResp, + Any::ImageApplyTransforms, + Any::ImageReady, + Any::AcmeGetChallenge, + Any::AcmeGetChallengeReady, + Any::OsExit, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_ANY:[&'static str; 43] = [ +const ENUM_NAMES_ANY: [&'static str; 43] = [ "NONE", "TimerStart", "TimerReady", @@ -869,12 +807,12 @@ const ENUM_NAMES_ANY:[&'static str; 43] = [ "ImageReady", "AcmeGetChallenge", "AcmeGetChallengeReady", - "OsExit" + "OsExit", ]; pub fn enum_name_any(e: Any) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_ANY[index] + let index: usize = e as usize; + ENUM_NAMES_ANY[index] } pub struct AnyUnionTableOffset {} @@ -882,68 +820,67 @@ pub struct AnyUnionTableOffset {} #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum ErrorKind { - NoError = 0, - String = 1, - NotFound = 2, - PermissionDenied = 3, - ConnectionRefused = 4, - ConnectionReset = 5, - ConnectionAborted = 6, - NotConnected = 7, - AddrInUse = 8, - AddrNotAvailable = 9, - BrokenPipe = 10, - AlreadyExists = 11, - WouldBlock = 12, - InvalidInput = 13, - InvalidData = 14, - TimedOut = 15, - Interrupted = 16, - WriteZero = 17, - Other = 18, - UnexpectedEof = 19, - EmptyHost = 20, - IdnaError = 21, - InvalidPort = 22, - InvalidIpv4Address = 23, - InvalidIpv6Address = 24, - InvalidDomainCharacter = 25, - RelativeUrlWithoutBase = 26, - RelativeUrlWithCannotBeABaseBase = 27, - SetHostOnCannotBeABaseUrl = 28, - Overflow = 29, - HttpUser = 30, - HttpClosed = 31, - HttpCanceled = 32, - HttpParse = 33, - HttpOther = 34, - + NoError = 0, + String = 1, + NotFound = 2, + PermissionDenied = 3, + ConnectionRefused = 4, + ConnectionReset = 5, + ConnectionAborted = 6, + NotConnected = 7, + AddrInUse = 8, + AddrNotAvailable = 9, + BrokenPipe = 10, + AlreadyExists = 11, + WouldBlock = 12, + InvalidInput = 13, + InvalidData = 14, + TimedOut = 15, + Interrupted = 16, + WriteZero = 17, + Other = 18, + UnexpectedEof = 19, + EmptyHost = 20, + IdnaError = 21, + InvalidPort = 22, + InvalidIpv4Address = 23, + InvalidIpv6Address = 24, + InvalidDomainCharacter = 25, + RelativeUrlWithoutBase = 26, + RelativeUrlWithCannotBeABaseBase = 27, + SetHostOnCannotBeABaseUrl = 28, + Overflow = 29, + HttpUser = 30, + HttpClosed = 31, + HttpCanceled = 32, + HttpParse = 33, + HttpOther = 34, } const ENUM_MIN_ERROR_KIND: i8 = 0; const ENUM_MAX_ERROR_KIND: i8 = 34; impl<'a> flatbuffers::Follow<'a> for ErrorKind { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for ErrorKind { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const ErrorKind; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const ErrorKind; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const ErrorKind; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const ErrorKind; + unsafe { *p } + } } impl flatbuffers::Push for ErrorKind { @@ -955,46 +892,46 @@ impl flatbuffers::Push for ErrorKind { } #[allow(non_camel_case_types)] -const ENUM_VALUES_ERROR_KIND:[ErrorKind; 35] = [ - ErrorKind::NoError, - ErrorKind::String, - ErrorKind::NotFound, - ErrorKind::PermissionDenied, - ErrorKind::ConnectionRefused, - ErrorKind::ConnectionReset, - ErrorKind::ConnectionAborted, - ErrorKind::NotConnected, - ErrorKind::AddrInUse, - ErrorKind::AddrNotAvailable, - ErrorKind::BrokenPipe, - ErrorKind::AlreadyExists, - ErrorKind::WouldBlock, - ErrorKind::InvalidInput, - ErrorKind::InvalidData, - ErrorKind::TimedOut, - ErrorKind::Interrupted, - ErrorKind::WriteZero, - ErrorKind::Other, - ErrorKind::UnexpectedEof, - ErrorKind::EmptyHost, - ErrorKind::IdnaError, - ErrorKind::InvalidPort, - ErrorKind::InvalidIpv4Address, - ErrorKind::InvalidIpv6Address, - ErrorKind::InvalidDomainCharacter, - ErrorKind::RelativeUrlWithoutBase, - ErrorKind::RelativeUrlWithCannotBeABaseBase, - ErrorKind::SetHostOnCannotBeABaseUrl, - ErrorKind::Overflow, - ErrorKind::HttpUser, - ErrorKind::HttpClosed, - ErrorKind::HttpCanceled, - ErrorKind::HttpParse, - ErrorKind::HttpOther +const ENUM_VALUES_ERROR_KIND: [ErrorKind; 35] = [ + ErrorKind::NoError, + ErrorKind::String, + ErrorKind::NotFound, + ErrorKind::PermissionDenied, + ErrorKind::ConnectionRefused, + ErrorKind::ConnectionReset, + ErrorKind::ConnectionAborted, + ErrorKind::NotConnected, + ErrorKind::AddrInUse, + ErrorKind::AddrNotAvailable, + ErrorKind::BrokenPipe, + ErrorKind::AlreadyExists, + ErrorKind::WouldBlock, + ErrorKind::InvalidInput, + ErrorKind::InvalidData, + ErrorKind::TimedOut, + ErrorKind::Interrupted, + ErrorKind::WriteZero, + ErrorKind::Other, + ErrorKind::UnexpectedEof, + ErrorKind::EmptyHost, + ErrorKind::IdnaError, + ErrorKind::InvalidPort, + ErrorKind::InvalidIpv4Address, + ErrorKind::InvalidIpv6Address, + ErrorKind::InvalidDomainCharacter, + ErrorKind::RelativeUrlWithoutBase, + ErrorKind::RelativeUrlWithCannotBeABaseBase, + ErrorKind::SetHostOnCannotBeABaseUrl, + ErrorKind::Overflow, + ErrorKind::HttpUser, + ErrorKind::HttpClosed, + ErrorKind::HttpCanceled, + ErrorKind::HttpParse, + ErrorKind::HttpOther, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_ERROR_KIND:[&'static str; 35] = [ +const ENUM_NAMES_ERROR_KIND: [&'static str; 35] = [ "NoError", "String", "NotFound", @@ -1029,54 +966,53 @@ const ENUM_NAMES_ERROR_KIND:[&'static str; 35] = [ "HttpClosed", "HttpCanceled", "HttpParse", - "HttpOther" + "HttpOther", ]; pub fn enum_name_error_kind(e: ErrorKind) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_ERROR_KIND[index] + let index: usize = e as usize; + ENUM_NAMES_ERROR_KIND[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum HttpMethod { - Get = 0, - Head = 1, - Post = 2, - Put = 3, - Patch = 4, - Delete = 5, - Connect = 6, - Options = 7, - Trace = 8, - + Get = 0, + Head = 1, + Post = 2, + Put = 3, + Patch = 4, + Delete = 5, + Connect = 6, + Options = 7, + Trace = 8, } const ENUM_MIN_HTTP_METHOD: i8 = 0; const ENUM_MAX_HTTP_METHOD: i8 = 8; impl<'a> flatbuffers::Follow<'a> for HttpMethod { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for HttpMethod { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const HttpMethod; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const HttpMethod; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const HttpMethod; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const HttpMethod; + unsafe { *p } + } } impl flatbuffers::Push for HttpMethod { @@ -1088,69 +1024,60 @@ impl flatbuffers::Push for HttpMethod { } #[allow(non_camel_case_types)] -const ENUM_VALUES_HTTP_METHOD:[HttpMethod; 9] = [ - HttpMethod::Get, - HttpMethod::Head, - HttpMethod::Post, - HttpMethod::Put, - HttpMethod::Patch, - HttpMethod::Delete, - HttpMethod::Connect, - HttpMethod::Options, - HttpMethod::Trace +const ENUM_VALUES_HTTP_METHOD: [HttpMethod; 9] = [ + HttpMethod::Get, + HttpMethod::Head, + HttpMethod::Post, + HttpMethod::Put, + HttpMethod::Patch, + HttpMethod::Delete, + HttpMethod::Connect, + HttpMethod::Options, + HttpMethod::Trace, ]; #[allow(non_camel_case_types)] -const ENUM_NAMES_HTTP_METHOD:[&'static str; 9] = [ - "Get", - "Head", - "Post", - "Put", - "Patch", - "Delete", - "Connect", - "Options", - "Trace" +const ENUM_NAMES_HTTP_METHOD: [&'static str; 9] = [ + "Get", "Head", "Post", "Put", "Patch", "Delete", "Connect", "Options", "Trace", ]; pub fn enum_name_http_method(e: HttpMethod) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_HTTP_METHOD[index] + let index: usize = e as usize; + ENUM_NAMES_HTTP_METHOD[index] } #[allow(non_camel_case_types)] #[repr(i8)] #[derive(Clone, Copy, PartialEq, Debug)] pub enum EventType { - Fetch = 0, - Resolv = 1, - + Fetch = 0, + Resolv = 1, } const ENUM_MIN_EVENT_TYPE: i8 = 0; const ENUM_MAX_EVENT_TYPE: i8 = 1; impl<'a> flatbuffers::Follow<'a> for EventType { - type Inner = Self; - #[inline] - fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { - flatbuffers::read_scalar_at::(buf, loc) - } + type Inner = Self; + #[inline] + fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + flatbuffers::read_scalar_at::(buf, loc) + } } impl flatbuffers::EndianScalar for EventType { - #[inline] - fn to_little_endian(self) -> Self { - let n = i8::to_le(self as i8); - let p = &n as *const i8 as *const EventType; - unsafe { *p } - } - #[inline] - fn from_little_endian(self) -> Self { - let n = i8::from_le(self as i8); - let p = &n as *const i8 as *const EventType; - unsafe { *p } - } + #[inline] + fn to_little_endian(self) -> Self { + let n = i8::to_le(self as i8); + let p = &n as *const i8 as *const EventType; + unsafe { *p } + } + #[inline] + fn from_little_endian(self) -> Self { + let n = i8::from_le(self as i8); + let p = &n as *const i8 as *const EventType; + unsafe { *p } + } } impl flatbuffers::Push for EventType { @@ -1162,27 +1089,21 @@ impl flatbuffers::Push for EventType { } #[allow(non_camel_case_types)] -const ENUM_VALUES_EVENT_TYPE:[EventType; 2] = [ - EventType::Fetch, - EventType::Resolv -]; +const ENUM_VALUES_EVENT_TYPE: [EventType; 2] = [EventType::Fetch, EventType::Resolv]; #[allow(non_camel_case_types)] -const ENUM_NAMES_EVENT_TYPE:[&'static str; 2] = [ - "Fetch", - "Resolv" -]; +const ENUM_NAMES_EVENT_TYPE: [&'static str; 2] = ["Fetch", "Resolv"]; pub fn enum_name_event_type(e: EventType) -> &'static str { - let index: usize = e as usize; - ENUM_NAMES_EVENT_TYPE[index] + let index: usize = e as usize; + ENUM_NAMES_EVENT_TYPE[index] } pub enum DnsAOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsA<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsA<'a> { @@ -1198,67 +1119,68 @@ impl<'a> flatbuffers::Follow<'a> for DnsA<'a> { impl<'a> DnsA<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsA { - _tab: table, - } + DnsA { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsAArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsABuilder::new(_fbb); - if let Some(x) = args.ip { builder.add_ip(x); } - builder.finish() + args: &'args DnsAArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsABuilder::new(_fbb); + if let Some(x) = args.ip { + builder.add_ip(x); + } + builder.finish() } pub const VT_IP: flatbuffers::VOffsetT = 4; - #[inline] - pub fn ip(&self) -> Option<&'a str> { - self._tab.get::>(DnsA::VT_IP, None) - } + #[inline] + pub fn ip(&self) -> Option<&'a str> { + self._tab + .get::>(DnsA::VT_IP, None) + } } pub struct DnsAArgs<'a> { - pub ip: Option>, + pub ip: Option>, } impl<'a> Default for DnsAArgs<'a> { #[inline] fn default() -> Self { - DnsAArgs { - ip: None, - } + DnsAArgs { ip: None } } } pub struct DnsABuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsABuilder<'a, 'b> { - #[inline] - pub fn add_ip(&mut self, ip: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsA::VT_IP, ip); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsABuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsABuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_ip(&mut self, ip: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsA::VT_IP, ip); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsABuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsABuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsAaaaOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsAaaa<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsAaaa<'a> { @@ -1274,67 +1196,68 @@ impl<'a> flatbuffers::Follow<'a> for DnsAaaa<'a> { impl<'a> DnsAaaa<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsAaaa { - _tab: table, - } + DnsAaaa { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsAaaaArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsAaaaBuilder::new(_fbb); - if let Some(x) = args.ip { builder.add_ip(x); } - builder.finish() + args: &'args DnsAaaaArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsAaaaBuilder::new(_fbb); + if let Some(x) = args.ip { + builder.add_ip(x); + } + builder.finish() } pub const VT_IP: flatbuffers::VOffsetT = 4; - #[inline] - pub fn ip(&self) -> Option<&'a str> { - self._tab.get::>(DnsAaaa::VT_IP, None) - } + #[inline] + pub fn ip(&self) -> Option<&'a str> { + self._tab + .get::>(DnsAaaa::VT_IP, None) + } } pub struct DnsAaaaArgs<'a> { - pub ip: Option>, + pub ip: Option>, } impl<'a> Default for DnsAaaaArgs<'a> { #[inline] fn default() -> Self { - DnsAaaaArgs { - ip: None, - } + DnsAaaaArgs { ip: None } } } pub struct DnsAaaaBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsAaaaBuilder<'a, 'b> { - #[inline] - pub fn add_ip(&mut self, ip: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsAaaa::VT_IP, ip); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsAaaaBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsAaaaBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_ip(&mut self, ip: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsAaaa::VT_IP, ip); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsAaaaBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsAaaaBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsCnameOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsCname<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsCname<'a> { @@ -1350,67 +1273,68 @@ impl<'a> flatbuffers::Follow<'a> for DnsCname<'a> { impl<'a> DnsCname<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsCname { - _tab: table, - } + DnsCname { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsCnameArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsCnameBuilder::new(_fbb); - if let Some(x) = args.name { builder.add_name(x); } - builder.finish() + args: &'args DnsCnameArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsCnameBuilder::new(_fbb); + if let Some(x) = args.name { + builder.add_name(x); + } + builder.finish() } pub const VT_NAME: flatbuffers::VOffsetT = 4; - #[inline] - pub fn name(&self) -> Option<&'a str> { - self._tab.get::>(DnsCname::VT_NAME, None) - } + #[inline] + pub fn name(&self) -> Option<&'a str> { + self._tab + .get::>(DnsCname::VT_NAME, None) + } } pub struct DnsCnameArgs<'a> { - pub name: Option>, + pub name: Option>, } impl<'a> Default for DnsCnameArgs<'a> { #[inline] fn default() -> Self { - DnsCnameArgs { - name: None, - } + DnsCnameArgs { name: None } } } pub struct DnsCnameBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsCnameBuilder<'a, 'b> { - #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsCname::VT_NAME, name); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsCnameBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsCnameBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsCname::VT_NAME, name); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsCnameBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsCnameBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsMxOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsMx<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsMx<'a> { @@ -1426,36 +1350,38 @@ impl<'a> flatbuffers::Follow<'a> for DnsMx<'a> { impl<'a> DnsMx<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsMx { - _tab: table, - } + DnsMx { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsMxArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsMxBuilder::new(_fbb); - if let Some(x) = args.exchange { builder.add_exchange(x); } - builder.add_preference(args.preference); - builder.finish() + args: &'args DnsMxArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsMxBuilder::new(_fbb); + if let Some(x) = args.exchange { + builder.add_exchange(x); + } + builder.add_preference(args.preference); + builder.finish() } pub const VT_PREFERENCE: flatbuffers::VOffsetT = 4; pub const VT_EXCHANGE: flatbuffers::VOffsetT = 6; - #[inline] - pub fn preference(&self) -> u16 { - self._tab.get::(DnsMx::VT_PREFERENCE, Some(0)).unwrap() - } - #[inline] - pub fn exchange(&self) -> Option<&'a str> { - self._tab.get::>(DnsMx::VT_EXCHANGE, None) - } + #[inline] + pub fn preference(&self) -> u16 { + self._tab.get::(DnsMx::VT_PREFERENCE, Some(0)).unwrap() + } + #[inline] + pub fn exchange(&self) -> Option<&'a str> { + self._tab + .get::>(DnsMx::VT_EXCHANGE, None) + } } pub struct DnsMxArgs<'a> { pub preference: u16, - pub exchange: Option>, + pub exchange: Option>, } impl<'a> Default for DnsMxArgs<'a> { #[inline] @@ -1467,38 +1393,40 @@ impl<'a> Default for DnsMxArgs<'a> { } } pub struct DnsMxBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsMxBuilder<'a, 'b> { - #[inline] - pub fn add_preference(&mut self, preference: u16) { - self.fbb_.push_slot::(DnsMx::VT_PREFERENCE, preference, 0); - } - #[inline] - pub fn add_exchange(&mut self, exchange: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsMx::VT_EXCHANGE, exchange); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsMxBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsMxBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_preference(&mut self, preference: u16) { + self.fbb_ + .push_slot::(DnsMx::VT_PREFERENCE, preference, 0); + } + #[inline] + pub fn add_exchange(&mut self, exchange: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsMx::VT_EXCHANGE, exchange); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsMxBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsMxBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsNsOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsNs<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsNs<'a> { @@ -1514,67 +1442,68 @@ impl<'a> flatbuffers::Follow<'a> for DnsNs<'a> { impl<'a> DnsNs<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsNs { - _tab: table, - } + DnsNs { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsNsArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsNsBuilder::new(_fbb); - if let Some(x) = args.name { builder.add_name(x); } - builder.finish() + args: &'args DnsNsArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsNsBuilder::new(_fbb); + if let Some(x) = args.name { + builder.add_name(x); + } + builder.finish() } pub const VT_NAME: flatbuffers::VOffsetT = 4; - #[inline] - pub fn name(&self) -> Option<&'a str> { - self._tab.get::>(DnsNs::VT_NAME, None) - } + #[inline] + pub fn name(&self) -> Option<&'a str> { + self._tab + .get::>(DnsNs::VT_NAME, None) + } } pub struct DnsNsArgs<'a> { - pub name: Option>, + pub name: Option>, } impl<'a> Default for DnsNsArgs<'a> { #[inline] fn default() -> Self { - DnsNsArgs { - name: None, - } + DnsNsArgs { name: None } } } pub struct DnsNsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsNsBuilder<'a, 'b> { - #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsNs::VT_NAME, name); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsNsBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsNsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsNs::VT_NAME, name); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsNsBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsNsBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsPtrOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsPtr<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsPtr<'a> { @@ -1590,67 +1519,68 @@ impl<'a> flatbuffers::Follow<'a> for DnsPtr<'a> { impl<'a> DnsPtr<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsPtr { - _tab: table, - } + DnsPtr { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsPtrArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsPtrBuilder::new(_fbb); - if let Some(x) = args.name { builder.add_name(x); } - builder.finish() + args: &'args DnsPtrArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsPtrBuilder::new(_fbb); + if let Some(x) = args.name { + builder.add_name(x); + } + builder.finish() } pub const VT_NAME: flatbuffers::VOffsetT = 4; - #[inline] - pub fn name(&self) -> Option<&'a str> { - self._tab.get::>(DnsPtr::VT_NAME, None) - } + #[inline] + pub fn name(&self) -> Option<&'a str> { + self._tab + .get::>(DnsPtr::VT_NAME, None) + } } pub struct DnsPtrArgs<'a> { - pub name: Option>, + pub name: Option>, } impl<'a> Default for DnsPtrArgs<'a> { #[inline] fn default() -> Self { - DnsPtrArgs { - name: None, - } + DnsPtrArgs { name: None } } } pub struct DnsPtrBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsPtrBuilder<'a, 'b> { - #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsPtr::VT_NAME, name); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsPtrBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsPtrBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsPtr::VT_NAME, name); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsPtrBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsPtrBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsSoaOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsSoa<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsSoa<'a> { @@ -1666,23 +1596,26 @@ impl<'a> flatbuffers::Follow<'a> for DnsSoa<'a> { impl<'a> DnsSoa<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsSoa { - _tab: table, - } + DnsSoa { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsSoaArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsSoaBuilder::new(_fbb); - builder.add_minimum(args.minimum); - builder.add_expire(args.expire); - builder.add_retry(args.retry); - builder.add_refresh(args.refresh); - builder.add_serial(args.serial); - if let Some(x) = args.rname { builder.add_rname(x); } - if let Some(x) = args.mname { builder.add_mname(x); } - builder.finish() + args: &'args DnsSoaArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsSoaBuilder::new(_fbb); + builder.add_minimum(args.minimum); + builder.add_expire(args.expire); + builder.add_retry(args.retry); + builder.add_refresh(args.refresh); + builder.add_serial(args.serial); + if let Some(x) = args.rname { + builder.add_rname(x); + } + if let Some(x) = args.mname { + builder.add_mname(x); + } + builder.finish() } pub const VT_MNAME: flatbuffers::VOffsetT = 4; @@ -1693,39 +1626,41 @@ impl<'a> DnsSoa<'a> { pub const VT_EXPIRE: flatbuffers::VOffsetT = 14; pub const VT_MINIMUM: flatbuffers::VOffsetT = 16; - #[inline] - pub fn mname(&self) -> Option<&'a str> { - self._tab.get::>(DnsSoa::VT_MNAME, None) - } - #[inline] - pub fn rname(&self) -> Option<&'a str> { - self._tab.get::>(DnsSoa::VT_RNAME, None) - } - #[inline] - pub fn serial(&self) -> u32 { - self._tab.get::(DnsSoa::VT_SERIAL, Some(0)).unwrap() - } - #[inline] - pub fn refresh(&self) -> i32 { - self._tab.get::(DnsSoa::VT_REFRESH, Some(0)).unwrap() - } - #[inline] - pub fn retry(&self) -> i32 { - self._tab.get::(DnsSoa::VT_RETRY, Some(0)).unwrap() - } - #[inline] - pub fn expire(&self) -> i32 { - self._tab.get::(DnsSoa::VT_EXPIRE, Some(0)).unwrap() - } - #[inline] - pub fn minimum(&self) -> u32 { - self._tab.get::(DnsSoa::VT_MINIMUM, Some(0)).unwrap() - } + #[inline] + pub fn mname(&self) -> Option<&'a str> { + self._tab + .get::>(DnsSoa::VT_MNAME, None) + } + #[inline] + pub fn rname(&self) -> Option<&'a str> { + self._tab + .get::>(DnsSoa::VT_RNAME, None) + } + #[inline] + pub fn serial(&self) -> u32 { + self._tab.get::(DnsSoa::VT_SERIAL, Some(0)).unwrap() + } + #[inline] + pub fn refresh(&self) -> i32 { + self._tab.get::(DnsSoa::VT_REFRESH, Some(0)).unwrap() + } + #[inline] + pub fn retry(&self) -> i32 { + self._tab.get::(DnsSoa::VT_RETRY, Some(0)).unwrap() + } + #[inline] + pub fn expire(&self) -> i32 { + self._tab.get::(DnsSoa::VT_EXPIRE, Some(0)).unwrap() + } + #[inline] + pub fn minimum(&self) -> u32 { + self._tab.get::(DnsSoa::VT_MINIMUM, Some(0)).unwrap() + } } pub struct DnsSoaArgs<'a> { - pub mname: Option>, - pub rname: Option>, + pub mname: Option>, + pub rname: Option>, pub serial: u32, pub refresh: i32, pub retry: i32, @@ -1747,58 +1682,60 @@ impl<'a> Default for DnsSoaArgs<'a> { } } pub struct DnsSoaBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsSoaBuilder<'a, 'b> { - #[inline] - pub fn add_mname(&mut self, mname: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsSoa::VT_MNAME, mname); - } - #[inline] - pub fn add_rname(&mut self, rname: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsSoa::VT_RNAME, rname); - } - #[inline] - pub fn add_serial(&mut self, serial: u32) { - self.fbb_.push_slot::(DnsSoa::VT_SERIAL, serial, 0); - } - #[inline] - pub fn add_refresh(&mut self, refresh: i32) { - self.fbb_.push_slot::(DnsSoa::VT_REFRESH, refresh, 0); - } - #[inline] - pub fn add_retry(&mut self, retry: i32) { - self.fbb_.push_slot::(DnsSoa::VT_RETRY, retry, 0); - } - #[inline] - pub fn add_expire(&mut self, expire: i32) { - self.fbb_.push_slot::(DnsSoa::VT_EXPIRE, expire, 0); - } - #[inline] - pub fn add_minimum(&mut self, minimum: u32) { - self.fbb_.push_slot::(DnsSoa::VT_MINIMUM, minimum, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsSoaBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsSoaBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_mname(&mut self, mname: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsSoa::VT_MNAME, mname); + } + #[inline] + pub fn add_rname(&mut self, rname: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsSoa::VT_RNAME, rname); + } + #[inline] + pub fn add_serial(&mut self, serial: u32) { + self.fbb_.push_slot::(DnsSoa::VT_SERIAL, serial, 0); + } + #[inline] + pub fn add_refresh(&mut self, refresh: i32) { + self.fbb_.push_slot::(DnsSoa::VT_REFRESH, refresh, 0); + } + #[inline] + pub fn add_retry(&mut self, retry: i32) { + self.fbb_.push_slot::(DnsSoa::VT_RETRY, retry, 0); + } + #[inline] + pub fn add_expire(&mut self, expire: i32) { + self.fbb_.push_slot::(DnsSoa::VT_EXPIRE, expire, 0); + } + #[inline] + pub fn add_minimum(&mut self, minimum: u32) { + self.fbb_.push_slot::(DnsSoa::VT_MINIMUM, minimum, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsSoaBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsSoaBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsSrvOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsSrv<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsSrv<'a> { @@ -1814,20 +1751,21 @@ impl<'a> flatbuffers::Follow<'a> for DnsSrv<'a> { impl<'a> DnsSrv<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsSrv { - _tab: table, - } + DnsSrv { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsSrvArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsSrvBuilder::new(_fbb); - if let Some(x) = args.target { builder.add_target(x); } - builder.add_port(args.port); - builder.add_weight(args.weight); - builder.add_priority(args.priority); - builder.finish() + args: &'args DnsSrvArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsSrvBuilder::new(_fbb); + if let Some(x) = args.target { + builder.add_target(x); + } + builder.add_port(args.port); + builder.add_weight(args.weight); + builder.add_priority(args.priority); + builder.finish() } pub const VT_PRIORITY: flatbuffers::VOffsetT = 4; @@ -1835,29 +1773,30 @@ impl<'a> DnsSrv<'a> { pub const VT_PORT: flatbuffers::VOffsetT = 8; pub const VT_TARGET: flatbuffers::VOffsetT = 10; - #[inline] - pub fn priority(&self) -> u16 { - self._tab.get::(DnsSrv::VT_PRIORITY, Some(0)).unwrap() - } - #[inline] - pub fn weight(&self) -> u16 { - self._tab.get::(DnsSrv::VT_WEIGHT, Some(0)).unwrap() - } - #[inline] - pub fn port(&self) -> u16 { - self._tab.get::(DnsSrv::VT_PORT, Some(0)).unwrap() - } - #[inline] - pub fn target(&self) -> Option<&'a str> { - self._tab.get::>(DnsSrv::VT_TARGET, None) - } + #[inline] + pub fn priority(&self) -> u16 { + self._tab.get::(DnsSrv::VT_PRIORITY, Some(0)).unwrap() + } + #[inline] + pub fn weight(&self) -> u16 { + self._tab.get::(DnsSrv::VT_WEIGHT, Some(0)).unwrap() + } + #[inline] + pub fn port(&self) -> u16 { + self._tab.get::(DnsSrv::VT_PORT, Some(0)).unwrap() + } + #[inline] + pub fn target(&self) -> Option<&'a str> { + self._tab + .get::>(DnsSrv::VT_TARGET, None) + } } pub struct DnsSrvArgs<'a> { pub priority: u16, pub weight: u16, pub port: u16, - pub target: Option>, + pub target: Option>, } impl<'a> Default for DnsSrvArgs<'a> { #[inline] @@ -1871,46 +1810,47 @@ impl<'a> Default for DnsSrvArgs<'a> { } } pub struct DnsSrvBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsSrvBuilder<'a, 'b> { - #[inline] - pub fn add_priority(&mut self, priority: u16) { - self.fbb_.push_slot::(DnsSrv::VT_PRIORITY, priority, 0); - } - #[inline] - pub fn add_weight(&mut self, weight: u16) { - self.fbb_.push_slot::(DnsSrv::VT_WEIGHT, weight, 0); - } - #[inline] - pub fn add_port(&mut self, port: u16) { - self.fbb_.push_slot::(DnsSrv::VT_PORT, port, 0); - } - #[inline] - pub fn add_target(&mut self, target: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsSrv::VT_TARGET, target); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsSrvBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsSrvBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_priority(&mut self, priority: u16) { + self.fbb_.push_slot::(DnsSrv::VT_PRIORITY, priority, 0); + } + #[inline] + pub fn add_weight(&mut self, weight: u16) { + self.fbb_.push_slot::(DnsSrv::VT_WEIGHT, weight, 0); + } + #[inline] + pub fn add_port(&mut self, port: u16) { + self.fbb_.push_slot::(DnsSrv::VT_PORT, port, 0); + } + #[inline] + pub fn add_target(&mut self, target: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsSrv::VT_TARGET, target); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsSrvBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsSrvBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsTxtDataOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsTxtData<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsTxtData<'a> { @@ -1926,67 +1866,72 @@ impl<'a> flatbuffers::Follow<'a> for DnsTxtData<'a> { impl<'a> DnsTxtData<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsTxtData { - _tab: table, - } + DnsTxtData { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsTxtDataArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsTxtDataBuilder::new(_fbb); - if let Some(x) = args.data { builder.add_data(x); } - builder.finish() + args: &'args DnsTxtDataArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsTxtDataBuilder::new(_fbb); + if let Some(x) = args.data { + builder.add_data(x); + } + builder.finish() } pub const VT_DATA: flatbuffers::VOffsetT = 4; - #[inline] - pub fn data(&self) -> Option<&'a [u8]> { - self._tab.get::>>(DnsTxtData::VT_DATA, None).map(|v| v.safe_slice()) - } + #[inline] + pub fn data(&self) -> Option<&'a [u8]> { + self._tab + .get::>>( + DnsTxtData::VT_DATA, + None, + ) + .map(|v| v.safe_slice()) + } } pub struct DnsTxtDataArgs<'a> { - pub data: Option>>, + pub data: Option>>, } impl<'a> Default for DnsTxtDataArgs<'a> { #[inline] fn default() -> Self { - DnsTxtDataArgs { - data: None, - } + DnsTxtDataArgs { data: None } } } pub struct DnsTxtDataBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsTxtDataBuilder<'a, 'b> { - #[inline] - pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(DnsTxtData::VT_DATA, data); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsTxtDataBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsTxtDataBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_data(&mut self, data: flatbuffers::WIPOffset>) { + self.fbb_ + .push_slot_always::>(DnsTxtData::VT_DATA, data); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsTxtDataBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsTxtDataBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsTxtOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsTxt<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsTxt<'a> { @@ -2002,67 +1947,80 @@ impl<'a> flatbuffers::Follow<'a> for DnsTxt<'a> { impl<'a> DnsTxt<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsTxt { - _tab: table, - } + DnsTxt { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsTxtArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsTxtBuilder::new(_fbb); - if let Some(x) = args.data { builder.add_data(x); } - builder.finish() + args: &'args DnsTxtArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsTxtBuilder::new(_fbb); + if let Some(x) = args.data { + builder.add_data(x); + } + builder.finish() } pub const VT_DATA: flatbuffers::VOffsetT = 4; - #[inline] - pub fn data(&self) -> Option>>> { - self._tab.get::>>>>(DnsTxt::VT_DATA, None) - } + #[inline] + pub fn data( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(DnsTxt::VT_DATA, None) + } } pub struct DnsTxtArgs<'a> { - pub data: Option>>>>, + pub data: Option< + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + >, + >, } impl<'a> Default for DnsTxtArgs<'a> { #[inline] fn default() -> Self { - DnsTxtArgs { - data: None, - } + DnsTxtArgs { data: None } } } pub struct DnsTxtBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsTxtBuilder<'a, 'b> { - #[inline] - pub fn add_data(&mut self, data: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(DnsTxt::VT_DATA, data); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsTxtBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsTxtBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_data( + &mut self, + data: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(DnsTxt::VT_DATA, data); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsTxtBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsTxtBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsRequestOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsRequest<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsRequest<'a> { @@ -2078,43 +2036,52 @@ impl<'a> flatbuffers::Follow<'a> for DnsRequest<'a> { impl<'a> DnsRequest<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsRequest { - _tab: table, - } + DnsRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsRequestArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsRequestBuilder::new(_fbb); - if let Some(x) = args.queries { builder.add_queries(x); } - builder.add_id(args.id); - builder.add_message_type(args.message_type); - builder.finish() + args: &'args DnsRequestArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsRequestBuilder::new(_fbb); + if let Some(x) = args.queries { + builder.add_queries(x); + } + builder.add_id(args.id); + builder.add_message_type(args.message_type); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_MESSAGE_TYPE: flatbuffers::VOffsetT = 6; pub const VT_QUERIES: flatbuffers::VOffsetT = 8; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(DnsRequest::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn message_type(&self) -> DnsMessageType { - self._tab.get::(DnsRequest::VT_MESSAGE_TYPE, Some(DnsMessageType::Query)).unwrap() - } - #[inline] - pub fn queries(&self) -> Option>>> { - self._tab.get::>>>>(DnsRequest::VT_QUERIES, None) - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(DnsRequest::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn message_type(&self) -> DnsMessageType { + self._tab + .get::(DnsRequest::VT_MESSAGE_TYPE, Some(DnsMessageType::Query)) + .unwrap() + } + #[inline] + pub fn queries( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(DnsRequest::VT_QUERIES, None) + } } pub struct DnsRequestArgs<'a> { pub id: u32, pub message_type: DnsMessageType, - pub queries: Option>>>>, + pub queries: Option< + flatbuffers::WIPOffset>>>, + >, } impl<'a> Default for DnsRequestArgs<'a> { #[inline] @@ -2127,42 +2094,52 @@ impl<'a> Default for DnsRequestArgs<'a> { } } pub struct DnsRequestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsRequestBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(DnsRequest::VT_ID, id, 0); - } - #[inline] - pub fn add_message_type(&mut self, message_type: DnsMessageType) { - self.fbb_.push_slot::(DnsRequest::VT_MESSAGE_TYPE, message_type, DnsMessageType::Query); - } - #[inline] - pub fn add_queries(&mut self, queries: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(DnsRequest::VT_QUERIES, queries); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsRequestBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsRequestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(DnsRequest::VT_ID, id, 0); + } + #[inline] + pub fn add_message_type(&mut self, message_type: DnsMessageType) { + self.fbb_.push_slot::( + DnsRequest::VT_MESSAGE_TYPE, + message_type, + DnsMessageType::Query, + ); + } + #[inline] + pub fn add_queries( + &mut self, + queries: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(DnsRequest::VT_QUERIES, queries); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsQueryOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsQuery<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsQuery<'a> { @@ -2178,20 +2155,23 @@ impl<'a> flatbuffers::Follow<'a> for DnsQuery<'a> { impl<'a> DnsQuery<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsQuery { - _tab: table, - } + DnsQuery { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsQueryArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsQueryBuilder::new(_fbb); - if let Some(x) = args.name_servers { builder.add_name_servers(x); } - if let Some(x) = args.name { builder.add_name(x); } - builder.add_dns_class(args.dns_class); - builder.add_rr_type(args.rr_type); - builder.finish() + args: &'args DnsQueryArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsQueryBuilder::new(_fbb); + if let Some(x) = args.name_servers { + builder.add_name_servers(x); + } + if let Some(x) = args.name { + builder.add_name(x); + } + builder.add_dns_class(args.dns_class); + builder.add_rr_type(args.rr_type); + builder.finish() } pub const VT_NAME: flatbuffers::VOffsetT = 4; @@ -2199,29 +2179,40 @@ impl<'a> DnsQuery<'a> { pub const VT_DNS_CLASS: flatbuffers::VOffsetT = 8; pub const VT_NAME_SERVERS: flatbuffers::VOffsetT = 10; - #[inline] - pub fn name(&self) -> Option<&'a str> { - self._tab.get::>(DnsQuery::VT_NAME, None) - } - #[inline] - pub fn rr_type(&self) -> DnsRecordType { - self._tab.get::(DnsQuery::VT_RR_TYPE, Some(DnsRecordType::A)).unwrap() - } - #[inline] - pub fn dns_class(&self) -> DnsClass { - self._tab.get::(DnsQuery::VT_DNS_CLASS, Some(DnsClass::IN)).unwrap() - } - #[inline] - pub fn name_servers(&self) -> Option>> { - self._tab.get::>>>(DnsQuery::VT_NAME_SERVERS, None) - } + #[inline] + pub fn name(&self) -> Option<&'a str> { + self._tab + .get::>(DnsQuery::VT_NAME, None) + } + #[inline] + pub fn rr_type(&self) -> DnsRecordType { + self._tab + .get::(DnsQuery::VT_RR_TYPE, Some(DnsRecordType::A)) + .unwrap() + } + #[inline] + pub fn dns_class(&self) -> DnsClass { + self._tab + .get::(DnsQuery::VT_DNS_CLASS, Some(DnsClass::IN)) + .unwrap() + } + #[inline] + pub fn name_servers( + &self, + ) -> Option>> { + self._tab.get::>, + >>(DnsQuery::VT_NAME_SERVERS, None) + } } pub struct DnsQueryArgs<'a> { - pub name: Option>, + pub name: Option>, pub rr_type: DnsRecordType, pub dns_class: DnsClass, - pub name_servers: Option>>>, + pub name_servers: Option< + flatbuffers::WIPOffset>>, + >, } impl<'a> Default for DnsQueryArgs<'a> { #[inline] @@ -2235,46 +2226,55 @@ impl<'a> Default for DnsQueryArgs<'a> { } } pub struct DnsQueryBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsQueryBuilder<'a, 'b> { - #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsQuery::VT_NAME, name); - } - #[inline] - pub fn add_rr_type(&mut self, rr_type: DnsRecordType) { - self.fbb_.push_slot::(DnsQuery::VT_RR_TYPE, rr_type, DnsRecordType::A); - } - #[inline] - pub fn add_dns_class(&mut self, dns_class: DnsClass) { - self.fbb_.push_slot::(DnsQuery::VT_DNS_CLASS, dns_class, DnsClass::IN); - } - #[inline] - pub fn add_name_servers(&mut self, name_servers: flatbuffers::WIPOffset>>) { - self.fbb_.push_slot_always::>(DnsQuery::VT_NAME_SERVERS, name_servers); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsQueryBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsQueryBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsQuery::VT_NAME, name); + } + #[inline] + pub fn add_rr_type(&mut self, rr_type: DnsRecordType) { + self.fbb_ + .push_slot::(DnsQuery::VT_RR_TYPE, rr_type, DnsRecordType::A); + } + #[inline] + pub fn add_dns_class(&mut self, dns_class: DnsClass) { + self.fbb_ + .push_slot::(DnsQuery::VT_DNS_CLASS, dns_class, DnsClass::IN); + } + #[inline] + pub fn add_name_servers( + &mut self, + name_servers: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>, + >, + ) { + self.fbb_ + .push_slot_always::>(DnsQuery::VT_NAME_SERVERS, name_servers); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsQueryBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsQueryBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsRecordOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsRecord<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsRecord<'a> { @@ -2290,22 +2290,25 @@ impl<'a> flatbuffers::Follow<'a> for DnsRecord<'a> { impl<'a> DnsRecord<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsRecord { - _tab: table, - } + DnsRecord { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsRecordArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsRecordBuilder::new(_fbb); - builder.add_ttl(args.ttl); - if let Some(x) = args.rdata { builder.add_rdata(x); } - if let Some(x) = args.name { builder.add_name(x); } - builder.add_dns_class(args.dns_class); - builder.add_rdata_type(args.rdata_type); - builder.add_rr_type(args.rr_type); - builder.finish() + args: &'args DnsRecordArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsRecordBuilder::new(_fbb); + builder.add_ttl(args.ttl); + if let Some(x) = args.rdata { + builder.add_rdata(x); + } + if let Some(x) = args.name { + builder.add_name(x); + } + builder.add_dns_class(args.dns_class); + builder.add_rdata_type(args.rdata_type); + builder.add_rr_type(args.rr_type); + builder.finish() } pub const VT_NAME: flatbuffers::VOffsetT = 4; @@ -2315,124 +2318,131 @@ impl<'a> DnsRecord<'a> { pub const VT_DNS_CLASS: flatbuffers::VOffsetT = 12; pub const VT_TTL: flatbuffers::VOffsetT = 14; - #[inline] - pub fn name(&self) -> Option<&'a str> { - self._tab.get::>(DnsRecord::VT_NAME, None) - } - #[inline] - pub fn rr_type(&self) -> DnsRecordType { - self._tab.get::(DnsRecord::VT_RR_TYPE, Some(DnsRecordType::A)).unwrap() - } - #[inline] - pub fn rdata_type(&self) -> DnsRecordData { - self._tab.get::(DnsRecord::VT_RDATA_TYPE, Some(DnsRecordData::NONE)).unwrap() - } - #[inline] - pub fn rdata(&self) -> Option> { - self._tab.get::>>(DnsRecord::VT_RDATA, None) - } - #[inline] - pub fn dns_class(&self) -> DnsClass { - self._tab.get::(DnsRecord::VT_DNS_CLASS, Some(DnsClass::IN)).unwrap() - } - #[inline] - pub fn ttl(&self) -> u32 { - self._tab.get::(DnsRecord::VT_TTL, Some(0)).unwrap() - } - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_a(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsA { - self.rdata().map(|u| DnsA::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_aaaa(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsAaaa { - self.rdata().map(|u| DnsAaaa::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_cname(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsCname { - self.rdata().map(|u| DnsCname::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_mx(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsMx { - self.rdata().map(|u| DnsMx::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_ns(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsNs { - self.rdata().map(|u| DnsNs::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_ptr(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsPtr { - self.rdata().map(|u| DnsPtr::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_soa(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsSoa { - self.rdata().map(|u| DnsSoa::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_srv(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsSrv { - self.rdata().map(|u| DnsSrv::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn rdata_as_dns_txt(&'a self) -> Option { - if self.rdata_type() == DnsRecordData::DnsTxt { - self.rdata().map(|u| DnsTxt::init_from_table(u)) - } else { - None - } - } + #[inline] + pub fn name(&self) -> Option<&'a str> { + self._tab + .get::>(DnsRecord::VT_NAME, None) + } + #[inline] + pub fn rr_type(&self) -> DnsRecordType { + self._tab + .get::(DnsRecord::VT_RR_TYPE, Some(DnsRecordType::A)) + .unwrap() + } + #[inline] + pub fn rdata_type(&self) -> DnsRecordData { + self._tab + .get::(DnsRecord::VT_RDATA_TYPE, Some(DnsRecordData::NONE)) + .unwrap() + } + #[inline] + pub fn rdata(&self) -> Option> { + self._tab + .get::>>(DnsRecord::VT_RDATA, None) + } + #[inline] + pub fn dns_class(&self) -> DnsClass { + self._tab + .get::(DnsRecord::VT_DNS_CLASS, Some(DnsClass::IN)) + .unwrap() + } + #[inline] + pub fn ttl(&self) -> u32 { + self._tab.get::(DnsRecord::VT_TTL, Some(0)).unwrap() + } + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_a(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsA { + self.rdata().map(|u| DnsA::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_aaaa(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsAaaa { + self.rdata().map(|u| DnsAaaa::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_cname(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsCname { + self.rdata().map(|u| DnsCname::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_mx(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsMx { + self.rdata().map(|u| DnsMx::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_ns(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsNs { + self.rdata().map(|u| DnsNs::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_ptr(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsPtr { + self.rdata().map(|u| DnsPtr::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_soa(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsSoa { + self.rdata().map(|u| DnsSoa::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_srv(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsSrv { + self.rdata().map(|u| DnsSrv::init_from_table(u)) + } else { + None + } + } + #[inline] + #[allow(non_snake_case)] + pub fn rdata_as_dns_txt(&'a self) -> Option { + if self.rdata_type() == DnsRecordData::DnsTxt { + self.rdata().map(|u| DnsTxt::init_from_table(u)) + } else { + None + } + } } pub struct DnsRecordArgs<'a> { - pub name: Option>, + pub name: Option>, pub rr_type: DnsRecordType, pub rdata_type: DnsRecordData, pub rdata: Option>, @@ -2453,54 +2463,62 @@ impl<'a> Default for DnsRecordArgs<'a> { } } pub struct DnsRecordBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsRecordBuilder<'a, 'b> { - #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DnsRecord::VT_NAME, name); - } - #[inline] - pub fn add_rr_type(&mut self, rr_type: DnsRecordType) { - self.fbb_.push_slot::(DnsRecord::VT_RR_TYPE, rr_type, DnsRecordType::A); - } - #[inline] - pub fn add_rdata_type(&mut self, rdata_type: DnsRecordData) { - self.fbb_.push_slot::(DnsRecord::VT_RDATA_TYPE, rdata_type, DnsRecordData::NONE); - } - #[inline] - pub fn add_rdata(&mut self, rdata: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(DnsRecord::VT_RDATA, rdata); - } - #[inline] - pub fn add_dns_class(&mut self, dns_class: DnsClass) { - self.fbb_.push_slot::(DnsRecord::VT_DNS_CLASS, dns_class, DnsClass::IN); - } - #[inline] - pub fn add_ttl(&mut self, ttl: u32) { - self.fbb_.push_slot::(DnsRecord::VT_TTL, ttl, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsRecordBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsRecordBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DnsRecord::VT_NAME, name); + } + #[inline] + pub fn add_rr_type(&mut self, rr_type: DnsRecordType) { + self.fbb_ + .push_slot::(DnsRecord::VT_RR_TYPE, rr_type, DnsRecordType::A); + } + #[inline] + pub fn add_rdata_type(&mut self, rdata_type: DnsRecordData) { + self.fbb_.push_slot::( + DnsRecord::VT_RDATA_TYPE, + rdata_type, + DnsRecordData::NONE, + ); + } + #[inline] + pub fn add_rdata(&mut self, rdata: flatbuffers::WIPOffset) { + self.fbb_ + .push_slot_always::>(DnsRecord::VT_RDATA, rdata); + } + #[inline] + pub fn add_dns_class(&mut self, dns_class: DnsClass) { + self.fbb_ + .push_slot::(DnsRecord::VT_DNS_CLASS, dns_class, DnsClass::IN); + } + #[inline] + pub fn add_ttl(&mut self, ttl: u32) { + self.fbb_.push_slot::(DnsRecord::VT_TTL, ttl, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsRecordBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsRecordBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DnsResponseOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DnsResponse<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DnsResponse<'a> { @@ -2516,24 +2534,27 @@ impl<'a> flatbuffers::Follow<'a> for DnsResponse<'a> { impl<'a> DnsResponse<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DnsResponse { - _tab: table, - } + DnsResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DnsResponseArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DnsResponseBuilder::new(_fbb); - if let Some(x) = args.queries { builder.add_queries(x); } - if let Some(x) = args.answers { builder.add_answers(x); } - builder.add_id(args.id); - builder.add_response_code(args.response_code); - builder.add_truncated(args.truncated); - builder.add_authoritative(args.authoritative); - builder.add_message_type(args.message_type); - builder.add_op_code(args.op_code); - builder.finish() + args: &'args DnsResponseArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DnsResponseBuilder::new(_fbb); + if let Some(x) = args.queries { + builder.add_queries(x); + } + if let Some(x) = args.answers { + builder.add_answers(x); + } + builder.add_id(args.id); + builder.add_response_code(args.response_code); + builder.add_truncated(args.truncated); + builder.add_authoritative(args.authoritative); + builder.add_message_type(args.message_type); + builder.add_op_code(args.op_code); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; @@ -2545,38 +2566,59 @@ impl<'a> DnsResponse<'a> { pub const VT_ANSWERS: flatbuffers::VOffsetT = 16; pub const VT_QUERIES: flatbuffers::VOffsetT = 18; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(DnsResponse::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn op_code(&self) -> DnsOpCode { - self._tab.get::(DnsResponse::VT_OP_CODE, Some(DnsOpCode::Query)).unwrap() - } - #[inline] - pub fn message_type(&self) -> DnsMessageType { - self._tab.get::(DnsResponse::VT_MESSAGE_TYPE, Some(DnsMessageType::Query)).unwrap() - } - #[inline] - pub fn authoritative(&self) -> bool { - self._tab.get::(DnsResponse::VT_AUTHORITATIVE, Some(false)).unwrap() - } - #[inline] - pub fn truncated(&self) -> bool { - self._tab.get::(DnsResponse::VT_TRUNCATED, Some(false)).unwrap() - } - #[inline] - pub fn response_code(&self) -> DnsResponseCode { - self._tab.get::(DnsResponse::VT_RESPONSE_CODE, Some(DnsResponseCode::NoError)).unwrap() - } - #[inline] - pub fn answers(&self) -> Option>>> { - self._tab.get::>>>>(DnsResponse::VT_ANSWERS, None) - } - #[inline] - pub fn queries(&self) -> Option>>> { - self._tab.get::>>>>(DnsResponse::VT_QUERIES, None) - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(DnsResponse::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn op_code(&self) -> DnsOpCode { + self._tab + .get::(DnsResponse::VT_OP_CODE, Some(DnsOpCode::Query)) + .unwrap() + } + #[inline] + pub fn message_type(&self) -> DnsMessageType { + self._tab + .get::(DnsResponse::VT_MESSAGE_TYPE, Some(DnsMessageType::Query)) + .unwrap() + } + #[inline] + pub fn authoritative(&self) -> bool { + self._tab + .get::(DnsResponse::VT_AUTHORITATIVE, Some(false)) + .unwrap() + } + #[inline] + pub fn truncated(&self) -> bool { + self._tab + .get::(DnsResponse::VT_TRUNCATED, Some(false)) + .unwrap() + } + #[inline] + pub fn response_code(&self) -> DnsResponseCode { + self._tab + .get::( + DnsResponse::VT_RESPONSE_CODE, + Some(DnsResponseCode::NoError), + ) + .unwrap() + } + #[inline] + pub fn answers( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(DnsResponse::VT_ANSWERS, None) + } + #[inline] + pub fn queries( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(DnsResponse::VT_QUERIES, None) + } } pub struct DnsResponseArgs<'a> { @@ -2586,8 +2628,14 @@ pub struct DnsResponseArgs<'a> { pub authoritative: bool, pub truncated: bool, pub response_code: DnsResponseCode, - pub answers: Option>>>>, - pub queries: Option>>>>, + pub answers: Option< + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + >, + >, + pub queries: Option< + flatbuffers::WIPOffset>>>, + >, } impl<'a> Default for DnsResponseArgs<'a> { #[inline] @@ -2605,62 +2653,85 @@ impl<'a> Default for DnsResponseArgs<'a> { } } pub struct DnsResponseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DnsResponseBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(DnsResponse::VT_ID, id, 0); - } - #[inline] - pub fn add_op_code(&mut self, op_code: DnsOpCode) { - self.fbb_.push_slot::(DnsResponse::VT_OP_CODE, op_code, DnsOpCode::Query); - } - #[inline] - pub fn add_message_type(&mut self, message_type: DnsMessageType) { - self.fbb_.push_slot::(DnsResponse::VT_MESSAGE_TYPE, message_type, DnsMessageType::Query); - } - #[inline] - pub fn add_authoritative(&mut self, authoritative: bool) { - self.fbb_.push_slot::(DnsResponse::VT_AUTHORITATIVE, authoritative, false); - } - #[inline] - pub fn add_truncated(&mut self, truncated: bool) { - self.fbb_.push_slot::(DnsResponse::VT_TRUNCATED, truncated, false); - } - #[inline] - pub fn add_response_code(&mut self, response_code: DnsResponseCode) { - self.fbb_.push_slot::(DnsResponse::VT_RESPONSE_CODE, response_code, DnsResponseCode::NoError); - } - #[inline] - pub fn add_answers(&mut self, answers: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(DnsResponse::VT_ANSWERS, answers); - } - #[inline] - pub fn add_queries(&mut self, queries: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(DnsResponse::VT_QUERIES, queries); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsResponseBuilder<'a, 'b> { - let start = _fbb.start_table(); - DnsResponseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(DnsResponse::VT_ID, id, 0); + } + #[inline] + pub fn add_op_code(&mut self, op_code: DnsOpCode) { + self.fbb_ + .push_slot::(DnsResponse::VT_OP_CODE, op_code, DnsOpCode::Query); + } + #[inline] + pub fn add_message_type(&mut self, message_type: DnsMessageType) { + self.fbb_.push_slot::( + DnsResponse::VT_MESSAGE_TYPE, + message_type, + DnsMessageType::Query, + ); + } + #[inline] + pub fn add_authoritative(&mut self, authoritative: bool) { + self.fbb_ + .push_slot::(DnsResponse::VT_AUTHORITATIVE, authoritative, false); + } + #[inline] + pub fn add_truncated(&mut self, truncated: bool) { + self.fbb_ + .push_slot::(DnsResponse::VT_TRUNCATED, truncated, false); + } + #[inline] + pub fn add_response_code(&mut self, response_code: DnsResponseCode) { + self.fbb_.push_slot::( + DnsResponse::VT_RESPONSE_CODE, + response_code, + DnsResponseCode::NoError, + ); + } + #[inline] + pub fn add_answers( + &mut self, + answers: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(DnsResponse::VT_ANSWERS, answers); + } + #[inline] + pub fn add_queries( + &mut self, + queries: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(DnsResponse::VT_QUERIES, queries); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DnsResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + DnsResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheGetOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheGet<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheGet<'a> { @@ -2676,67 +2747,68 @@ impl<'a> flatbuffers::Follow<'a> for CacheGet<'a> { impl<'a> CacheGet<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheGet { - _tab: table, - } + CacheGet { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheGetArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheGetBuilder::new(_fbb); - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheGetArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheGetBuilder::new(_fbb); + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheGet::VT_KEY, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheGet::VT_KEY, None) + } } pub struct CacheGetArgs<'a> { - pub key: Option>, + pub key: Option>, } impl<'a> Default for CacheGetArgs<'a> { #[inline] fn default() -> Self { - CacheGetArgs { - key: None, - } + CacheGetArgs { key: None } } } pub struct CacheGetBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheGetBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheGet::VT_KEY, key); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheGetBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheGetBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheGet::VT_KEY, key); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheGetBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheGetBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheMetaOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheMeta<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheMeta<'a> { @@ -2752,36 +2824,41 @@ impl<'a> flatbuffers::Follow<'a> for CacheMeta<'a> { impl<'a> CacheMeta<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheMeta { - _tab: table, - } + CacheMeta { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheMetaArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheMetaBuilder::new(_fbb); - if let Some(x) = args.value { builder.add_value(x); } - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheMetaArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheMetaBuilder::new(_fbb); + if let Some(x) = args.value { + builder.add_value(x); + } + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; pub const VT_VALUE: flatbuffers::VOffsetT = 6; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheMeta::VT_KEY, None) - } - #[inline] - pub fn value(&self) -> Option<&'a str> { - self._tab.get::>(CacheMeta::VT_VALUE, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheMeta::VT_KEY, None) + } + #[inline] + pub fn value(&self) -> Option<&'a str> { + self._tab + .get::>(CacheMeta::VT_VALUE, None) + } } pub struct CacheMetaArgs<'a> { - pub key: Option>, - pub value: Option>, + pub key: Option>, + pub value: Option>, } impl<'a> Default for CacheMetaArgs<'a> { #[inline] @@ -2793,38 +2870,40 @@ impl<'a> Default for CacheMetaArgs<'a> { } } pub struct CacheMetaBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheMetaBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheMeta::VT_KEY, key); - } - #[inline] - pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheMeta::VT_VALUE, value); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheMetaBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheMetaBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheMeta::VT_KEY, key); + } + #[inline] + pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheMeta::VT_VALUE, value); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheMetaBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheMetaBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheGetReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheGetReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheGetReady<'a> { @@ -2840,43 +2919,47 @@ impl<'a> flatbuffers::Follow<'a> for CacheGetReady<'a> { impl<'a> CacheGetReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheGetReady { - _tab: table, - } + CacheGetReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheGetReadyArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheGetReadyBuilder::new(_fbb); - if let Some(x) = args.meta { builder.add_meta(x); } - builder.add_id(args.id); - builder.add_stream(args.stream); - builder.finish() + args: &'args CacheGetReadyArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheGetReadyBuilder::new(_fbb); + if let Some(x) = args.meta { + builder.add_meta(x); + } + builder.add_id(args.id); + builder.add_stream(args.stream); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_STREAM: flatbuffers::VOffsetT = 6; pub const VT_META: flatbuffers::VOffsetT = 8; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(CacheGetReady::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn stream(&self) -> bool { - self._tab.get::(CacheGetReady::VT_STREAM, Some(false)).unwrap() - } - #[inline] - pub fn meta(&self) -> Option<&'a str> { - self._tab.get::>(CacheGetReady::VT_META, None) - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(CacheGetReady::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn stream(&self) -> bool { + self._tab + .get::(CacheGetReady::VT_STREAM, Some(false)) + .unwrap() + } + #[inline] + pub fn meta(&self) -> Option<&'a str> { + self._tab + .get::>(CacheGetReady::VT_META, None) + } } pub struct CacheGetReadyArgs<'a> { pub id: u32, pub stream: bool, - pub meta: Option>, + pub meta: Option>, } impl<'a> Default for CacheGetReadyArgs<'a> { #[inline] @@ -2889,42 +2972,44 @@ impl<'a> Default for CacheGetReadyArgs<'a> { } } pub struct CacheGetReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheGetReadyBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(CacheGetReady::VT_ID, id, 0); - } - #[inline] - pub fn add_stream(&mut self, stream: bool) { - self.fbb_.push_slot::(CacheGetReady::VT_STREAM, stream, false); - } - #[inline] - pub fn add_meta(&mut self, meta: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheGetReady::VT_META, meta); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheGetReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheGetReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(CacheGetReady::VT_ID, id, 0); + } + #[inline] + pub fn add_stream(&mut self, stream: bool) { + self.fbb_ + .push_slot::(CacheGetReady::VT_STREAM, stream, false); + } + #[inline] + pub fn add_meta(&mut self, meta: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheGetReady::VT_META, meta); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheGetReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheGetReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheSetOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheSet<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheSet<'a> { @@ -2940,20 +3025,25 @@ impl<'a> flatbuffers::Follow<'a> for CacheSet<'a> { impl<'a> CacheSet<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheSet { - _tab: table, - } + CacheSet { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheSetArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheSetBuilder::new(_fbb); - if let Some(x) = args.meta { builder.add_meta(x); } - if let Some(x) = args.tags { builder.add_tags(x); } - builder.add_ttl(args.ttl); - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheSetArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheSetBuilder::new(_fbb); + if let Some(x) = args.meta { + builder.add_meta(x); + } + if let Some(x) = args.tags { + builder.add_tags(x); + } + builder.add_ttl(args.ttl); + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; @@ -2961,29 +3051,35 @@ impl<'a> CacheSet<'a> { pub const VT_TAGS: flatbuffers::VOffsetT = 8; pub const VT_META: flatbuffers::VOffsetT = 10; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheSet::VT_KEY, None) - } - #[inline] - pub fn ttl(&self) -> u32 { - self._tab.get::(CacheSet::VT_TTL, Some(0)).unwrap() - } - #[inline] - pub fn tags(&self) -> Option>> { - self._tab.get::>>>(CacheSet::VT_TAGS, None) - } - #[inline] - pub fn meta(&self) -> Option<&'a str> { - self._tab.get::>(CacheSet::VT_META, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheSet::VT_KEY, None) + } + #[inline] + pub fn ttl(&self) -> u32 { + self._tab.get::(CacheSet::VT_TTL, Some(0)).unwrap() + } + #[inline] + pub fn tags(&self) -> Option>> { + self._tab.get::>, + >>(CacheSet::VT_TAGS, None) + } + #[inline] + pub fn meta(&self) -> Option<&'a str> { + self._tab + .get::>(CacheSet::VT_META, None) + } } pub struct CacheSetArgs<'a> { - pub key: Option>, + pub key: Option>, pub ttl: u32, - pub tags: Option>>>, - pub meta: Option>, + pub tags: Option< + flatbuffers::WIPOffset>>, + >, + pub meta: Option>, } impl<'a> Default for CacheSetArgs<'a> { #[inline] @@ -2997,46 +3093,54 @@ impl<'a> Default for CacheSetArgs<'a> { } } pub struct CacheSetBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheSetBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheSet::VT_KEY, key); - } - #[inline] - pub fn add_ttl(&mut self, ttl: u32) { - self.fbb_.push_slot::(CacheSet::VT_TTL, ttl, 0); - } - #[inline] - pub fn add_tags(&mut self, tags: flatbuffers::WIPOffset>>) { - self.fbb_.push_slot_always::>(CacheSet::VT_TAGS, tags); - } - #[inline] - pub fn add_meta(&mut self, meta: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheSet::VT_META, meta); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheSetBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheSet::VT_KEY, key); + } + #[inline] + pub fn add_ttl(&mut self, ttl: u32) { + self.fbb_.push_slot::(CacheSet::VT_TTL, ttl, 0); + } + #[inline] + pub fn add_tags( + &mut self, + tags: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>, + >, + ) { + self.fbb_ + .push_slot_always::>(CacheSet::VT_TAGS, tags); + } + #[inline] + pub fn add_meta(&mut self, meta: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheSet::VT_META, meta); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheSetBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheSetReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheSetReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheSetReady<'a> { @@ -3052,25 +3156,24 @@ impl<'a> flatbuffers::Follow<'a> for CacheSetReady<'a> { impl<'a> CacheSetReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheSetReady { - _tab: table, - } + CacheSetReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheSetReadyArgs) -> flatbuffers::WIPOffset> { - let mut builder = CacheSetReadyBuilder::new(_fbb); - builder.add_id(args.id); - builder.finish() + args: &'args CacheSetReadyArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheSetReadyBuilder::new(_fbb); + builder.add_id(args.id); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(CacheSetReady::VT_ID, Some(0)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(CacheSetReady::VT_ID, Some(0)).unwrap() + } } pub struct CacheSetReadyArgs { @@ -3079,40 +3182,38 @@ pub struct CacheSetReadyArgs { impl<'a> Default for CacheSetReadyArgs { #[inline] fn default() -> Self { - CacheSetReadyArgs { - id: 0, - } + CacheSetReadyArgs { id: 0 } } } pub struct CacheSetReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheSetReadyBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(CacheSetReady::VT_ID, id, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheSetReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(CacheSetReady::VT_ID, id, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheSetReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheDelOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheDel<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheDel<'a> { @@ -3128,67 +3229,68 @@ impl<'a> flatbuffers::Follow<'a> for CacheDel<'a> { impl<'a> CacheDel<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheDel { - _tab: table, - } + CacheDel { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheDelArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheDelBuilder::new(_fbb); - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheDelArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheDelBuilder::new(_fbb); + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheDel::VT_KEY, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheDel::VT_KEY, None) + } } pub struct CacheDelArgs<'a> { - pub key: Option>, + pub key: Option>, } impl<'a> Default for CacheDelArgs<'a> { #[inline] fn default() -> Self { - CacheDelArgs { - key: None, - } + CacheDelArgs { key: None } } } pub struct CacheDelBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheDelBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheDel::VT_KEY, key); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheDelBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheDelBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheDel::VT_KEY, key); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheDelBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheDelBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheExpireOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheExpire<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheExpire<'a> { @@ -3204,79 +3306,79 @@ impl<'a> flatbuffers::Follow<'a> for CacheExpire<'a> { impl<'a> CacheExpire<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheExpire { - _tab: table, - } + CacheExpire { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheExpireArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheExpireBuilder::new(_fbb); - builder.add_ttl(args.ttl); - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheExpireArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheExpireBuilder::new(_fbb); + builder.add_ttl(args.ttl); + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; pub const VT_TTL: flatbuffers::VOffsetT = 6; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheExpire::VT_KEY, None) - } - #[inline] - pub fn ttl(&self) -> u32 { - self._tab.get::(CacheExpire::VT_TTL, Some(0)).unwrap() - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheExpire::VT_KEY, None) + } + #[inline] + pub fn ttl(&self) -> u32 { + self._tab.get::(CacheExpire::VT_TTL, Some(0)).unwrap() + } } pub struct CacheExpireArgs<'a> { - pub key: Option>, + pub key: Option>, pub ttl: u32, } impl<'a> Default for CacheExpireArgs<'a> { #[inline] fn default() -> Self { - CacheExpireArgs { - key: None, - ttl: 0, - } + CacheExpireArgs { key: None, ttl: 0 } } } pub struct CacheExpireBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheExpireBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheExpire::VT_KEY, key); - } - #[inline] - pub fn add_ttl(&mut self, ttl: u32) { - self.fbb_.push_slot::(CacheExpire::VT_TTL, ttl, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheExpireBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheExpireBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheExpire::VT_KEY, key); + } + #[inline] + pub fn add_ttl(&mut self, ttl: u32) { + self.fbb_.push_slot::(CacheExpire::VT_TTL, ttl, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheExpireBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheExpireBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheNotifyDelOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheNotifyDel<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheNotifyDel<'a> { @@ -3292,67 +3394,68 @@ impl<'a> flatbuffers::Follow<'a> for CacheNotifyDel<'a> { impl<'a> CacheNotifyDel<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheNotifyDel { - _tab: table, - } + CacheNotifyDel { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheNotifyDelArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheNotifyDelBuilder::new(_fbb); - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheNotifyDelArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheNotifyDelBuilder::new(_fbb); + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheNotifyDel::VT_KEY, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheNotifyDel::VT_KEY, None) + } } pub struct CacheNotifyDelArgs<'a> { - pub key: Option>, + pub key: Option>, } impl<'a> Default for CacheNotifyDelArgs<'a> { #[inline] fn default() -> Self { - CacheNotifyDelArgs { - key: None, - } + CacheNotifyDelArgs { key: None } } } pub struct CacheNotifyDelBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheNotifyDelBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheNotifyDel::VT_KEY, key); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheNotifyDelBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheNotifyDelBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheNotifyDel::VT_KEY, key); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheNotifyDelBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheNotifyDelBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheNotifyPurgeTagOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheNotifyPurgeTag<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheNotifyPurgeTag<'a> { @@ -3368,67 +3471,70 @@ impl<'a> flatbuffers::Follow<'a> for CacheNotifyPurgeTag<'a> { impl<'a> CacheNotifyPurgeTag<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheNotifyPurgeTag { - _tab: table, - } + CacheNotifyPurgeTag { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheNotifyPurgeTagArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheNotifyPurgeTagBuilder::new(_fbb); - if let Some(x) = args.tag { builder.add_tag(x); } - builder.finish() + args: &'args CacheNotifyPurgeTagArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheNotifyPurgeTagBuilder::new(_fbb); + if let Some(x) = args.tag { + builder.add_tag(x); + } + builder.finish() } pub const VT_TAG: flatbuffers::VOffsetT = 4; - #[inline] - pub fn tag(&self) -> Option<&'a str> { - self._tab.get::>(CacheNotifyPurgeTag::VT_TAG, None) - } + #[inline] + pub fn tag(&self) -> Option<&'a str> { + self._tab + .get::>(CacheNotifyPurgeTag::VT_TAG, None) + } } pub struct CacheNotifyPurgeTagArgs<'a> { - pub tag: Option>, + pub tag: Option>, } impl<'a> Default for CacheNotifyPurgeTagArgs<'a> { #[inline] fn default() -> Self { - CacheNotifyPurgeTagArgs { - tag: None, - } + CacheNotifyPurgeTagArgs { tag: None } } } pub struct CacheNotifyPurgeTagBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheNotifyPurgeTagBuilder<'a, 'b> { - #[inline] - pub fn add_tag(&mut self, tag: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheNotifyPurgeTag::VT_TAG, tag); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheNotifyPurgeTagBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheNotifyPurgeTagBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_tag(&mut self, tag: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheNotifyPurgeTag::VT_TAG, tag); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> CacheNotifyPurgeTagBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheNotifyPurgeTagBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheSetMetaOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheSetMeta<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheSetMeta<'a> { @@ -3444,36 +3550,41 @@ impl<'a> flatbuffers::Follow<'a> for CacheSetMeta<'a> { impl<'a> CacheSetMeta<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheSetMeta { - _tab: table, - } + CacheSetMeta { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheSetMetaArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheSetMetaBuilder::new(_fbb); - if let Some(x) = args.meta { builder.add_meta(x); } - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheSetMetaArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheSetMetaBuilder::new(_fbb); + if let Some(x) = args.meta { + builder.add_meta(x); + } + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; pub const VT_META: flatbuffers::VOffsetT = 6; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheSetMeta::VT_KEY, None) - } - #[inline] - pub fn meta(&self) -> Option<&'a str> { - self._tab.get::>(CacheSetMeta::VT_META, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheSetMeta::VT_KEY, None) + } + #[inline] + pub fn meta(&self) -> Option<&'a str> { + self._tab + .get::>(CacheSetMeta::VT_META, None) + } } pub struct CacheSetMetaArgs<'a> { - pub key: Option>, - pub meta: Option>, + pub key: Option>, + pub meta: Option>, } impl<'a> Default for CacheSetMetaArgs<'a> { #[inline] @@ -3485,38 +3596,40 @@ impl<'a> Default for CacheSetMetaArgs<'a> { } } pub struct CacheSetMetaBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheSetMetaBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheSetMeta::VT_KEY, key); - } - #[inline] - pub fn add_meta(&mut self, meta: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheSetMeta::VT_META, meta); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetMetaBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheSetMetaBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheSetMeta::VT_KEY, key); + } + #[inline] + pub fn add_meta(&mut self, meta: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheSetMeta::VT_META, meta); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetMetaBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheSetMetaBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CacheSetTagsOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CacheSetTags<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CacheSetTags<'a> { @@ -3532,36 +3645,44 @@ impl<'a> flatbuffers::Follow<'a> for CacheSetTags<'a> { impl<'a> CacheSetTags<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CacheSetTags { - _tab: table, - } + CacheSetTags { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CacheSetTagsArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CacheSetTagsBuilder::new(_fbb); - if let Some(x) = args.tags { builder.add_tags(x); } - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args CacheSetTagsArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CacheSetTagsBuilder::new(_fbb); + if let Some(x) = args.tags { + builder.add_tags(x); + } + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; pub const VT_TAGS: flatbuffers::VOffsetT = 6; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(CacheSetTags::VT_KEY, None) - } - #[inline] - pub fn tags(&self) -> Option>> { - self._tab.get::>>>(CacheSetTags::VT_TAGS, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(CacheSetTags::VT_KEY, None) + } + #[inline] + pub fn tags(&self) -> Option>> { + self._tab.get::>, + >>(CacheSetTags::VT_TAGS, None) + } } pub struct CacheSetTagsArgs<'a> { - pub key: Option>, - pub tags: Option>>>, + pub key: Option>, + pub tags: Option< + flatbuffers::WIPOffset>>, + >, } impl<'a> Default for CacheSetTagsArgs<'a> { #[inline] @@ -3573,38 +3694,45 @@ impl<'a> Default for CacheSetTagsArgs<'a> { } } pub struct CacheSetTagsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CacheSetTagsBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CacheSetTags::VT_KEY, key); - } - #[inline] - pub fn add_tags(&mut self, tags: flatbuffers::WIPOffset>>) { - self.fbb_.push_slot_always::>(CacheSetTags::VT_TAGS, tags); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetTagsBuilder<'a, 'b> { - let start = _fbb.start_table(); - CacheSetTagsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CacheSetTags::VT_KEY, key); + } + #[inline] + pub fn add_tags( + &mut self, + tags: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset<&'b str>>, + >, + ) { + self.fbb_ + .push_slot_always::>(CacheSetTags::VT_TAGS, tags); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CacheSetTagsBuilder<'a, 'b> { + let start = _fbb.start_table(); + CacheSetTagsBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CachePurgeTagOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CachePurgeTag<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CachePurgeTag<'a> { @@ -3620,67 +3748,68 @@ impl<'a> flatbuffers::Follow<'a> for CachePurgeTag<'a> { impl<'a> CachePurgeTag<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CachePurgeTag { - _tab: table, - } + CachePurgeTag { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CachePurgeTagArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CachePurgeTagBuilder::new(_fbb); - if let Some(x) = args.tag { builder.add_tag(x); } - builder.finish() + args: &'args CachePurgeTagArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CachePurgeTagBuilder::new(_fbb); + if let Some(x) = args.tag { + builder.add_tag(x); + } + builder.finish() } pub const VT_TAG: flatbuffers::VOffsetT = 4; - #[inline] - pub fn tag(&self) -> Option<&'a str> { - self._tab.get::>(CachePurgeTag::VT_TAG, None) - } + #[inline] + pub fn tag(&self) -> Option<&'a str> { + self._tab + .get::>(CachePurgeTag::VT_TAG, None) + } } pub struct CachePurgeTagArgs<'a> { - pub tag: Option>, + pub tag: Option>, } impl<'a> Default for CachePurgeTagArgs<'a> { #[inline] fn default() -> Self { - CachePurgeTagArgs { - tag: None, - } + CachePurgeTagArgs { tag: None } } } pub struct CachePurgeTagBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CachePurgeTagBuilder<'a, 'b> { - #[inline] - pub fn add_tag(&mut self, tag: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CachePurgeTag::VT_TAG, tag); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CachePurgeTagBuilder<'a, 'b> { - let start = _fbb.start_table(); - CachePurgeTagBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_tag(&mut self, tag: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CachePurgeTag::VT_TAG, tag); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CachePurgeTagBuilder<'a, 'b> { + let start = _fbb.start_table(); + CachePurgeTagBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DataPutOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DataPut<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DataPut<'a> { @@ -3696,43 +3825,51 @@ impl<'a> flatbuffers::Follow<'a> for DataPut<'a> { impl<'a> DataPut<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DataPut { - _tab: table, - } + DataPut { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DataPutArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DataPutBuilder::new(_fbb); - if let Some(x) = args.json { builder.add_json(x); } - if let Some(x) = args.key { builder.add_key(x); } - if let Some(x) = args.collection { builder.add_collection(x); } - builder.finish() + args: &'args DataPutArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DataPutBuilder::new(_fbb); + if let Some(x) = args.json { + builder.add_json(x); + } + if let Some(x) = args.key { + builder.add_key(x); + } + if let Some(x) = args.collection { + builder.add_collection(x); + } + builder.finish() } pub const VT_COLLECTION: flatbuffers::VOffsetT = 4; pub const VT_KEY: flatbuffers::VOffsetT = 6; pub const VT_JSON: flatbuffers::VOffsetT = 8; - #[inline] - pub fn collection(&self) -> Option<&'a str> { - self._tab.get::>(DataPut::VT_COLLECTION, None) - } - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(DataPut::VT_KEY, None) - } - #[inline] - pub fn json(&self) -> Option<&'a str> { - self._tab.get::>(DataPut::VT_JSON, None) - } + #[inline] + pub fn collection(&self) -> Option<&'a str> { + self._tab + .get::>(DataPut::VT_COLLECTION, None) + } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(DataPut::VT_KEY, None) + } + #[inline] + pub fn json(&self) -> Option<&'a str> { + self._tab + .get::>(DataPut::VT_JSON, None) + } } pub struct DataPutArgs<'a> { - pub collection: Option>, - pub key: Option>, - pub json: Option>, + pub collection: Option>, + pub key: Option>, + pub json: Option>, } impl<'a> Default for DataPutArgs<'a> { #[inline] @@ -3745,42 +3882,45 @@ impl<'a> Default for DataPutArgs<'a> { } } pub struct DataPutBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DataPutBuilder<'a, 'b> { - #[inline] - pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataPut::VT_COLLECTION, collection); - } - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataPut::VT_KEY, key); - } - #[inline] - pub fn add_json(&mut self, json: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataPut::VT_JSON, json); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataPutBuilder<'a, 'b> { - let start = _fbb.start_table(); - DataPutBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataPut::VT_COLLECTION, collection); + } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataPut::VT_KEY, key); + } + #[inline] + pub fn add_json(&mut self, json: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataPut::VT_JSON, json); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataPutBuilder<'a, 'b> { + let start = _fbb.start_table(); + DataPutBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DataGetOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DataGet<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DataGet<'a> { @@ -3796,36 +3936,41 @@ impl<'a> flatbuffers::Follow<'a> for DataGet<'a> { impl<'a> DataGet<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DataGet { - _tab: table, - } + DataGet { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DataGetArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DataGetBuilder::new(_fbb); - if let Some(x) = args.key { builder.add_key(x); } - if let Some(x) = args.collection { builder.add_collection(x); } - builder.finish() + args: &'args DataGetArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DataGetBuilder::new(_fbb); + if let Some(x) = args.key { + builder.add_key(x); + } + if let Some(x) = args.collection { + builder.add_collection(x); + } + builder.finish() } pub const VT_COLLECTION: flatbuffers::VOffsetT = 4; pub const VT_KEY: flatbuffers::VOffsetT = 6; - #[inline] - pub fn collection(&self) -> Option<&'a str> { - self._tab.get::>(DataGet::VT_COLLECTION, None) - } - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(DataGet::VT_KEY, None) - } + #[inline] + pub fn collection(&self) -> Option<&'a str> { + self._tab + .get::>(DataGet::VT_COLLECTION, None) + } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(DataGet::VT_KEY, None) + } } pub struct DataGetArgs<'a> { - pub collection: Option>, - pub key: Option>, + pub collection: Option>, + pub key: Option>, } impl<'a> Default for DataGetArgs<'a> { #[inline] @@ -3837,38 +3982,40 @@ impl<'a> Default for DataGetArgs<'a> { } } pub struct DataGetBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DataGetBuilder<'a, 'b> { - #[inline] - pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataGet::VT_COLLECTION, collection); - } - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataGet::VT_KEY, key); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataGetBuilder<'a, 'b> { - let start = _fbb.start_table(); - DataGetBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataGet::VT_COLLECTION, collection); + } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataGet::VT_KEY, key); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataGetBuilder<'a, 'b> { + let start = _fbb.start_table(); + DataGetBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DataGetReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DataGetReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DataGetReady<'a> { @@ -3884,67 +4031,68 @@ impl<'a> flatbuffers::Follow<'a> for DataGetReady<'a> { impl<'a> DataGetReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DataGetReady { - _tab: table, - } + DataGetReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DataGetReadyArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DataGetReadyBuilder::new(_fbb); - if let Some(x) = args.json { builder.add_json(x); } - builder.finish() + args: &'args DataGetReadyArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DataGetReadyBuilder::new(_fbb); + if let Some(x) = args.json { + builder.add_json(x); + } + builder.finish() } pub const VT_JSON: flatbuffers::VOffsetT = 4; - #[inline] - pub fn json(&self) -> Option<&'a str> { - self._tab.get::>(DataGetReady::VT_JSON, None) - } + #[inline] + pub fn json(&self) -> Option<&'a str> { + self._tab + .get::>(DataGetReady::VT_JSON, None) + } } pub struct DataGetReadyArgs<'a> { - pub json: Option>, + pub json: Option>, } impl<'a> Default for DataGetReadyArgs<'a> { #[inline] fn default() -> Self { - DataGetReadyArgs { - json: None, - } + DataGetReadyArgs { json: None } } } pub struct DataGetReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DataGetReadyBuilder<'a, 'b> { - #[inline] - pub fn add_json(&mut self, json: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataGetReady::VT_JSON, json); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataGetReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - DataGetReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_json(&mut self, json: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataGetReady::VT_JSON, json); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataGetReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + DataGetReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DataDelOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DataDel<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DataDel<'a> { @@ -3960,36 +4108,41 @@ impl<'a> flatbuffers::Follow<'a> for DataDel<'a> { impl<'a> DataDel<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DataDel { - _tab: table, - } + DataDel { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DataDelArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DataDelBuilder::new(_fbb); - if let Some(x) = args.key { builder.add_key(x); } - if let Some(x) = args.collection { builder.add_collection(x); } - builder.finish() + args: &'args DataDelArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DataDelBuilder::new(_fbb); + if let Some(x) = args.key { + builder.add_key(x); + } + if let Some(x) = args.collection { + builder.add_collection(x); + } + builder.finish() } pub const VT_COLLECTION: flatbuffers::VOffsetT = 4; pub const VT_KEY: flatbuffers::VOffsetT = 6; - #[inline] - pub fn collection(&self) -> Option<&'a str> { - self._tab.get::>(DataDel::VT_COLLECTION, None) - } - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(DataDel::VT_KEY, None) - } + #[inline] + pub fn collection(&self) -> Option<&'a str> { + self._tab + .get::>(DataDel::VT_COLLECTION, None) + } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(DataDel::VT_KEY, None) + } } pub struct DataDelArgs<'a> { - pub collection: Option>, - pub key: Option>, + pub collection: Option>, + pub key: Option>, } impl<'a> Default for DataDelArgs<'a> { #[inline] @@ -4001,38 +4154,40 @@ impl<'a> Default for DataDelArgs<'a> { } } pub struct DataDelBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DataDelBuilder<'a, 'b> { - #[inline] - pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataDel::VT_COLLECTION, collection); - } - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataDel::VT_KEY, key); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataDelBuilder<'a, 'b> { - let start = _fbb.start_table(); - DataDelBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataDel::VT_COLLECTION, collection); + } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataDel::VT_KEY, key); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataDelBuilder<'a, 'b> { + let start = _fbb.start_table(); + DataDelBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DataDropCollectionOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DataDropCollection<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DataDropCollection<'a> { @@ -4048,67 +4203,72 @@ impl<'a> flatbuffers::Follow<'a> for DataDropCollection<'a> { impl<'a> DataDropCollection<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DataDropCollection { - _tab: table, - } + DataDropCollection { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DataDropCollectionArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DataDropCollectionBuilder::new(_fbb); - if let Some(x) = args.collection { builder.add_collection(x); } - builder.finish() + args: &'args DataDropCollectionArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DataDropCollectionBuilder::new(_fbb); + if let Some(x) = args.collection { + builder.add_collection(x); + } + builder.finish() } pub const VT_COLLECTION: flatbuffers::VOffsetT = 4; - #[inline] - pub fn collection(&self) -> Option<&'a str> { - self._tab.get::>(DataDropCollection::VT_COLLECTION, None) - } + #[inline] + pub fn collection(&self) -> Option<&'a str> { + self._tab + .get::>(DataDropCollection::VT_COLLECTION, None) + } } pub struct DataDropCollectionArgs<'a> { - pub collection: Option>, + pub collection: Option>, } impl<'a> Default for DataDropCollectionArgs<'a> { #[inline] fn default() -> Self { - DataDropCollectionArgs { - collection: None, - } + DataDropCollectionArgs { collection: None } } } pub struct DataDropCollectionBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DataDropCollectionBuilder<'a, 'b> { - #[inline] - pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataDropCollection::VT_COLLECTION, collection); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataDropCollectionBuilder<'a, 'b> { - let start = _fbb.start_table(); - DataDropCollectionBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + DataDropCollection::VT_COLLECTION, + collection, + ); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> DataDropCollectionBuilder<'a, 'b> { + let start = _fbb.start_table(); + DataDropCollectionBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum DataIncrOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct DataIncr<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for DataIncr<'a> { @@ -4124,20 +4284,25 @@ impl<'a> flatbuffers::Follow<'a> for DataIncr<'a> { impl<'a> DataIncr<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - DataIncr { - _tab: table, - } + DataIncr { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args DataIncrArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = DataIncrBuilder::new(_fbb); - builder.add_amount(args.amount); - if let Some(x) = args.field { builder.add_field(x); } - if let Some(x) = args.key { builder.add_key(x); } - if let Some(x) = args.collection { builder.add_collection(x); } - builder.finish() + args: &'args DataIncrArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = DataIncrBuilder::new(_fbb); + builder.add_amount(args.amount); + if let Some(x) = args.field { + builder.add_field(x); + } + if let Some(x) = args.key { + builder.add_key(x); + } + if let Some(x) = args.collection { + builder.add_collection(x); + } + builder.finish() } pub const VT_COLLECTION: flatbuffers::VOffsetT = 4; @@ -4145,28 +4310,31 @@ impl<'a> DataIncr<'a> { pub const VT_FIELD: flatbuffers::VOffsetT = 8; pub const VT_AMOUNT: flatbuffers::VOffsetT = 10; - #[inline] - pub fn collection(&self) -> Option<&'a str> { - self._tab.get::>(DataIncr::VT_COLLECTION, None) - } - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(DataIncr::VT_KEY, None) - } - #[inline] - pub fn field(&self) -> Option<&'a str> { - self._tab.get::>(DataIncr::VT_FIELD, None) - } - #[inline] - pub fn amount(&self) -> i32 { - self._tab.get::(DataIncr::VT_AMOUNT, Some(0)).unwrap() - } + #[inline] + pub fn collection(&self) -> Option<&'a str> { + self._tab + .get::>(DataIncr::VT_COLLECTION, None) + } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(DataIncr::VT_KEY, None) + } + #[inline] + pub fn field(&self) -> Option<&'a str> { + self._tab + .get::>(DataIncr::VT_FIELD, None) + } + #[inline] + pub fn amount(&self) -> i32 { + self._tab.get::(DataIncr::VT_AMOUNT, Some(0)).unwrap() + } } pub struct DataIncrArgs<'a> { - pub collection: Option>, - pub key: Option>, - pub field: Option>, + pub collection: Option>, + pub key: Option>, + pub field: Option>, pub amount: i32, } impl<'a> Default for DataIncrArgs<'a> { @@ -4181,46 +4349,49 @@ impl<'a> Default for DataIncrArgs<'a> { } } pub struct DataIncrBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> DataIncrBuilder<'a, 'b> { - #[inline] - pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataIncr::VT_COLLECTION, collection); - } - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataIncr::VT_KEY, key); - } - #[inline] - pub fn add_field(&mut self, field: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(DataIncr::VT_FIELD, field); - } - #[inline] - pub fn add_amount(&mut self, amount: i32) { - self.fbb_.push_slot::(DataIncr::VT_AMOUNT, amount, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataIncrBuilder<'a, 'b> { - let start = _fbb.start_table(); - DataIncrBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_collection(&mut self, collection: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataIncr::VT_COLLECTION, collection); + } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataIncr::VT_KEY, key); + } + #[inline] + pub fn add_field(&mut self, field: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(DataIncr::VT_FIELD, field); + } + #[inline] + pub fn add_amount(&mut self, amount: i32) { + self.fbb_.push_slot::(DataIncr::VT_AMOUNT, amount, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DataIncrBuilder<'a, 'b> { + let start = _fbb.start_table(); + DataIncrBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum ImageWebPEncodeOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct ImageWebPEncode<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for ImageWebPEncode<'a> { @@ -4236,20 +4407,19 @@ impl<'a> flatbuffers::Follow<'a> for ImageWebPEncode<'a> { impl<'a> ImageWebPEncode<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ImageWebPEncode { - _tab: table, - } + ImageWebPEncode { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ImageWebPEncodeArgs) -> flatbuffers::WIPOffset> { - let mut builder = ImageWebPEncodeBuilder::new(_fbb); - builder.add_alpha_quality(args.alpha_quality); - builder.add_quality(args.quality); - builder.add_near_lossless(args.near_lossless); - builder.add_lossless(args.lossless); - builder.finish() + args: &'args ImageWebPEncodeArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = ImageWebPEncodeBuilder::new(_fbb); + builder.add_alpha_quality(args.alpha_quality); + builder.add_quality(args.quality); + builder.add_near_lossless(args.near_lossless); + builder.add_lossless(args.lossless); + builder.finish() } pub const VT_QUALITY: flatbuffers::VOffsetT = 4; @@ -4257,22 +4427,30 @@ impl<'a> ImageWebPEncode<'a> { pub const VT_LOSSLESS: flatbuffers::VOffsetT = 8; pub const VT_NEAR_LOSSLESS: flatbuffers::VOffsetT = 10; - #[inline] - pub fn quality(&self) -> f32 { - self._tab.get::(ImageWebPEncode::VT_QUALITY, Some(0.0)).unwrap() - } - #[inline] - pub fn alpha_quality(&self) -> f32 { - self._tab.get::(ImageWebPEncode::VT_ALPHA_QUALITY, Some(0.0)).unwrap() - } - #[inline] - pub fn lossless(&self) -> bool { - self._tab.get::(ImageWebPEncode::VT_LOSSLESS, Some(false)).unwrap() - } - #[inline] - pub fn near_lossless(&self) -> bool { - self._tab.get::(ImageWebPEncode::VT_NEAR_LOSSLESS, Some(false)).unwrap() - } + #[inline] + pub fn quality(&self) -> f32 { + self._tab + .get::(ImageWebPEncode::VT_QUALITY, Some(0.0)) + .unwrap() + } + #[inline] + pub fn alpha_quality(&self) -> f32 { + self._tab + .get::(ImageWebPEncode::VT_ALPHA_QUALITY, Some(0.0)) + .unwrap() + } + #[inline] + pub fn lossless(&self) -> bool { + self._tab + .get::(ImageWebPEncode::VT_LOSSLESS, Some(false)) + .unwrap() + } + #[inline] + pub fn near_lossless(&self) -> bool { + self._tab + .get::(ImageWebPEncode::VT_NEAR_LOSSLESS, Some(false)) + .unwrap() + } } pub struct ImageWebPEncodeArgs { @@ -4293,46 +4471,50 @@ impl<'a> Default for ImageWebPEncodeArgs { } } pub struct ImageWebPEncodeBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> ImageWebPEncodeBuilder<'a, 'b> { - #[inline] - pub fn add_quality(&mut self, quality: f32) { - self.fbb_.push_slot::(ImageWebPEncode::VT_QUALITY, quality, 0.0); - } - #[inline] - pub fn add_alpha_quality(&mut self, alpha_quality: f32) { - self.fbb_.push_slot::(ImageWebPEncode::VT_ALPHA_QUALITY, alpha_quality, 0.0); - } - #[inline] - pub fn add_lossless(&mut self, lossless: bool) { - self.fbb_.push_slot::(ImageWebPEncode::VT_LOSSLESS, lossless, false); - } - #[inline] - pub fn add_near_lossless(&mut self, near_lossless: bool) { - self.fbb_.push_slot::(ImageWebPEncode::VT_NEAR_LOSSLESS, near_lossless, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageWebPEncodeBuilder<'a, 'b> { - let start = _fbb.start_table(); - ImageWebPEncodeBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_quality(&mut self, quality: f32) { + self.fbb_ + .push_slot::(ImageWebPEncode::VT_QUALITY, quality, 0.0); + } + #[inline] + pub fn add_alpha_quality(&mut self, alpha_quality: f32) { + self.fbb_ + .push_slot::(ImageWebPEncode::VT_ALPHA_QUALITY, alpha_quality, 0.0); + } + #[inline] + pub fn add_lossless(&mut self, lossless: bool) { + self.fbb_ + .push_slot::(ImageWebPEncode::VT_LOSSLESS, lossless, false); + } + #[inline] + pub fn add_near_lossless(&mut self, near_lossless: bool) { + self.fbb_ + .push_slot::(ImageWebPEncode::VT_NEAR_LOSSLESS, near_lossless, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageWebPEncodeBuilder<'a, 'b> { + let start = _fbb.start_table(); + ImageWebPEncodeBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum ImageResizeOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct ImageResize<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for ImageResize<'a> { @@ -4348,37 +4530,42 @@ impl<'a> flatbuffers::Follow<'a> for ImageResize<'a> { impl<'a> ImageResize<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ImageResize { - _tab: table, - } + ImageResize { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ImageResizeArgs) -> flatbuffers::WIPOffset> { - let mut builder = ImageResizeBuilder::new(_fbb); - builder.add_height(args.height); - builder.add_width(args.width); - builder.add_filter(args.filter); - builder.finish() + args: &'args ImageResizeArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = ImageResizeBuilder::new(_fbb); + builder.add_height(args.height); + builder.add_width(args.width); + builder.add_filter(args.filter); + builder.finish() } pub const VT_WIDTH: flatbuffers::VOffsetT = 4; pub const VT_HEIGHT: flatbuffers::VOffsetT = 6; pub const VT_FILTER: flatbuffers::VOffsetT = 8; - #[inline] - pub fn width(&self) -> u32 { - self._tab.get::(ImageResize::VT_WIDTH, Some(0)).unwrap() - } - #[inline] - pub fn height(&self) -> u32 { - self._tab.get::(ImageResize::VT_HEIGHT, Some(0)).unwrap() - } - #[inline] - pub fn filter(&self) -> ImageSamplingFilter { - self._tab.get::(ImageResize::VT_FILTER, Some(ImageSamplingFilter::Nearest)).unwrap() - } + #[inline] + pub fn width(&self) -> u32 { + self._tab + .get::(ImageResize::VT_WIDTH, Some(0)) + .unwrap() + } + #[inline] + pub fn height(&self) -> u32 { + self._tab + .get::(ImageResize::VT_HEIGHT, Some(0)) + .unwrap() + } + #[inline] + pub fn filter(&self) -> ImageSamplingFilter { + self._tab + .get::(ImageResize::VT_FILTER, Some(ImageSamplingFilter::Nearest)) + .unwrap() + } } pub struct ImageResizeArgs { @@ -4397,42 +4584,47 @@ impl<'a> Default for ImageResizeArgs { } } pub struct ImageResizeBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> ImageResizeBuilder<'a, 'b> { - #[inline] - pub fn add_width(&mut self, width: u32) { - self.fbb_.push_slot::(ImageResize::VT_WIDTH, width, 0); - } - #[inline] - pub fn add_height(&mut self, height: u32) { - self.fbb_.push_slot::(ImageResize::VT_HEIGHT, height, 0); - } - #[inline] - pub fn add_filter(&mut self, filter: ImageSamplingFilter) { - self.fbb_.push_slot::(ImageResize::VT_FILTER, filter, ImageSamplingFilter::Nearest); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageResizeBuilder<'a, 'b> { - let start = _fbb.start_table(); - ImageResizeBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_width(&mut self, width: u32) { + self.fbb_.push_slot::(ImageResize::VT_WIDTH, width, 0); + } + #[inline] + pub fn add_height(&mut self, height: u32) { + self.fbb_ + .push_slot::(ImageResize::VT_HEIGHT, height, 0); + } + #[inline] + pub fn add_filter(&mut self, filter: ImageSamplingFilter) { + self.fbb_.push_slot::( + ImageResize::VT_FILTER, + filter, + ImageSamplingFilter::Nearest, + ); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageResizeBuilder<'a, 'b> { + let start = _fbb.start_table(); + ImageResizeBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum ImageTransformOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct ImageTransform<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for ImageTransform<'a> { @@ -4448,67 +4640,81 @@ impl<'a> flatbuffers::Follow<'a> for ImageTransform<'a> { impl<'a> ImageTransform<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ImageTransform { - _tab: table, - } + ImageTransform { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ImageTransformArgs) -> flatbuffers::WIPOffset> { - let mut builder = ImageTransformBuilder::new(_fbb); - if let Some(x) = args.options { builder.add_options(x); } - builder.add_options_type(args.options_type); - builder.add_transform(args.transform); - builder.finish() + args: &'args ImageTransformArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = ImageTransformBuilder::new(_fbb); + if let Some(x) = args.options { + builder.add_options(x); + } + builder.add_options_type(args.options_type); + builder.add_transform(args.transform); + builder.finish() } pub const VT_TRANSFORM: flatbuffers::VOffsetT = 4; pub const VT_OPTIONS_TYPE: flatbuffers::VOffsetT = 6; pub const VT_OPTIONS: flatbuffers::VOffsetT = 8; - #[inline] - pub fn transform(&self) -> ImageTransformType { - self._tab.get::(ImageTransform::VT_TRANSFORM, Some(ImageTransformType::WebPEncode)).unwrap() - } - #[inline] - pub fn options_type(&self) -> ImageTransformOptions { - self._tab.get::(ImageTransform::VT_OPTIONS_TYPE, Some(ImageTransformOptions::NONE)).unwrap() - } - #[inline] - pub fn options(&self) -> Option> { - self._tab.get::>>(ImageTransform::VT_OPTIONS, None) - } - #[inline] - #[allow(non_snake_case)] - pub fn options_as_image_web_pencode(&'a self) -> Option { - if self.options_type() == ImageTransformOptions::ImageWebPEncode { - self.options().map(|u| ImageWebPEncode::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn options_as_image_resize(&'a self) -> Option { - if self.options_type() == ImageTransformOptions::ImageResize { - self.options().map(|u| ImageResize::init_from_table(u)) - } else { - None - } - } - -} - -pub struct ImageTransformArgs { - pub transform: ImageTransformType, - pub options_type: ImageTransformOptions, - pub options: Option>, -} -impl<'a> Default for ImageTransformArgs { #[inline] - fn default() -> Self { + pub fn transform(&self) -> ImageTransformType { + self._tab + .get::( + ImageTransform::VT_TRANSFORM, + Some(ImageTransformType::WebPEncode), + ) + .unwrap() + } + #[inline] + pub fn options_type(&self) -> ImageTransformOptions { + self._tab + .get::( + ImageTransform::VT_OPTIONS_TYPE, + Some(ImageTransformOptions::NONE), + ) + .unwrap() + } + #[inline] + pub fn options(&self) -> Option> { + self._tab + .get::>>( + ImageTransform::VT_OPTIONS, + None, + ) + } + #[inline] + #[allow(non_snake_case)] + pub fn options_as_image_web_pencode(&'a self) -> Option { + if self.options_type() == ImageTransformOptions::ImageWebPEncode { + self.options().map(|u| ImageWebPEncode::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn options_as_image_resize(&'a self) -> Option { + if self.options_type() == ImageTransformOptions::ImageResize { + self.options().map(|u| ImageResize::init_from_table(u)) + } else { + None + } + } +} + +pub struct ImageTransformArgs { + pub transform: ImageTransformType, + pub options_type: ImageTransformOptions, + pub options: Option>, +} +impl<'a> Default for ImageTransformArgs { + #[inline] + fn default() -> Self { ImageTransformArgs { transform: ImageTransformType::WebPEncode, options_type: ImageTransformOptions::NONE, @@ -4517,42 +4723,51 @@ impl<'a> Default for ImageTransformArgs { } } pub struct ImageTransformBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> ImageTransformBuilder<'a, 'b> { - #[inline] - pub fn add_transform(&mut self, transform: ImageTransformType) { - self.fbb_.push_slot::(ImageTransform::VT_TRANSFORM, transform, ImageTransformType::WebPEncode); - } - #[inline] - pub fn add_options_type(&mut self, options_type: ImageTransformOptions) { - self.fbb_.push_slot::(ImageTransform::VT_OPTIONS_TYPE, options_type, ImageTransformOptions::NONE); - } - #[inline] - pub fn add_options(&mut self, options: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(ImageTransform::VT_OPTIONS, options); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageTransformBuilder<'a, 'b> { - let start = _fbb.start_table(); - ImageTransformBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_transform(&mut self, transform: ImageTransformType) { + self.fbb_.push_slot::( + ImageTransform::VT_TRANSFORM, + transform, + ImageTransformType::WebPEncode, + ); + } + #[inline] + pub fn add_options_type(&mut self, options_type: ImageTransformOptions) { + self.fbb_.push_slot::( + ImageTransform::VT_OPTIONS_TYPE, + options_type, + ImageTransformOptions::NONE, + ); + } + #[inline] + pub fn add_options(&mut self, options: flatbuffers::WIPOffset) { + self.fbb_ + .push_slot_always::>(ImageTransform::VT_OPTIONS, options); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageTransformBuilder<'a, 'b> { + let start = _fbb.start_table(); + ImageTransformBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum ImageApplyTransformsOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct ImageApplyTransforms<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for ImageApplyTransforms<'a> { @@ -4568,67 +4783,84 @@ impl<'a> flatbuffers::Follow<'a> for ImageApplyTransforms<'a> { impl<'a> ImageApplyTransforms<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ImageApplyTransforms { - _tab: table, - } + ImageApplyTransforms { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ImageApplyTransformsArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = ImageApplyTransformsBuilder::new(_fbb); - if let Some(x) = args.transforms { builder.add_transforms(x); } - builder.finish() + args: &'args ImageApplyTransformsArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = ImageApplyTransformsBuilder::new(_fbb); + if let Some(x) = args.transforms { + builder.add_transforms(x); + } + builder.finish() } pub const VT_TRANSFORMS: flatbuffers::VOffsetT = 4; - #[inline] - pub fn transforms(&self) -> Option>>> { - self._tab.get::>>>>(ImageApplyTransforms::VT_TRANSFORMS, None) - } + #[inline] + pub fn transforms( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(ImageApplyTransforms::VT_TRANSFORMS, None) + } } pub struct ImageApplyTransformsArgs<'a> { - pub transforms: Option>>>>, + pub transforms: Option< + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + >, + >, } impl<'a> Default for ImageApplyTransformsArgs<'a> { #[inline] fn default() -> Self { - ImageApplyTransformsArgs { - transforms: None, - } + ImageApplyTransformsArgs { transforms: None } } } pub struct ImageApplyTransformsBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> ImageApplyTransformsBuilder<'a, 'b> { - #[inline] - pub fn add_transforms(&mut self, transforms: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(ImageApplyTransforms::VT_TRANSFORMS, transforms); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageApplyTransformsBuilder<'a, 'b> { - let start = _fbb.start_table(); - ImageApplyTransformsBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_transforms( + &mut self, + transforms: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_.push_slot_always::>( + ImageApplyTransforms::VT_TRANSFORMS, + transforms, + ); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> ImageApplyTransformsBuilder<'a, 'b> { + let start = _fbb.start_table(); + ImageApplyTransformsBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum ImageReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct ImageReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for ImageReady<'a> { @@ -4644,31 +4876,32 @@ impl<'a> flatbuffers::Follow<'a> for ImageReady<'a> { impl<'a> ImageReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - ImageReady { - _tab: table, - } + ImageReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args ImageReadyArgs) -> flatbuffers::WIPOffset> { - let mut builder = ImageReadyBuilder::new(_fbb); - builder.add_out_id(args.out_id); - builder.add_in_id(args.in_id); - builder.finish() + args: &'args ImageReadyArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = ImageReadyBuilder::new(_fbb); + builder.add_out_id(args.out_id); + builder.add_in_id(args.in_id); + builder.finish() } pub const VT_IN_ID: flatbuffers::VOffsetT = 4; pub const VT_OUT_ID: flatbuffers::VOffsetT = 6; - #[inline] - pub fn in_id(&self) -> u32 { - self._tab.get::(ImageReady::VT_IN_ID, Some(0)).unwrap() - } - #[inline] - pub fn out_id(&self) -> u32 { - self._tab.get::(ImageReady::VT_OUT_ID, Some(0)).unwrap() - } + #[inline] + pub fn in_id(&self) -> u32 { + self._tab.get::(ImageReady::VT_IN_ID, Some(0)).unwrap() + } + #[inline] + pub fn out_id(&self) -> u32 { + self._tab + .get::(ImageReady::VT_OUT_ID, Some(0)) + .unwrap() + } } pub struct ImageReadyArgs { @@ -4685,38 +4918,38 @@ impl<'a> Default for ImageReadyArgs { } } pub struct ImageReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> ImageReadyBuilder<'a, 'b> { - #[inline] - pub fn add_in_id(&mut self, in_id: u32) { - self.fbb_.push_slot::(ImageReady::VT_IN_ID, in_id, 0); - } - #[inline] - pub fn add_out_id(&mut self, out_id: u32) { - self.fbb_.push_slot::(ImageReady::VT_OUT_ID, out_id, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - ImageReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_in_id(&mut self, in_id: u32) { + self.fbb_.push_slot::(ImageReady::VT_IN_ID, in_id, 0); + } + #[inline] + pub fn add_out_id(&mut self, out_id: u32) { + self.fbb_.push_slot::(ImageReady::VT_OUT_ID, out_id, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ImageReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + ImageReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum AcmeGetChallengeOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct AcmeGetChallenge<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for AcmeGetChallenge<'a> { @@ -4732,36 +4965,41 @@ impl<'a> flatbuffers::Follow<'a> for AcmeGetChallenge<'a> { impl<'a> AcmeGetChallenge<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - AcmeGetChallenge { - _tab: table, - } + AcmeGetChallenge { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args AcmeGetChallengeArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = AcmeGetChallengeBuilder::new(_fbb); - if let Some(x) = args.token { builder.add_token(x); } - if let Some(x) = args.hostname { builder.add_hostname(x); } - builder.finish() + args: &'args AcmeGetChallengeArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = AcmeGetChallengeBuilder::new(_fbb); + if let Some(x) = args.token { + builder.add_token(x); + } + if let Some(x) = args.hostname { + builder.add_hostname(x); + } + builder.finish() } pub const VT_HOSTNAME: flatbuffers::VOffsetT = 4; pub const VT_TOKEN: flatbuffers::VOffsetT = 6; - #[inline] - pub fn hostname(&self) -> Option<&'a str> { - self._tab.get::>(AcmeGetChallenge::VT_HOSTNAME, None) - } - #[inline] - pub fn token(&self) -> Option<&'a str> { - self._tab.get::>(AcmeGetChallenge::VT_TOKEN, None) - } + #[inline] + pub fn hostname(&self) -> Option<&'a str> { + self._tab + .get::>(AcmeGetChallenge::VT_HOSTNAME, None) + } + #[inline] + pub fn token(&self) -> Option<&'a str> { + self._tab + .get::>(AcmeGetChallenge::VT_TOKEN, None) + } } pub struct AcmeGetChallengeArgs<'a> { - pub hostname: Option>, - pub token: Option>, + pub hostname: Option>, + pub token: Option>, } impl<'a> Default for AcmeGetChallengeArgs<'a> { #[inline] @@ -4773,38 +5011,42 @@ impl<'a> Default for AcmeGetChallengeArgs<'a> { } } pub struct AcmeGetChallengeBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> AcmeGetChallengeBuilder<'a, 'b> { - #[inline] - pub fn add_hostname(&mut self, hostname: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(AcmeGetChallenge::VT_HOSTNAME, hostname); - } - #[inline] - pub fn add_token(&mut self, token: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(AcmeGetChallenge::VT_TOKEN, token); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AcmeGetChallengeBuilder<'a, 'b> { - let start = _fbb.start_table(); - AcmeGetChallengeBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_hostname(&mut self, hostname: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(AcmeGetChallenge::VT_HOSTNAME, hostname); + } + #[inline] + pub fn add_token(&mut self, token: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(AcmeGetChallenge::VT_TOKEN, token); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> AcmeGetChallengeBuilder<'a, 'b> { + let start = _fbb.start_table(); + AcmeGetChallengeBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum AcmeGetChallengeReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct AcmeGetChallengeReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for AcmeGetChallengeReady<'a> { @@ -4820,36 +5062,40 @@ impl<'a> flatbuffers::Follow<'a> for AcmeGetChallengeReady<'a> { impl<'a> AcmeGetChallengeReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - AcmeGetChallengeReady { - _tab: table, - } + AcmeGetChallengeReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args AcmeGetChallengeReadyArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = AcmeGetChallengeReadyBuilder::new(_fbb); - if let Some(x) = args.contents { builder.add_contents(x); } - builder.add_id(args.id); - builder.finish() + args: &'args AcmeGetChallengeReadyArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = AcmeGetChallengeReadyBuilder::new(_fbb); + if let Some(x) = args.contents { + builder.add_contents(x); + } + builder.add_id(args.id); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_CONTENTS: flatbuffers::VOffsetT = 6; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(AcmeGetChallengeReady::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn contents(&self) -> Option<&'a str> { - self._tab.get::>(AcmeGetChallengeReady::VT_CONTENTS, None) - } + #[inline] + pub fn id(&self) -> u32 { + self._tab + .get::(AcmeGetChallengeReady::VT_ID, Some(0)) + .unwrap() + } + #[inline] + pub fn contents(&self) -> Option<&'a str> { + self._tab + .get::>(AcmeGetChallengeReady::VT_CONTENTS, None) + } } pub struct AcmeGetChallengeReadyArgs<'a> { pub id: u32, - pub contents: Option>, + pub contents: Option>, } impl<'a> Default for AcmeGetChallengeReadyArgs<'a> { #[inline] @@ -4861,38 +5107,44 @@ impl<'a> Default for AcmeGetChallengeReadyArgs<'a> { } } pub struct AcmeGetChallengeReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> AcmeGetChallengeReadyBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(AcmeGetChallengeReady::VT_ID, id, 0); - } - #[inline] - pub fn add_contents(&mut self, contents: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(AcmeGetChallengeReady::VT_CONTENTS, contents); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AcmeGetChallengeReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - AcmeGetChallengeReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_ + .push_slot::(AcmeGetChallengeReady::VT_ID, id, 0); + } + #[inline] + pub fn add_contents(&mut self, contents: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + AcmeGetChallengeReady::VT_CONTENTS, + contents, + ); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> AcmeGetChallengeReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + AcmeGetChallengeReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum OsExitOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct OsExit<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for OsExit<'a> { @@ -4908,25 +5160,24 @@ impl<'a> flatbuffers::Follow<'a> for OsExit<'a> { impl<'a> OsExit<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - OsExit { - _tab: table, - } + OsExit { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args OsExitArgs) -> flatbuffers::WIPOffset> { - let mut builder = OsExitBuilder::new(_fbb); - builder.add_code(args.code); - builder.finish() + args: &'args OsExitArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = OsExitBuilder::new(_fbb); + builder.add_code(args.code); + builder.finish() } pub const VT_CODE: flatbuffers::VOffsetT = 4; - #[inline] - pub fn code(&self) -> i32 { - self._tab.get::(OsExit::VT_CODE, Some(0)).unwrap() - } + #[inline] + pub fn code(&self) -> i32 { + self._tab.get::(OsExit::VT_CODE, Some(0)).unwrap() + } } pub struct OsExitArgs { @@ -4935,40 +5186,38 @@ pub struct OsExitArgs { impl<'a> Default for OsExitArgs { #[inline] fn default() -> Self { - OsExitArgs { - code: 0, - } + OsExitArgs { code: 0 } } } pub struct OsExitBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> OsExitBuilder<'a, 'b> { - #[inline] - pub fn add_code(&mut self, code: i32) { - self.fbb_.push_slot::(OsExit::VT_CODE, code, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OsExitBuilder<'a, 'b> { - let start = _fbb.start_table(); - OsExitBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_code(&mut self, code: i32) { + self.fbb_.push_slot::(OsExit::VT_CODE, code, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> OsExitBuilder<'a, 'b> { + let start = _fbb.start_table(); + OsExitBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum BaseOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct Base<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for Base<'a> { @@ -4984,22 +5233,25 @@ impl<'a> flatbuffers::Follow<'a> for Base<'a> { impl<'a> Base<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - Base { - _tab: table, - } + Base { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args BaseArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = BaseBuilder::new(_fbb); - if let Some(x) = args.msg { builder.add_msg(x); } - if let Some(x) = args.error { builder.add_error(x); } - builder.add_cmd_id(args.cmd_id); - builder.add_msg_type(args.msg_type); - builder.add_error_kind(args.error_kind); - builder.add_sync(args.sync); - builder.finish() + args: &'args BaseArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = BaseBuilder::new(_fbb); + if let Some(x) = args.msg { + builder.add_msg(x); + } + if let Some(x) = args.error { + builder.add_error(x); + } + builder.add_cmd_id(args.cmd_id); + builder.add_msg_type(args.msg_type); + builder.add_error_kind(args.error_kind); + builder.add_sync(args.sync); + builder.finish() } pub const VT_CMD_ID: flatbuffers::VOffsetT = 4; @@ -5009,457 +5261,464 @@ impl<'a> Base<'a> { pub const VT_MSG_TYPE: flatbuffers::VOffsetT = 12; pub const VT_MSG: flatbuffers::VOffsetT = 14; - #[inline] - pub fn cmd_id(&self) -> u32 { - self._tab.get::(Base::VT_CMD_ID, Some(0)).unwrap() - } - #[inline] - pub fn sync(&self) -> bool { - self._tab.get::(Base::VT_SYNC, Some(false)).unwrap() - } - #[inline] - pub fn error_kind(&self) -> ErrorKind { - self._tab.get::(Base::VT_ERROR_KIND, Some(ErrorKind::NoError)).unwrap() - } - #[inline] - pub fn error(&self) -> Option<&'a str> { - self._tab.get::>(Base::VT_ERROR, None) - } - #[inline] - pub fn msg_type(&self) -> Any { - self._tab.get::(Base::VT_MSG_TYPE, Some(Any::NONE)).unwrap() - } - #[inline] - pub fn msg(&self) -> Option> { - self._tab.get::>>(Base::VT_MSG, None) - } - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_timer_start(&'a self) -> Option { - if self.msg_type() == Any::TimerStart { - self.msg().map(|u| TimerStart::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_timer_ready(&'a self) -> Option { - if self.msg_type() == Any::TimerReady { - self.msg().map(|u| TimerReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_timer_clear(&'a self) -> Option { - if self.msg_type() == Any::TimerClear { - self.msg().map(|u| TimerClear::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_http_request(&'a self) -> Option { - if self.msg_type() == Any::HttpRequest { - self.msg().map(|u| HttpRequest::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_http_response(&'a self) -> Option { - if self.msg_type() == Any::HttpResponse { - self.msg().map(|u| HttpResponse::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_stream_chunk(&'a self) -> Option { - if self.msg_type() == Any::StreamChunk { - self.msg().map(|u| StreamChunk::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_http_request_start(&'a self) -> Option { - if self.msg_type() == Any::HttpRequestStart { - self.msg().map(|u| HttpRequestStart::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_fetch_http_response(&'a self) -> Option { - if self.msg_type() == Any::FetchHttpResponse { - self.msg().map(|u| FetchHttpResponse::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_get(&'a self) -> Option { - if self.msg_type() == Any::CacheGet { - self.msg().map(|u| CacheGet::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_get_ready(&'a self) -> Option { - if self.msg_type() == Any::CacheGetReady { - self.msg().map(|u| CacheGetReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_set(&'a self) -> Option { - if self.msg_type() == Any::CacheSet { - self.msg().map(|u| CacheSet::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_set_ready(&'a self) -> Option { - if self.msg_type() == Any::CacheSetReady { - self.msg().map(|u| CacheSetReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_del(&'a self) -> Option { - if self.msg_type() == Any::CacheDel { - self.msg().map(|u| CacheDel::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_expire(&'a self) -> Option { - if self.msg_type() == Any::CacheExpire { - self.msg().map(|u| CacheExpire::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_notify_del(&'a self) -> Option { - if self.msg_type() == Any::CacheNotifyDel { - self.msg().map(|u| CacheNotifyDel::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_notify_purge_tag(&'a self) -> Option { - if self.msg_type() == Any::CacheNotifyPurgeTag { - self.msg().map(|u| CacheNotifyPurgeTag::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_set_tags(&'a self) -> Option { - if self.msg_type() == Any::CacheSetTags { - self.msg().map(|u| CacheSetTags::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_purge_tag(&'a self) -> Option { - if self.msg_type() == Any::CachePurgeTag { - self.msg().map(|u| CachePurgeTag::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_cache_set_meta(&'a self) -> Option { - if self.msg_type() == Any::CacheSetMeta { - self.msg().map(|u| CacheSetMeta::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_crypto_digest(&'a self) -> Option { - if self.msg_type() == Any::CryptoDigest { - self.msg().map(|u| CryptoDigest::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_crypto_digest_ready(&'a self) -> Option { - if self.msg_type() == Any::CryptoDigestReady { - self.msg().map(|u| CryptoDigestReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_crypto_random_values(&'a self) -> Option { - if self.msg_type() == Any::CryptoRandomValues { - self.msg().map(|u| CryptoRandomValues::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_crypto_random_values_ready(&'a self) -> Option { - if self.msg_type() == Any::CryptoRandomValuesReady { - self.msg().map(|u| CryptoRandomValuesReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_source_map(&'a self) -> Option { - if self.msg_type() == Any::SourceMap { - self.msg().map(|u| SourceMap::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_source_map_ready(&'a self) -> Option { - if self.msg_type() == Any::SourceMapReady { - self.msg().map(|u| SourceMapReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_data_put(&'a self) -> Option { - if self.msg_type() == Any::DataPut { - self.msg().map(|u| DataPut::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_data_get(&'a self) -> Option { - if self.msg_type() == Any::DataGet { - self.msg().map(|u| DataGet::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_data_get_ready(&'a self) -> Option { - if self.msg_type() == Any::DataGetReady { - self.msg().map(|u| DataGetReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_data_del(&'a self) -> Option { - if self.msg_type() == Any::DataDel { - self.msg().map(|u| DataDel::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_data_incr(&'a self) -> Option { - if self.msg_type() == Any::DataIncr { - self.msg().map(|u| DataIncr::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_data_drop_collection(&'a self) -> Option { - if self.msg_type() == Any::DataDropCollection { - self.msg().map(|u| DataDropCollection::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_dns_query(&'a self) -> Option { - if self.msg_type() == Any::DnsQuery { - self.msg().map(|u| DnsQuery::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_dns_request(&'a self) -> Option { - if self.msg_type() == Any::DnsRequest { - self.msg().map(|u| DnsRequest::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_dns_response(&'a self) -> Option { - if self.msg_type() == Any::DnsResponse { - self.msg().map(|u| DnsResponse::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_add_event_listener(&'a self) -> Option { - if self.msg_type() == Any::AddEventListener { - self.msg().map(|u| AddEventListener::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_load_module(&'a self) -> Option { - if self.msg_type() == Any::LoadModule { - self.msg().map(|u| LoadModule::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_load_module_resp(&'a self) -> Option { - if self.msg_type() == Any::LoadModuleResp { - self.msg().map(|u| LoadModuleResp::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_image_apply_transforms(&'a self) -> Option { - if self.msg_type() == Any::ImageApplyTransforms { - self.msg().map(|u| ImageApplyTransforms::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_image_ready(&'a self) -> Option { - if self.msg_type() == Any::ImageReady { - self.msg().map(|u| ImageReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_acme_get_challenge(&'a self) -> Option { - if self.msg_type() == Any::AcmeGetChallenge { - self.msg().map(|u| AcmeGetChallenge::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_acme_get_challenge_ready(&'a self) -> Option { - if self.msg_type() == Any::AcmeGetChallengeReady { - self.msg().map(|u| AcmeGetChallengeReady::init_from_table(u)) - } else { - None - } - } - - #[inline] - #[allow(non_snake_case)] - pub fn msg_as_os_exit(&'a self) -> Option { - if self.msg_type() == Any::OsExit { - self.msg().map(|u| OsExit::init_from_table(u)) - } else { - None - } - } + #[inline] + pub fn cmd_id(&self) -> u32 { + self._tab.get::(Base::VT_CMD_ID, Some(0)).unwrap() + } + #[inline] + pub fn sync(&self) -> bool { + self._tab.get::(Base::VT_SYNC, Some(false)).unwrap() + } + #[inline] + pub fn error_kind(&self) -> ErrorKind { + self._tab + .get::(Base::VT_ERROR_KIND, Some(ErrorKind::NoError)) + .unwrap() + } + #[inline] + pub fn error(&self) -> Option<&'a str> { + self._tab + .get::>(Base::VT_ERROR, None) + } + #[inline] + pub fn msg_type(&self) -> Any { + self._tab + .get::(Base::VT_MSG_TYPE, Some(Any::NONE)) + .unwrap() + } + #[inline] + pub fn msg(&self) -> Option> { + self._tab + .get::>>(Base::VT_MSG, None) + } + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_timer_start(&'a self) -> Option { + if self.msg_type() == Any::TimerStart { + self.msg().map(|u| TimerStart::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_timer_ready(&'a self) -> Option { + if self.msg_type() == Any::TimerReady { + self.msg().map(|u| TimerReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_timer_clear(&'a self) -> Option { + if self.msg_type() == Any::TimerClear { + self.msg().map(|u| TimerClear::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_http_request(&'a self) -> Option { + if self.msg_type() == Any::HttpRequest { + self.msg().map(|u| HttpRequest::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_http_response(&'a self) -> Option { + if self.msg_type() == Any::HttpResponse { + self.msg().map(|u| HttpResponse::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_stream_chunk(&'a self) -> Option { + if self.msg_type() == Any::StreamChunk { + self.msg().map(|u| StreamChunk::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_http_request_start(&'a self) -> Option { + if self.msg_type() == Any::HttpRequestStart { + self.msg().map(|u| HttpRequestStart::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_fetch_http_response(&'a self) -> Option { + if self.msg_type() == Any::FetchHttpResponse { + self.msg().map(|u| FetchHttpResponse::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_get(&'a self) -> Option { + if self.msg_type() == Any::CacheGet { + self.msg().map(|u| CacheGet::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_get_ready(&'a self) -> Option { + if self.msg_type() == Any::CacheGetReady { + self.msg().map(|u| CacheGetReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_set(&'a self) -> Option { + if self.msg_type() == Any::CacheSet { + self.msg().map(|u| CacheSet::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_set_ready(&'a self) -> Option { + if self.msg_type() == Any::CacheSetReady { + self.msg().map(|u| CacheSetReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_del(&'a self) -> Option { + if self.msg_type() == Any::CacheDel { + self.msg().map(|u| CacheDel::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_expire(&'a self) -> Option { + if self.msg_type() == Any::CacheExpire { + self.msg().map(|u| CacheExpire::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_notify_del(&'a self) -> Option { + if self.msg_type() == Any::CacheNotifyDel { + self.msg().map(|u| CacheNotifyDel::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_notify_purge_tag(&'a self) -> Option { + if self.msg_type() == Any::CacheNotifyPurgeTag { + self.msg().map(|u| CacheNotifyPurgeTag::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_set_tags(&'a self) -> Option { + if self.msg_type() == Any::CacheSetTags { + self.msg().map(|u| CacheSetTags::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_purge_tag(&'a self) -> Option { + if self.msg_type() == Any::CachePurgeTag { + self.msg().map(|u| CachePurgeTag::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_cache_set_meta(&'a self) -> Option { + if self.msg_type() == Any::CacheSetMeta { + self.msg().map(|u| CacheSetMeta::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_crypto_digest(&'a self) -> Option { + if self.msg_type() == Any::CryptoDigest { + self.msg().map(|u| CryptoDigest::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_crypto_digest_ready(&'a self) -> Option { + if self.msg_type() == Any::CryptoDigestReady { + self.msg().map(|u| CryptoDigestReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_crypto_random_values(&'a self) -> Option { + if self.msg_type() == Any::CryptoRandomValues { + self.msg().map(|u| CryptoRandomValues::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_crypto_random_values_ready(&'a self) -> Option { + if self.msg_type() == Any::CryptoRandomValuesReady { + self.msg() + .map(|u| CryptoRandomValuesReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_source_map(&'a self) -> Option { + if self.msg_type() == Any::SourceMap { + self.msg().map(|u| SourceMap::init_from_table(u)) + } else { + None + } + } + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_source_map_ready(&'a self) -> Option { + if self.msg_type() == Any::SourceMapReady { + self.msg().map(|u| SourceMapReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_data_put(&'a self) -> Option { + if self.msg_type() == Any::DataPut { + self.msg().map(|u| DataPut::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_data_get(&'a self) -> Option { + if self.msg_type() == Any::DataGet { + self.msg().map(|u| DataGet::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_data_get_ready(&'a self) -> Option { + if self.msg_type() == Any::DataGetReady { + self.msg().map(|u| DataGetReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_data_del(&'a self) -> Option { + if self.msg_type() == Any::DataDel { + self.msg().map(|u| DataDel::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_data_incr(&'a self) -> Option { + if self.msg_type() == Any::DataIncr { + self.msg().map(|u| DataIncr::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_data_drop_collection(&'a self) -> Option { + if self.msg_type() == Any::DataDropCollection { + self.msg().map(|u| DataDropCollection::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_dns_query(&'a self) -> Option { + if self.msg_type() == Any::DnsQuery { + self.msg().map(|u| DnsQuery::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_dns_request(&'a self) -> Option { + if self.msg_type() == Any::DnsRequest { + self.msg().map(|u| DnsRequest::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_dns_response(&'a self) -> Option { + if self.msg_type() == Any::DnsResponse { + self.msg().map(|u| DnsResponse::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_add_event_listener(&'a self) -> Option { + if self.msg_type() == Any::AddEventListener { + self.msg().map(|u| AddEventListener::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_load_module(&'a self) -> Option { + if self.msg_type() == Any::LoadModule { + self.msg().map(|u| LoadModule::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_load_module_resp(&'a self) -> Option { + if self.msg_type() == Any::LoadModuleResp { + self.msg().map(|u| LoadModuleResp::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_image_apply_transforms(&'a self) -> Option { + if self.msg_type() == Any::ImageApplyTransforms { + self.msg().map(|u| ImageApplyTransforms::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_image_ready(&'a self) -> Option { + if self.msg_type() == Any::ImageReady { + self.msg().map(|u| ImageReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_acme_get_challenge(&'a self) -> Option { + if self.msg_type() == Any::AcmeGetChallenge { + self.msg().map(|u| AcmeGetChallenge::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_acme_get_challenge_ready(&'a self) -> Option { + if self.msg_type() == Any::AcmeGetChallengeReady { + self.msg() + .map(|u| AcmeGetChallengeReady::init_from_table(u)) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn msg_as_os_exit(&'a self) -> Option { + if self.msg_type() == Any::OsExit { + self.msg().map(|u| OsExit::init_from_table(u)) + } else { + None + } + } } pub struct BaseArgs<'a> { pub cmd_id: u32, pub sync: bool, pub error_kind: ErrorKind, - pub error: Option>, + pub error: Option>, pub msg_type: Any, pub msg: Option>, } @@ -5477,54 +5736,58 @@ impl<'a> Default for BaseArgs<'a> { } } pub struct BaseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> BaseBuilder<'a, 'b> { - #[inline] - pub fn add_cmd_id(&mut self, cmd_id: u32) { - self.fbb_.push_slot::(Base::VT_CMD_ID, cmd_id, 0); - } - #[inline] - pub fn add_sync(&mut self, sync: bool) { - self.fbb_.push_slot::(Base::VT_SYNC, sync, false); - } - #[inline] - pub fn add_error_kind(&mut self, error_kind: ErrorKind) { - self.fbb_.push_slot::(Base::VT_ERROR_KIND, error_kind, ErrorKind::NoError); - } - #[inline] - pub fn add_error(&mut self, error: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(Base::VT_ERROR, error); - } - #[inline] - pub fn add_msg_type(&mut self, msg_type: Any) { - self.fbb_.push_slot::(Base::VT_MSG_TYPE, msg_type, Any::NONE); - } - #[inline] - pub fn add_msg(&mut self, msg: flatbuffers::WIPOffset) { - self.fbb_.push_slot_always::>(Base::VT_MSG, msg); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> BaseBuilder<'a, 'b> { - let start = _fbb.start_table(); - BaseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_cmd_id(&mut self, cmd_id: u32) { + self.fbb_.push_slot::(Base::VT_CMD_ID, cmd_id, 0); + } + #[inline] + pub fn add_sync(&mut self, sync: bool) { + self.fbb_.push_slot::(Base::VT_SYNC, sync, false); + } + #[inline] + pub fn add_error_kind(&mut self, error_kind: ErrorKind) { + self.fbb_ + .push_slot::(Base::VT_ERROR_KIND, error_kind, ErrorKind::NoError); + } + #[inline] + pub fn add_error(&mut self, error: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(Base::VT_ERROR, error); + } + #[inline] + pub fn add_msg_type(&mut self, msg_type: Any) { + self.fbb_ + .push_slot::(Base::VT_MSG_TYPE, msg_type, Any::NONE); + } + #[inline] + pub fn add_msg(&mut self, msg: flatbuffers::WIPOffset) { + self.fbb_ + .push_slot_always::>(Base::VT_MSG, msg); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> BaseBuilder<'a, 'b> { + let start = _fbb.start_table(); + BaseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum TimerStartOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct TimerStart<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for TimerStart<'a> { @@ -5540,31 +5803,30 @@ impl<'a> flatbuffers::Follow<'a> for TimerStart<'a> { impl<'a> TimerStart<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TimerStart { - _tab: table, - } + TimerStart { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TimerStartArgs) -> flatbuffers::WIPOffset> { - let mut builder = TimerStartBuilder::new(_fbb); - builder.add_delay(args.delay); - builder.add_id(args.id); - builder.finish() + args: &'args TimerStartArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = TimerStartBuilder::new(_fbb); + builder.add_delay(args.delay); + builder.add_id(args.id); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_DELAY: flatbuffers::VOffsetT = 6; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(TimerStart::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn delay(&self) -> u32 { - self._tab.get::(TimerStart::VT_DELAY, Some(0)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(TimerStart::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn delay(&self) -> u32 { + self._tab.get::(TimerStart::VT_DELAY, Some(0)).unwrap() + } } pub struct TimerStartArgs { @@ -5574,45 +5836,42 @@ pub struct TimerStartArgs { impl<'a> Default for TimerStartArgs { #[inline] fn default() -> Self { - TimerStartArgs { - id: 0, - delay: 0, - } + TimerStartArgs { id: 0, delay: 0 } } } pub struct TimerStartBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> TimerStartBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(TimerStart::VT_ID, id, 0); - } - #[inline] - pub fn add_delay(&mut self, delay: u32) { - self.fbb_.push_slot::(TimerStart::VT_DELAY, delay, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimerStartBuilder<'a, 'b> { - let start = _fbb.start_table(); - TimerStartBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(TimerStart::VT_ID, id, 0); + } + #[inline] + pub fn add_delay(&mut self, delay: u32) { + self.fbb_.push_slot::(TimerStart::VT_DELAY, delay, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimerStartBuilder<'a, 'b> { + let start = _fbb.start_table(); + TimerStartBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum TimerReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct TimerReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for TimerReady<'a> { @@ -5628,31 +5887,32 @@ impl<'a> flatbuffers::Follow<'a> for TimerReady<'a> { impl<'a> TimerReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TimerReady { - _tab: table, - } + TimerReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TimerReadyArgs) -> flatbuffers::WIPOffset> { - let mut builder = TimerReadyBuilder::new(_fbb); - builder.add_id(args.id); - builder.add_canceled(args.canceled); - builder.finish() + args: &'args TimerReadyArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = TimerReadyBuilder::new(_fbb); + builder.add_id(args.id); + builder.add_canceled(args.canceled); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_CANCELED: flatbuffers::VOffsetT = 6; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(TimerReady::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn canceled(&self) -> bool { - self._tab.get::(TimerReady::VT_CANCELED, Some(false)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(TimerReady::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn canceled(&self) -> bool { + self._tab + .get::(TimerReady::VT_CANCELED, Some(false)) + .unwrap() + } } pub struct TimerReadyArgs { @@ -5669,38 +5929,39 @@ impl<'a> Default for TimerReadyArgs { } } pub struct TimerReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> TimerReadyBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(TimerReady::VT_ID, id, 0); - } - #[inline] - pub fn add_canceled(&mut self, canceled: bool) { - self.fbb_.push_slot::(TimerReady::VT_CANCELED, canceled, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimerReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - TimerReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(TimerReady::VT_ID, id, 0); + } + #[inline] + pub fn add_canceled(&mut self, canceled: bool) { + self.fbb_ + .push_slot::(TimerReady::VT_CANCELED, canceled, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimerReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + TimerReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum TimerClearOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct TimerClear<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for TimerClear<'a> { @@ -5716,25 +5977,24 @@ impl<'a> flatbuffers::Follow<'a> for TimerClear<'a> { impl<'a> TimerClear<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - TimerClear { - _tab: table, - } + TimerClear { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args TimerClearArgs) -> flatbuffers::WIPOffset> { - let mut builder = TimerClearBuilder::new(_fbb); - builder.add_id(args.id); - builder.finish() + args: &'args TimerClearArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = TimerClearBuilder::new(_fbb); + builder.add_id(args.id); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(TimerClear::VT_ID, Some(0)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(TimerClear::VT_ID, Some(0)).unwrap() + } } pub struct TimerClearArgs { @@ -5743,40 +6003,38 @@ pub struct TimerClearArgs { impl<'a> Default for TimerClearArgs { #[inline] fn default() -> Self { - TimerClearArgs { - id: 0, - } + TimerClearArgs { id: 0 } } } pub struct TimerClearBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> TimerClearBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(TimerClear::VT_ID, id, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimerClearBuilder<'a, 'b> { - let start = _fbb.start_table(); - TimerClearBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(TimerClear::VT_ID, id, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimerClearBuilder<'a, 'b> { + let start = _fbb.start_table(); + TimerClearBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum HttpHeaderOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct HttpHeader<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for HttpHeader<'a> { @@ -5792,36 +6050,41 @@ impl<'a> flatbuffers::Follow<'a> for HttpHeader<'a> { impl<'a> HttpHeader<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HttpHeader { - _tab: table, - } + HttpHeader { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args HttpHeaderArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = HttpHeaderBuilder::new(_fbb); - if let Some(x) = args.value { builder.add_value(x); } - if let Some(x) = args.key { builder.add_key(x); } - builder.finish() + args: &'args HttpHeaderArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = HttpHeaderBuilder::new(_fbb); + if let Some(x) = args.value { + builder.add_value(x); + } + if let Some(x) = args.key { + builder.add_key(x); + } + builder.finish() } pub const VT_KEY: flatbuffers::VOffsetT = 4; pub const VT_VALUE: flatbuffers::VOffsetT = 6; - #[inline] - pub fn key(&self) -> Option<&'a str> { - self._tab.get::>(HttpHeader::VT_KEY, None) - } - #[inline] - pub fn value(&self) -> Option<&'a str> { - self._tab.get::>(HttpHeader::VT_VALUE, None) - } + #[inline] + pub fn key(&self) -> Option<&'a str> { + self._tab + .get::>(HttpHeader::VT_KEY, None) + } + #[inline] + pub fn value(&self) -> Option<&'a str> { + self._tab + .get::>(HttpHeader::VT_VALUE, None) + } } pub struct HttpHeaderArgs<'a> { - pub key: Option>, - pub value: Option>, + pub key: Option>, + pub value: Option>, } impl<'a> Default for HttpHeaderArgs<'a> { #[inline] @@ -5833,38 +6096,40 @@ impl<'a> Default for HttpHeaderArgs<'a> { } } pub struct HttpHeaderBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> HttpHeaderBuilder<'a, 'b> { - #[inline] - pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(HttpHeader::VT_KEY, key); - } - #[inline] - pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(HttpHeader::VT_VALUE, value); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpHeaderBuilder<'a, 'b> { - let start = _fbb.start_table(); - HttpHeaderBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_key(&mut self, key: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(HttpHeader::VT_KEY, key); + } + #[inline] + pub fn add_value(&mut self, value: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(HttpHeader::VT_VALUE, value); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpHeaderBuilder<'a, 'b> { + let start = _fbb.start_table(); + HttpHeaderBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum StreamChunkOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct StreamChunk<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for StreamChunk<'a> { @@ -5880,31 +6145,32 @@ impl<'a> flatbuffers::Follow<'a> for StreamChunk<'a> { impl<'a> StreamChunk<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - StreamChunk { - _tab: table, - } + StreamChunk { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args StreamChunkArgs) -> flatbuffers::WIPOffset> { - let mut builder = StreamChunkBuilder::new(_fbb); - builder.add_id(args.id); - builder.add_done(args.done); - builder.finish() + args: &'args StreamChunkArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = StreamChunkBuilder::new(_fbb); + builder.add_id(args.id); + builder.add_done(args.done); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; pub const VT_DONE: flatbuffers::VOffsetT = 6; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(StreamChunk::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn done(&self) -> bool { - self._tab.get::(StreamChunk::VT_DONE, Some(false)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(StreamChunk::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn done(&self) -> bool { + self._tab + .get::(StreamChunk::VT_DONE, Some(false)) + .unwrap() + } } pub struct StreamChunkArgs { @@ -5914,45 +6180,43 @@ pub struct StreamChunkArgs { impl<'a> Default for StreamChunkArgs { #[inline] fn default() -> Self { - StreamChunkArgs { - id: 0, - done: false, - } + StreamChunkArgs { id: 0, done: false } } } pub struct StreamChunkBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> StreamChunkBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(StreamChunk::VT_ID, id, 0); - } - #[inline] - pub fn add_done(&mut self, done: bool) { - self.fbb_.push_slot::(StreamChunk::VT_DONE, done, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StreamChunkBuilder<'a, 'b> { - let start = _fbb.start_table(); - StreamChunkBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(StreamChunk::VT_ID, id, 0); + } + #[inline] + pub fn add_done(&mut self, done: bool) { + self.fbb_ + .push_slot::(StreamChunk::VT_DONE, done, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StreamChunkBuilder<'a, 'b> { + let start = _fbb.start_table(); + StreamChunkBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum HttpRequestOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct HttpRequest<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for HttpRequest<'a> { @@ -5968,22 +6232,27 @@ impl<'a> flatbuffers::Follow<'a> for HttpRequest<'a> { impl<'a> HttpRequest<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HttpRequest { - _tab: table, - } + HttpRequest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args HttpRequestArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = HttpRequestBuilder::new(_fbb); - if let Some(x) = args.remote_addr { builder.add_remote_addr(x); } - if let Some(x) = args.headers { builder.add_headers(x); } - if let Some(x) = args.url { builder.add_url(x); } - builder.add_id(args.id); - builder.add_has_body(args.has_body); - builder.add_method(args.method); - builder.finish() + args: &'args HttpRequestArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = HttpRequestBuilder::new(_fbb); + if let Some(x) = args.remote_addr { + builder.add_remote_addr(x); + } + if let Some(x) = args.headers { + builder.add_headers(x); + } + if let Some(x) = args.url { + builder.add_url(x); + } + builder.add_id(args.id); + builder.add_has_body(args.has_body); + builder.add_method(args.method); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; @@ -5993,38 +6262,52 @@ impl<'a> HttpRequest<'a> { pub const VT_REMOTE_ADDR: flatbuffers::VOffsetT = 12; pub const VT_HAS_BODY: flatbuffers::VOffsetT = 14; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(HttpRequest::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn method(&self) -> HttpMethod { - self._tab.get::(HttpRequest::VT_METHOD, Some(HttpMethod::Get)).unwrap() - } - #[inline] - pub fn url(&self) -> Option<&'a str> { - self._tab.get::>(HttpRequest::VT_URL, None) - } - #[inline] - pub fn headers(&self) -> Option>>> { - self._tab.get::>>>>(HttpRequest::VT_HEADERS, None) - } - #[inline] - pub fn remote_addr(&self) -> Option<&'a str> { - self._tab.get::>(HttpRequest::VT_REMOTE_ADDR, None) - } - #[inline] - pub fn has_body(&self) -> bool { - self._tab.get::(HttpRequest::VT_HAS_BODY, Some(false)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(HttpRequest::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn method(&self) -> HttpMethod { + self._tab + .get::(HttpRequest::VT_METHOD, Some(HttpMethod::Get)) + .unwrap() + } + #[inline] + pub fn url(&self) -> Option<&'a str> { + self._tab + .get::>(HttpRequest::VT_URL, None) + } + #[inline] + pub fn headers( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(HttpRequest::VT_HEADERS, None) + } + #[inline] + pub fn remote_addr(&self) -> Option<&'a str> { + self._tab + .get::>(HttpRequest::VT_REMOTE_ADDR, None) + } + #[inline] + pub fn has_body(&self) -> bool { + self._tab + .get::(HttpRequest::VT_HAS_BODY, Some(false)) + .unwrap() + } } pub struct HttpRequestArgs<'a> { pub id: u32, pub method: HttpMethod, - pub url: Option>, - pub headers: Option>>>>, - pub remote_addr: Option>, + pub url: Option>, + pub headers: Option< + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + >, + >, + pub remote_addr: Option>, pub has_body: bool, } impl<'a> Default for HttpRequestArgs<'a> { @@ -6041,54 +6324,66 @@ impl<'a> Default for HttpRequestArgs<'a> { } } pub struct HttpRequestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> HttpRequestBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(HttpRequest::VT_ID, id, 0); - } - #[inline] - pub fn add_method(&mut self, method: HttpMethod) { - self.fbb_.push_slot::(HttpRequest::VT_METHOD, method, HttpMethod::Get); - } - #[inline] - pub fn add_url(&mut self, url: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(HttpRequest::VT_URL, url); - } - #[inline] - pub fn add_headers(&mut self, headers: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(HttpRequest::VT_HEADERS, headers); - } - #[inline] - pub fn add_remote_addr(&mut self, remote_addr: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(HttpRequest::VT_REMOTE_ADDR, remote_addr); - } - #[inline] - pub fn add_has_body(&mut self, has_body: bool) { - self.fbb_.push_slot::(HttpRequest::VT_HAS_BODY, has_body, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpRequestBuilder<'a, 'b> { - let start = _fbb.start_table(); - HttpRequestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(HttpRequest::VT_ID, id, 0); + } + #[inline] + pub fn add_method(&mut self, method: HttpMethod) { + self.fbb_ + .push_slot::(HttpRequest::VT_METHOD, method, HttpMethod::Get); + } + #[inline] + pub fn add_url(&mut self, url: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(HttpRequest::VT_URL, url); + } + #[inline] + pub fn add_headers( + &mut self, + headers: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(HttpRequest::VT_HEADERS, headers); + } + #[inline] + pub fn add_remote_addr(&mut self, remote_addr: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + HttpRequest::VT_REMOTE_ADDR, + remote_addr, + ); + } + #[inline] + pub fn add_has_body(&mut self, has_body: bool) { + self.fbb_ + .push_slot::(HttpRequest::VT_HAS_BODY, has_body, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + HttpRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum HttpResponseOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct HttpResponse<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for HttpResponse<'a> { @@ -6104,20 +6399,21 @@ impl<'a> flatbuffers::Follow<'a> for HttpResponse<'a> { impl<'a> HttpResponse<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HttpResponse { - _tab: table, - } + HttpResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args HttpResponseArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = HttpResponseBuilder::new(_fbb); - if let Some(x) = args.headers { builder.add_headers(x); } - builder.add_id(args.id); - builder.add_status(args.status); - builder.add_has_body(args.has_body); - builder.finish() + args: &'args HttpResponseArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = HttpResponseBuilder::new(_fbb); + if let Some(x) = args.headers { + builder.add_headers(x); + } + builder.add_id(args.id); + builder.add_status(args.status); + builder.add_has_body(args.has_body); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; @@ -6125,27 +6421,39 @@ impl<'a> HttpResponse<'a> { pub const VT_STATUS: flatbuffers::VOffsetT = 8; pub const VT_HAS_BODY: flatbuffers::VOffsetT = 10; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(HttpResponse::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn headers(&self) -> Option>>> { - self._tab.get::>>>>(HttpResponse::VT_HEADERS, None) - } - #[inline] - pub fn status(&self) -> u16 { - self._tab.get::(HttpResponse::VT_STATUS, Some(0)).unwrap() - } - #[inline] - pub fn has_body(&self) -> bool { - self._tab.get::(HttpResponse::VT_HAS_BODY, Some(false)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab.get::(HttpResponse::VT_ID, Some(0)).unwrap() + } + #[inline] + pub fn headers( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(HttpResponse::VT_HEADERS, None) + } + #[inline] + pub fn status(&self) -> u16 { + self._tab + .get::(HttpResponse::VT_STATUS, Some(0)) + .unwrap() + } + #[inline] + pub fn has_body(&self) -> bool { + self._tab + .get::(HttpResponse::VT_HAS_BODY, Some(false)) + .unwrap() + } } pub struct HttpResponseArgs<'a> { pub id: u32, - pub headers: Option>>>>, + pub headers: Option< + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + >, + >, pub status: u16, pub has_body: bool, } @@ -6161,46 +6469,54 @@ impl<'a> Default for HttpResponseArgs<'a> { } } pub struct HttpResponseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> HttpResponseBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(HttpResponse::VT_ID, id, 0); - } - #[inline] - pub fn add_headers(&mut self, headers: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(HttpResponse::VT_HEADERS, headers); - } - #[inline] - pub fn add_status(&mut self, status: u16) { - self.fbb_.push_slot::(HttpResponse::VT_STATUS, status, 0); - } - #[inline] - pub fn add_has_body(&mut self, has_body: bool) { - self.fbb_.push_slot::(HttpResponse::VT_HAS_BODY, has_body, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpResponseBuilder<'a, 'b> { - let start = _fbb.start_table(); - HttpResponseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(HttpResponse::VT_ID, id, 0); + } + #[inline] + pub fn add_headers( + &mut self, + headers: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(HttpResponse::VT_HEADERS, headers); + } + #[inline] + pub fn add_status(&mut self, status: u16) { + self.fbb_ + .push_slot::(HttpResponse::VT_STATUS, status, 0); + } + #[inline] + pub fn add_has_body(&mut self, has_body: bool) { + self.fbb_ + .push_slot::(HttpResponse::VT_HAS_BODY, has_body, false); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + HttpResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum HttpRequestStartOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct HttpRequestStart<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for HttpRequestStart<'a> { @@ -6216,25 +6532,26 @@ impl<'a> flatbuffers::Follow<'a> for HttpRequestStart<'a> { impl<'a> HttpRequestStart<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - HttpRequestStart { - _tab: table, - } + HttpRequestStart { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args HttpRequestStartArgs) -> flatbuffers::WIPOffset> { - let mut builder = HttpRequestStartBuilder::new(_fbb); - builder.add_id(args.id); - builder.finish() + args: &'args HttpRequestStartArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = HttpRequestStartBuilder::new(_fbb); + builder.add_id(args.id); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(HttpRequestStart::VT_ID, Some(0)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab + .get::(HttpRequestStart::VT_ID, Some(0)) + .unwrap() + } } pub struct HttpRequestStartArgs { @@ -6243,40 +6560,40 @@ pub struct HttpRequestStartArgs { impl<'a> Default for HttpRequestStartArgs { #[inline] fn default() -> Self { - HttpRequestStartArgs { - id: 0, - } + HttpRequestStartArgs { id: 0 } } } pub struct HttpRequestStartBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> HttpRequestStartBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(HttpRequestStart::VT_ID, id, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HttpRequestStartBuilder<'a, 'b> { - let start = _fbb.start_table(); - HttpRequestStartBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(HttpRequestStart::VT_ID, id, 0); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> HttpRequestStartBuilder<'a, 'b> { + let start = _fbb.start_table(); + HttpRequestStartBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum FetchHttpResponseOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct FetchHttpResponse<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for FetchHttpResponse<'a> { @@ -6292,20 +6609,21 @@ impl<'a> flatbuffers::Follow<'a> for FetchHttpResponse<'a> { impl<'a> FetchHttpResponse<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - FetchHttpResponse { - _tab: table, - } + FetchHttpResponse { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args FetchHttpResponseArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = FetchHttpResponseBuilder::new(_fbb); - if let Some(x) = args.headers { builder.add_headers(x); } - builder.add_id(args.id); - builder.add_status(args.status); - builder.add_has_body(args.has_body); - builder.finish() + args: &'args FetchHttpResponseArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = FetchHttpResponseBuilder::new(_fbb); + if let Some(x) = args.headers { + builder.add_headers(x); + } + builder.add_id(args.id); + builder.add_status(args.status); + builder.add_has_body(args.has_body); + builder.finish() } pub const VT_ID: flatbuffers::VOffsetT = 4; @@ -6313,27 +6631,41 @@ impl<'a> FetchHttpResponse<'a> { pub const VT_STATUS: flatbuffers::VOffsetT = 8; pub const VT_HAS_BODY: flatbuffers::VOffsetT = 10; - #[inline] - pub fn id(&self) -> u32 { - self._tab.get::(FetchHttpResponse::VT_ID, Some(0)).unwrap() - } - #[inline] - pub fn headers(&self) -> Option>>> { - self._tab.get::>>>>(FetchHttpResponse::VT_HEADERS, None) - } - #[inline] - pub fn status(&self) -> u16 { - self._tab.get::(FetchHttpResponse::VT_STATUS, Some(0)).unwrap() - } - #[inline] - pub fn has_body(&self) -> bool { - self._tab.get::(FetchHttpResponse::VT_HAS_BODY, Some(false)).unwrap() - } + #[inline] + pub fn id(&self) -> u32 { + self._tab + .get::(FetchHttpResponse::VT_ID, Some(0)) + .unwrap() + } + #[inline] + pub fn headers( + &self, + ) -> Option>>> { + self._tab.get::>>, + >>(FetchHttpResponse::VT_HEADERS, None) + } + #[inline] + pub fn status(&self) -> u16 { + self._tab + .get::(FetchHttpResponse::VT_STATUS, Some(0)) + .unwrap() + } + #[inline] + pub fn has_body(&self) -> bool { + self._tab + .get::(FetchHttpResponse::VT_HAS_BODY, Some(false)) + .unwrap() + } } pub struct FetchHttpResponseArgs<'a> { pub id: u32, - pub headers: Option>>>>, + pub headers: Option< + flatbuffers::WIPOffset< + flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset>>, + >, + >, pub status: u16, pub has_body: bool, } @@ -6349,46 +6681,56 @@ impl<'a> Default for FetchHttpResponseArgs<'a> { } } pub struct FetchHttpResponseBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> FetchHttpResponseBuilder<'a, 'b> { - #[inline] - pub fn add_id(&mut self, id: u32) { - self.fbb_.push_slot::(FetchHttpResponse::VT_ID, id, 0); - } - #[inline] - pub fn add_headers(&mut self, headers: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(FetchHttpResponse::VT_HEADERS, headers); - } - #[inline] - pub fn add_status(&mut self, status: u16) { - self.fbb_.push_slot::(FetchHttpResponse::VT_STATUS, status, 0); - } - #[inline] - pub fn add_has_body(&mut self, has_body: bool) { - self.fbb_.push_slot::(FetchHttpResponse::VT_HAS_BODY, has_body, false); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FetchHttpResponseBuilder<'a, 'b> { - let start = _fbb.start_table(); - FetchHttpResponseBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_id(&mut self, id: u32) { + self.fbb_.push_slot::(FetchHttpResponse::VT_ID, id, 0); + } + #[inline] + pub fn add_headers( + &mut self, + headers: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(FetchHttpResponse::VT_HEADERS, headers); + } + #[inline] + pub fn add_status(&mut self, status: u16) { + self.fbb_ + .push_slot::(FetchHttpResponse::VT_STATUS, status, 0); + } + #[inline] + pub fn add_has_body(&mut self, has_body: bool) { + self.fbb_ + .push_slot::(FetchHttpResponse::VT_HAS_BODY, has_body, false); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> FetchHttpResponseBuilder<'a, 'b> { + let start = _fbb.start_table(); + FetchHttpResponseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CryptoDigestOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CryptoDigest<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CryptoDigest<'a> { @@ -6404,67 +6746,68 @@ impl<'a> flatbuffers::Follow<'a> for CryptoDigest<'a> { impl<'a> CryptoDigest<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CryptoDigest { - _tab: table, - } + CryptoDigest { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CryptoDigestArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CryptoDigestBuilder::new(_fbb); - if let Some(x) = args.algo { builder.add_algo(x); } - builder.finish() + args: &'args CryptoDigestArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CryptoDigestBuilder::new(_fbb); + if let Some(x) = args.algo { + builder.add_algo(x); + } + builder.finish() } pub const VT_ALGO: flatbuffers::VOffsetT = 4; - #[inline] - pub fn algo(&self) -> Option<&'a str> { - self._tab.get::>(CryptoDigest::VT_ALGO, None) - } + #[inline] + pub fn algo(&self) -> Option<&'a str> { + self._tab + .get::>(CryptoDigest::VT_ALGO, None) + } } pub struct CryptoDigestArgs<'a> { - pub algo: Option>, + pub algo: Option>, } impl<'a> Default for CryptoDigestArgs<'a> { #[inline] fn default() -> Self { - CryptoDigestArgs { - algo: None, - } + CryptoDigestArgs { algo: None } } } pub struct CryptoDigestBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CryptoDigestBuilder<'a, 'b> { - #[inline] - pub fn add_algo(&mut self, algo: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(CryptoDigest::VT_ALGO, algo); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CryptoDigestBuilder<'a, 'b> { - let start = _fbb.start_table(); - CryptoDigestBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_algo(&mut self, algo: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(CryptoDigest::VT_ALGO, algo); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CryptoDigestBuilder<'a, 'b> { + let start = _fbb.start_table(); + CryptoDigestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CryptoDigestReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CryptoDigestReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CryptoDigestReady<'a> { @@ -6480,67 +6823,74 @@ impl<'a> flatbuffers::Follow<'a> for CryptoDigestReady<'a> { impl<'a> CryptoDigestReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CryptoDigestReady { - _tab: table, - } + CryptoDigestReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CryptoDigestReadyArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CryptoDigestReadyBuilder::new(_fbb); - if let Some(x) = args.buffer { builder.add_buffer(x); } - builder.finish() + args: &'args CryptoDigestReadyArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CryptoDigestReadyBuilder::new(_fbb); + if let Some(x) = args.buffer { + builder.add_buffer(x); + } + builder.finish() } pub const VT_BUFFER: flatbuffers::VOffsetT = 4; - #[inline] - pub fn buffer(&self) -> Option<&'a [u8]> { - self._tab.get::>>(CryptoDigestReady::VT_BUFFER, None).map(|v| v.safe_slice()) - } + #[inline] + pub fn buffer(&self) -> Option<&'a [u8]> { + self._tab + .get::>>( + CryptoDigestReady::VT_BUFFER, + None, + ) + .map(|v| v.safe_slice()) + } } pub struct CryptoDigestReadyArgs<'a> { - pub buffer: Option>>, + pub buffer: Option>>, } impl<'a> Default for CryptoDigestReadyArgs<'a> { #[inline] fn default() -> Self { - CryptoDigestReadyArgs { - buffer: None, - } + CryptoDigestReadyArgs { buffer: None } } } pub struct CryptoDigestReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CryptoDigestReadyBuilder<'a, 'b> { - #[inline] - pub fn add_buffer(&mut self, buffer: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(CryptoDigestReady::VT_BUFFER, buffer); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CryptoDigestReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - CryptoDigestReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_buffer(&mut self, buffer: flatbuffers::WIPOffset>) { + self.fbb_ + .push_slot_always::>(CryptoDigestReady::VT_BUFFER, buffer); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> CryptoDigestReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + CryptoDigestReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CryptoRandomValuesOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CryptoRandomValues<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CryptoRandomValues<'a> { @@ -6556,25 +6906,26 @@ impl<'a> flatbuffers::Follow<'a> for CryptoRandomValues<'a> { impl<'a> CryptoRandomValues<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CryptoRandomValues { - _tab: table, - } + CryptoRandomValues { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CryptoRandomValuesArgs) -> flatbuffers::WIPOffset> { - let mut builder = CryptoRandomValuesBuilder::new(_fbb); - builder.add_len(args.len); - builder.finish() + args: &'args CryptoRandomValuesArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = CryptoRandomValuesBuilder::new(_fbb); + builder.add_len(args.len); + builder.finish() } pub const VT_LEN: flatbuffers::VOffsetT = 4; - #[inline] - pub fn len(&self) -> u32 { - self._tab.get::(CryptoRandomValues::VT_LEN, Some(0)).unwrap() - } + #[inline] + pub fn len(&self) -> u32 { + self._tab + .get::(CryptoRandomValues::VT_LEN, Some(0)) + .unwrap() + } } pub struct CryptoRandomValuesArgs { @@ -6583,40 +6934,41 @@ pub struct CryptoRandomValuesArgs { impl<'a> Default for CryptoRandomValuesArgs { #[inline] fn default() -> Self { - CryptoRandomValuesArgs { - len: 0, - } + CryptoRandomValuesArgs { len: 0 } } } pub struct CryptoRandomValuesBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CryptoRandomValuesBuilder<'a, 'b> { - #[inline] - pub fn add_len(&mut self, len: u32) { - self.fbb_.push_slot::(CryptoRandomValues::VT_LEN, len, 0); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CryptoRandomValuesBuilder<'a, 'b> { - let start = _fbb.start_table(); - CryptoRandomValuesBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_len(&mut self, len: u32) { + self.fbb_ + .push_slot::(CryptoRandomValues::VT_LEN, len, 0); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> CryptoRandomValuesBuilder<'a, 'b> { + let start = _fbb.start_table(); + CryptoRandomValuesBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum CryptoRandomValuesReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct CryptoRandomValuesReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for CryptoRandomValuesReady<'a> { @@ -6632,67 +6984,76 @@ impl<'a> flatbuffers::Follow<'a> for CryptoRandomValuesReady<'a> { impl<'a> CryptoRandomValuesReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - CryptoRandomValuesReady { - _tab: table, - } + CryptoRandomValuesReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args CryptoRandomValuesReadyArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = CryptoRandomValuesReadyBuilder::new(_fbb); - if let Some(x) = args.buffer { builder.add_buffer(x); } - builder.finish() + args: &'args CryptoRandomValuesReadyArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = CryptoRandomValuesReadyBuilder::new(_fbb); + if let Some(x) = args.buffer { + builder.add_buffer(x); + } + builder.finish() } pub const VT_BUFFER: flatbuffers::VOffsetT = 4; - #[inline] - pub fn buffer(&self) -> Option<&'a [u8]> { - self._tab.get::>>(CryptoRandomValuesReady::VT_BUFFER, None).map(|v| v.safe_slice()) - } + #[inline] + pub fn buffer(&self) -> Option<&'a [u8]> { + self._tab + .get::>>( + CryptoRandomValuesReady::VT_BUFFER, + None, + ) + .map(|v| v.safe_slice()) + } } pub struct CryptoRandomValuesReadyArgs<'a> { - pub buffer: Option>>, + pub buffer: Option>>, } impl<'a> Default for CryptoRandomValuesReadyArgs<'a> { #[inline] fn default() -> Self { - CryptoRandomValuesReadyArgs { - buffer: None, - } + CryptoRandomValuesReadyArgs { buffer: None } } } pub struct CryptoRandomValuesReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> CryptoRandomValuesReadyBuilder<'a, 'b> { - #[inline] - pub fn add_buffer(&mut self, buffer: flatbuffers::WIPOffset>) { - self.fbb_.push_slot_always::>(CryptoRandomValuesReady::VT_BUFFER, buffer); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CryptoRandomValuesReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - CryptoRandomValuesReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_buffer(&mut self, buffer: flatbuffers::WIPOffset>) { + self.fbb_.push_slot_always::>( + CryptoRandomValuesReady::VT_BUFFER, + buffer, + ); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> CryptoRandomValuesReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + CryptoRandomValuesReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum FrameOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct Frame<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for Frame<'a> { @@ -6708,20 +7069,23 @@ impl<'a> flatbuffers::Follow<'a> for Frame<'a> { impl<'a> Frame<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - Frame { - _tab: table, - } + Frame { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args FrameArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = FrameBuilder::new(_fbb); - if let Some(x) = args.name { builder.add_name(x); } - if let Some(x) = args.filename { builder.add_filename(x); } - builder.add_col(args.col); - builder.add_line(args.line); - builder.finish() + args: &'args FrameArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = FrameBuilder::new(_fbb); + if let Some(x) = args.name { + builder.add_name(x); + } + if let Some(x) = args.filename { + builder.add_filename(x); + } + builder.add_col(args.col); + builder.add_line(args.line); + builder.finish() } pub const VT_LINE: flatbuffers::VOffsetT = 4; @@ -6729,29 +7093,31 @@ impl<'a> Frame<'a> { pub const VT_FILENAME: flatbuffers::VOffsetT = 8; pub const VT_NAME: flatbuffers::VOffsetT = 10; - #[inline] - pub fn line(&self) -> u32 { - self._tab.get::(Frame::VT_LINE, Some(0)).unwrap() - } - #[inline] - pub fn col(&self) -> u32 { - self._tab.get::(Frame::VT_COL, Some(0)).unwrap() - } - #[inline] - pub fn filename(&self) -> Option<&'a str> { - self._tab.get::>(Frame::VT_FILENAME, None) - } - #[inline] - pub fn name(&self) -> Option<&'a str> { - self._tab.get::>(Frame::VT_NAME, None) - } + #[inline] + pub fn line(&self) -> u32 { + self._tab.get::(Frame::VT_LINE, Some(0)).unwrap() + } + #[inline] + pub fn col(&self) -> u32 { + self._tab.get::(Frame::VT_COL, Some(0)).unwrap() + } + #[inline] + pub fn filename(&self) -> Option<&'a str> { + self._tab + .get::>(Frame::VT_FILENAME, None) + } + #[inline] + pub fn name(&self) -> Option<&'a str> { + self._tab + .get::>(Frame::VT_NAME, None) + } } pub struct FrameArgs<'a> { pub line: u32, pub col: u32, - pub filename: Option>, - pub name: Option>, + pub filename: Option>, + pub name: Option>, } impl<'a> Default for FrameArgs<'a> { #[inline] @@ -6765,46 +7131,48 @@ impl<'a> Default for FrameArgs<'a> { } } pub struct FrameBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> FrameBuilder<'a, 'b> { - #[inline] - pub fn add_line(&mut self, line: u32) { - self.fbb_.push_slot::(Frame::VT_LINE, line, 0); - } - #[inline] - pub fn add_col(&mut self, col: u32) { - self.fbb_.push_slot::(Frame::VT_COL, col, 0); - } - #[inline] - pub fn add_filename(&mut self, filename: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(Frame::VT_FILENAME, filename); - } - #[inline] - pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(Frame::VT_NAME, name); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FrameBuilder<'a, 'b> { - let start = _fbb.start_table(); - FrameBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_line(&mut self, line: u32) { + self.fbb_.push_slot::(Frame::VT_LINE, line, 0); + } + #[inline] + pub fn add_col(&mut self, col: u32) { + self.fbb_.push_slot::(Frame::VT_COL, col, 0); + } + #[inline] + pub fn add_filename(&mut self, filename: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(Frame::VT_FILENAME, filename); + } + #[inline] + pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) { + self.fbb_ + .push_slot_always::>(Frame::VT_NAME, name); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FrameBuilder<'a, 'b> { + let start = _fbb.start_table(); + FrameBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum SourceMapOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct SourceMap<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for SourceMap<'a> { @@ -6820,67 +7188,76 @@ impl<'a> flatbuffers::Follow<'a> for SourceMap<'a> { impl<'a> SourceMap<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SourceMap { - _tab: table, - } + SourceMap { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SourceMapArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = SourceMapBuilder::new(_fbb); - if let Some(x) = args.frames { builder.add_frames(x); } - builder.finish() + args: &'args SourceMapArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = SourceMapBuilder::new(_fbb); + if let Some(x) = args.frames { + builder.add_frames(x); + } + builder.finish() } pub const VT_FRAMES: flatbuffers::VOffsetT = 4; - #[inline] - pub fn frames(&self) -> Option>>> { - self._tab.get::>>>>(SourceMap::VT_FRAMES, None) - } + #[inline] + pub fn frames(&self) -> Option>>> { + self._tab.get::>>, + >>(SourceMap::VT_FRAMES, None) + } } pub struct SourceMapArgs<'a> { - pub frames: Option>>>>, + pub frames: Option< + flatbuffers::WIPOffset>>>, + >, } impl<'a> Default for SourceMapArgs<'a> { #[inline] fn default() -> Self { - SourceMapArgs { - frames: None, - } + SourceMapArgs { frames: None } } } pub struct SourceMapBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> SourceMapBuilder<'a, 'b> { - #[inline] - pub fn add_frames(&mut self, frames: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(SourceMap::VT_FRAMES, frames); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SourceMapBuilder<'a, 'b> { - let start = _fbb.start_table(); - SourceMapBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_frames( + &mut self, + frames: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(SourceMap::VT_FRAMES, frames); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SourceMapBuilder<'a, 'b> { + let start = _fbb.start_table(); + SourceMapBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum SourceMapReadyOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct SourceMapReady<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for SourceMapReady<'a> { @@ -6896,67 +7273,76 @@ impl<'a> flatbuffers::Follow<'a> for SourceMapReady<'a> { impl<'a> SourceMapReady<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - SourceMapReady { - _tab: table, - } + SourceMapReady { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args SourceMapReadyArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = SourceMapReadyBuilder::new(_fbb); - if let Some(x) = args.frames { builder.add_frames(x); } - builder.finish() + args: &'args SourceMapReadyArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = SourceMapReadyBuilder::new(_fbb); + if let Some(x) = args.frames { + builder.add_frames(x); + } + builder.finish() } pub const VT_FRAMES: flatbuffers::VOffsetT = 4; - #[inline] - pub fn frames(&self) -> Option>>> { - self._tab.get::>>>>(SourceMapReady::VT_FRAMES, None) - } + #[inline] + pub fn frames(&self) -> Option>>> { + self._tab.get::>>, + >>(SourceMapReady::VT_FRAMES, None) + } } pub struct SourceMapReadyArgs<'a> { - pub frames: Option>>>>, + pub frames: Option< + flatbuffers::WIPOffset>>>, + >, } impl<'a> Default for SourceMapReadyArgs<'a> { #[inline] fn default() -> Self { - SourceMapReadyArgs { - frames: None, - } + SourceMapReadyArgs { frames: None } } } pub struct SourceMapReadyBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> SourceMapReadyBuilder<'a, 'b> { - #[inline] - pub fn add_frames(&mut self, frames: flatbuffers::WIPOffset>>>) { - self.fbb_.push_slot_always::>(SourceMapReady::VT_FRAMES, frames); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SourceMapReadyBuilder<'a, 'b> { - let start = _fbb.start_table(); - SourceMapReadyBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_frames( + &mut self, + frames: flatbuffers::WIPOffset< + flatbuffers::Vector<'b, flatbuffers::ForwardsUOffset>>, + >, + ) { + self.fbb_ + .push_slot_always::>(SourceMapReady::VT_FRAMES, frames); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SourceMapReadyBuilder<'a, 'b> { + let start = _fbb.start_table(); + SourceMapReadyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum AddEventListenerOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct AddEventListener<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for AddEventListener<'a> { @@ -6972,25 +7358,26 @@ impl<'a> flatbuffers::Follow<'a> for AddEventListener<'a> { impl<'a> AddEventListener<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - AddEventListener { - _tab: table, - } + AddEventListener { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args AddEventListenerArgs) -> flatbuffers::WIPOffset> { - let mut builder = AddEventListenerBuilder::new(_fbb); - builder.add_event(args.event); - builder.finish() + args: &'args AddEventListenerArgs, + ) -> flatbuffers::WIPOffset> { + let mut builder = AddEventListenerBuilder::new(_fbb); + builder.add_event(args.event); + builder.finish() } pub const VT_EVENT: flatbuffers::VOffsetT = 4; - #[inline] - pub fn event(&self) -> EventType { - self._tab.get::(AddEventListener::VT_EVENT, Some(EventType::Fetch)).unwrap() - } + #[inline] + pub fn event(&self) -> EventType { + self._tab + .get::(AddEventListener::VT_EVENT, Some(EventType::Fetch)) + .unwrap() + } } pub struct AddEventListenerArgs { @@ -7005,34 +7392,37 @@ impl<'a> Default for AddEventListenerArgs { } } pub struct AddEventListenerBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> AddEventListenerBuilder<'a, 'b> { - #[inline] - pub fn add_event(&mut self, event: EventType) { - self.fbb_.push_slot::(AddEventListener::VT_EVENT, event, EventType::Fetch); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> AddEventListenerBuilder<'a, 'b> { - let start = _fbb.start_table(); - AddEventListenerBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_event(&mut self, event: EventType) { + self.fbb_ + .push_slot::(AddEventListener::VT_EVENT, event, EventType::Fetch); + } + #[inline] + pub fn new( + _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + ) -> AddEventListenerBuilder<'a, 'b> { + let start = _fbb.start_table(); + AddEventListenerBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum LoadModuleOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct LoadModule<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for LoadModule<'a> { @@ -7048,36 +7438,41 @@ impl<'a> flatbuffers::Follow<'a> for LoadModule<'a> { impl<'a> LoadModule<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - LoadModule { - _tab: table, - } + LoadModule { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args LoadModuleArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = LoadModuleBuilder::new(_fbb); - if let Some(x) = args.referer_origin_url { builder.add_referer_origin_url(x); } - if let Some(x) = args.specifier_url { builder.add_specifier_url(x); } - builder.finish() + args: &'args LoadModuleArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = LoadModuleBuilder::new(_fbb); + if let Some(x) = args.referer_origin_url { + builder.add_referer_origin_url(x); + } + if let Some(x) = args.specifier_url { + builder.add_specifier_url(x); + } + builder.finish() } pub const VT_SPECIFIER_URL: flatbuffers::VOffsetT = 4; pub const VT_REFERER_ORIGIN_URL: flatbuffers::VOffsetT = 6; - #[inline] - pub fn specifier_url(&self) -> Option<&'a str> { - self._tab.get::>(LoadModule::VT_SPECIFIER_URL, None) - } - #[inline] - pub fn referer_origin_url(&self) -> Option<&'a str> { - self._tab.get::>(LoadModule::VT_REFERER_ORIGIN_URL, None) - } + #[inline] + pub fn specifier_url(&self) -> Option<&'a str> { + self._tab + .get::>(LoadModule::VT_SPECIFIER_URL, None) + } + #[inline] + pub fn referer_origin_url(&self) -> Option<&'a str> { + self._tab + .get::>(LoadModule::VT_REFERER_ORIGIN_URL, None) + } } pub struct LoadModuleArgs<'a> { - pub specifier_url: Option>, - pub referer_origin_url: Option>, + pub specifier_url: Option>, + pub referer_origin_url: Option>, } impl<'a> Default for LoadModuleArgs<'a> { #[inline] @@ -7089,38 +7484,44 @@ impl<'a> Default for LoadModuleArgs<'a> { } } pub struct LoadModuleBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> LoadModuleBuilder<'a, 'b> { - #[inline] - pub fn add_specifier_url(&mut self, specifier_url: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(LoadModule::VT_SPECIFIER_URL, specifier_url); - } - #[inline] - pub fn add_referer_origin_url(&mut self, referer_origin_url: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(LoadModule::VT_REFERER_ORIGIN_URL, referer_origin_url); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LoadModuleBuilder<'a, 'b> { - let start = _fbb.start_table(); - LoadModuleBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_specifier_url(&mut self, specifier_url: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + LoadModule::VT_SPECIFIER_URL, + specifier_url, + ); + } + #[inline] + pub fn add_referer_origin_url(&mut self, referer_origin_url: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + LoadModule::VT_REFERER_ORIGIN_URL, + referer_origin_url, + ); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LoadModuleBuilder<'a, 'b> { + let start = _fbb.start_table(); + LoadModuleBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } pub enum LoadModuleRespOffset {} #[derive(Copy, Clone, Debug, PartialEq)] pub struct LoadModuleResp<'a> { - pub _tab: flatbuffers::Table<'a>, + pub _tab: flatbuffers::Table<'a>, } impl<'a> flatbuffers::Follow<'a> for LoadModuleResp<'a> { @@ -7136,36 +7537,41 @@ impl<'a> flatbuffers::Follow<'a> for LoadModuleResp<'a> { impl<'a> LoadModuleResp<'a> { #[inline] pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self { - LoadModuleResp { - _tab: table, - } + LoadModuleResp { _tab: table } } #[allow(unused_mut)] pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, - args: &'args LoadModuleRespArgs<'args>) -> flatbuffers::WIPOffset> { - let mut builder = LoadModuleRespBuilder::new(_fbb); - if let Some(x) = args.source_code { builder.add_source_code(x); } - if let Some(x) = args.origin_url { builder.add_origin_url(x); } - builder.finish() + args: &'args LoadModuleRespArgs<'args>, + ) -> flatbuffers::WIPOffset> { + let mut builder = LoadModuleRespBuilder::new(_fbb); + if let Some(x) = args.source_code { + builder.add_source_code(x); + } + if let Some(x) = args.origin_url { + builder.add_origin_url(x); + } + builder.finish() } pub const VT_ORIGIN_URL: flatbuffers::VOffsetT = 4; pub const VT_SOURCE_CODE: flatbuffers::VOffsetT = 6; - #[inline] - pub fn origin_url(&self) -> Option<&'a str> { - self._tab.get::>(LoadModuleResp::VT_ORIGIN_URL, None) - } - #[inline] - pub fn source_code(&self) -> Option<&'a str> { - self._tab.get::>(LoadModuleResp::VT_SOURCE_CODE, None) - } + #[inline] + pub fn origin_url(&self) -> Option<&'a str> { + self._tab + .get::>(LoadModuleResp::VT_ORIGIN_URL, None) + } + #[inline] + pub fn source_code(&self) -> Option<&'a str> { + self._tab + .get::>(LoadModuleResp::VT_SOURCE_CODE, None) + } } pub struct LoadModuleRespArgs<'a> { - pub origin_url: Option>, - pub source_code: Option>, + pub origin_url: Option>, + pub source_code: Option>, } impl<'a> Default for LoadModuleRespArgs<'a> { #[inline] @@ -7177,51 +7583,61 @@ impl<'a> Default for LoadModuleRespArgs<'a> { } } pub struct LoadModuleRespBuilder<'a: 'b, 'b> { - fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, - start_: flatbuffers::WIPOffset, + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, } impl<'a: 'b, 'b> LoadModuleRespBuilder<'a, 'b> { - #[inline] - pub fn add_origin_url(&mut self, origin_url: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(LoadModuleResp::VT_ORIGIN_URL, origin_url); - } - #[inline] - pub fn add_source_code(&mut self, source_code: flatbuffers::WIPOffset<&'b str>) { - self.fbb_.push_slot_always::>(LoadModuleResp::VT_SOURCE_CODE, source_code); - } - #[inline] - pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LoadModuleRespBuilder<'a, 'b> { - let start = _fbb.start_table(); - LoadModuleRespBuilder { - fbb_: _fbb, - start_: start, - } - } - #[inline] - pub fn finish(self) -> flatbuffers::WIPOffset> { - let o = self.fbb_.end_table(self.start_); - flatbuffers::WIPOffset::new(o.value()) - } + #[inline] + pub fn add_origin_url(&mut self, origin_url: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + LoadModuleResp::VT_ORIGIN_URL, + origin_url, + ); + } + #[inline] + pub fn add_source_code(&mut self, source_code: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>( + LoadModuleResp::VT_SOURCE_CODE, + source_code, + ); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LoadModuleRespBuilder<'a, 'b> { + let start = _fbb.start_table(); + LoadModuleRespBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } } #[inline] pub fn get_root_as_base<'a>(buf: &'a [u8]) -> Base<'a> { - flatbuffers::get_root::>(buf) + flatbuffers::get_root::>(buf) } #[inline] pub fn get_size_prefixed_root_as_base<'a>(buf: &'a [u8]) -> Base<'a> { - flatbuffers::get_size_prefixed_root::>(buf) + flatbuffers::get_size_prefixed_root::>(buf) } #[inline] pub fn finish_base_buffer<'a, 'b>( fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, - root: flatbuffers::WIPOffset>) { - fbb.finish(root, None); + root: flatbuffers::WIPOffset>, +) { + fbb.finish(root, None); } #[inline] -pub fn finish_size_prefixed_base_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset>) { - fbb.finish_size_prefixed(root, None); +pub fn finish_size_prefixed_base_buffer<'a, 'b>( + fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + root: flatbuffers::WIPOffset>, +) { + fbb.finish_size_prefixed(root, None); } diff --git a/src/ops/cache.rs b/src/ops/cache.rs index 27755ff..7ed147e 100644 --- a/src/ops/cache.rs +++ b/src/ops/cache.rs @@ -16,210 +16,213 @@ use crate::cache_store::*; use crate::cache_store_notifier::*; pub fn op_cache_del(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_cache_del().unwrap(); - let key = msg.key().unwrap().to_string(); + let msg = base.msg_as_cache_del().unwrap(); + let key = msg.key().unwrap().to_string(); - rt.spawn( - rt.cache_store - .del(key) - .map_err(|e| error!("error cache del future! {:?}", e)), - ); + rt.spawn( + rt.cache_store + .del(key) + .map_err(|e| error!("error cache del future! {:?}", e)), + ); - ok_future(None) + ok_future(None) } pub fn op_cache_expire(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_cache_expire().unwrap(); - let key = msg.key().unwrap().to_string(); - let ttl = msg.ttl(); + let msg = base.msg_as_cache_expire().unwrap(); + let key = msg.key().unwrap().to_string(); + let ttl = msg.ttl(); - rt.spawn( - rt.cache_store - .expire(key, ttl) - .map_err(|e| error!("error cache expire future! {:?}", e)), - ); + rt.spawn( + rt.cache_store + .expire(key, ttl) + .map_err(|e| error!("error cache expire future! {:?}", e)), + ); - ok_future(None) + ok_future(None) } pub fn op_cache_set(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let cmd_id = base.cmd_id(); - let msg = base.msg_as_cache_set().unwrap(); - let key = msg.key().unwrap().to_string(); - - let stream_id = get_next_stream_id(); - - let (sender, recver) = mpsc::unbounded::>(); - { - rt.streams.lock().unwrap().insert(stream_id, sender); - } - - let ttl = if msg.ttl() == 0 { - None - } else { - Some(msg.ttl()) - }; - - let tags = match msg.tags() { - Some(raw_tags) => { - let mut tags: Vec = vec![]; - for i in 0..raw_tags.len() { - tags.push(i.to_string()); - } - Some(tags) + let cmd_id = base.cmd_id(); + let msg = base.msg_as_cache_set().unwrap(); + let key = msg.key().unwrap().to_string(); + + let stream_id = get_next_stream_id(); + + let (sender, recver) = mpsc::unbounded::>(); + { + rt.streams.lock().unwrap().insert(stream_id, sender); } - None => None, - }; - - let meta = match msg.meta() { - Some(m) => Some(m.to_string()), - None => None, - }; - - let fut = rt - .cache_store - .set(key, Box::new(recver), CacheSetOptions { ttl, tags, meta }); - - rt.spawn( - fut - .map_err(|e| error!("error cache set stream! {:?}", e)) - .and_then(move |_b| Ok(())), - ); - - let builder = &mut FlatBufferBuilder::new(); - let msg = msg::CacheSetReady::create( - builder, - &msg::CacheSetReadyArgs { - id: stream_id, - ..Default::default() - }, - ); - ok_future(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - msg: Some(msg.as_union_value()), - msg_type: msg::Any::CacheSetReady, - ..Default::default() - }, - )) -} -pub fn op_cache_get(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let cmd_id = base.cmd_id(); - let msg = base.msg_as_cache_get().unwrap(); - - let stream_id = get_next_stream_id(); - - let key = msg.key().unwrap().to_string(); - let ptr = rt.ptr; - - Box::new( - rt.cache_store - .get(key) - .map_err(|e| format!("cache error: {:?}", e).into()) - .and_then(move |maybe_entry| { - let builder = &mut FlatBufferBuilder::new(); - let meta = if let Some(ref entry) = maybe_entry { - match entry.meta { - Some(ref m) => Some(builder.create_string(m.as_str())), - None => None, - } - } else { - None - }; - let msg = msg::CacheGetReady::create( - builder, - &msg::CacheGetReadyArgs { + let ttl = if msg.ttl() == 0 { + None + } else { + Some(msg.ttl()) + }; + + let tags = match msg.tags() { + Some(raw_tags) => { + let mut tags: Vec = vec![]; + for i in 0..raw_tags.len() { + tags.push(i.to_string()); + } + Some(tags) + } + None => None, + }; + + let meta = match msg.meta() { + Some(m) => Some(m.to_string()), + None => None, + }; + + let fut = rt + .cache_store + .set(key, Box::new(recver), CacheSetOptions { ttl, tags, meta }); + + rt.spawn( + fut.map_err(|e| error!("error cache set stream! {:?}", e)) + .and_then(move |_b| Ok(())), + ); + + let builder = &mut FlatBufferBuilder::new(); + let msg = msg::CacheSetReady::create( + builder, + &msg::CacheSetReadyArgs { id: stream_id, - meta, - stream: maybe_entry.is_some(), ..Default::default() - }, - ); - if let Some(entry) = maybe_entry { - send_body_stream( - ptr, - stream_id, - JsBody::BoxedStream(Box::new( - entry.stream.map_err(|e| format!("{:?}", e).into()), - )), - ); - } - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { + }, + ); + ok_future(serialize_response( + cmd_id, + builder, + msg::BaseArgs { msg: Some(msg.as_union_value()), - msg_type: msg::Any::CacheGetReady, + msg_type: msg::Any::CacheSetReady, ..Default::default() - }, - )) - }), - ) + }, + )) +} + +pub fn op_cache_get(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { + let cmd_id = base.cmd_id(); + let msg = base.msg_as_cache_get().unwrap(); + + let stream_id = get_next_stream_id(); + + let key = msg.key().unwrap().to_string(); + let ptr = rt.ptr; + + Box::new( + rt.cache_store + .get(key) + .map_err(|e| format!("cache error: {:?}", e).into()) + .and_then(move |maybe_entry| { + let builder = &mut FlatBufferBuilder::new(); + let meta = if let Some(ref entry) = maybe_entry { + match entry.meta { + Some(ref m) => Some(builder.create_string(m.as_str())), + None => None, + } + } else { + None + }; + let msg = msg::CacheGetReady::create( + builder, + &msg::CacheGetReadyArgs { + id: stream_id, + meta, + stream: maybe_entry.is_some(), + ..Default::default() + }, + ); + if let Some(entry) = maybe_entry { + send_body_stream( + ptr, + stream_id, + JsBody::BoxedStream(Box::new( + entry.stream.map_err(|e| format!("{:?}", e).into()), + )), + ); + } + Ok(serialize_response( + cmd_id, + builder, + msg::BaseArgs { + msg: Some(msg.as_union_value()), + msg_type: msg::Any::CacheGetReady, + ..Default::default() + }, + )) + }), + ) } pub fn op_cache_notify_del(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_cache_notify_del().unwrap(); - - let key = msg.key().unwrap().to_string(); - - Box::new( - rt.cache_store - .notify(CacheOperation::Del, key) - .map_err(|e| match e { - CacheStoreNotifierError::Unknown => "cache notifier unknown error".to_string().into(), - CacheStoreNotifierError::Failure(s) => s.into(), - CacheStoreNotifierError::Unavailable => { - "cache notifications is not available".to_string().into() - } - }) - .and_then(|_| Ok(None)), - ) + let msg = base.msg_as_cache_notify_del().unwrap(); + + let key = msg.key().unwrap().to_string(); + + Box::new( + rt.cache_store + .notify(CacheOperation::Del, key) + .map_err(|e| match e { + CacheStoreNotifierError::Unknown => { + "cache notifier unknown error".to_string().into() + } + CacheStoreNotifierError::Failure(s) => s.into(), + CacheStoreNotifierError::Unavailable => { + "cache notifications is not available".to_string().into() + } + }) + .and_then(|_| Ok(None)), + ) } pub fn op_cache_notify_purge_tag(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_cache_notify_purge_tag().unwrap(); - - let tag = msg.tag().unwrap().to_string(); - - Box::new( - rt.cache_store - .notify(CacheOperation::PurgeTag, tag) - .map_err(|e| match e { - CacheStoreNotifierError::Unknown => "cache notifier unknown error".to_string().into(), - CacheStoreNotifierError::Failure(s) => s.into(), - CacheStoreNotifierError::Unavailable => { - "cache notifications is not available".to_string().into() - } - }) - .and_then(|_| Ok(None)), - ) + let msg = base.msg_as_cache_notify_purge_tag().unwrap(); + + let tag = msg.tag().unwrap().to_string(); + + Box::new( + rt.cache_store + .notify(CacheOperation::PurgeTag, tag) + .map_err(|e| match e { + CacheStoreNotifierError::Unknown => { + "cache notifier unknown error".to_string().into() + } + CacheStoreNotifierError::Failure(s) => s.into(), + CacheStoreNotifierError::Unavailable => { + "cache notifications is not available".to_string().into() + } + }) + .and_then(|_| Ok(None)), + ) } pub fn op_cache_set_meta(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_cache_set_meta().unwrap(); - let key = msg.key().unwrap().to_string(); - let meta = msg.meta().unwrap().to_string(); + let msg = base.msg_as_cache_set_meta().unwrap(); + let key = msg.key().unwrap().to_string(); + let meta = msg.meta().unwrap().to_string(); - rt.spawn( - rt.cache_store - .set_meta(key, meta) - .map_err(|e| error!("error cache set_meta future! {:?}", e)), - ); + rt.spawn( + rt.cache_store + .set_meta(key, meta) + .map_err(|e| error!("error cache set_meta future! {:?}", e)), + ); - ok_future(None) + ok_future(None) } pub fn op_cache_purge_tag(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_cache_purge_tag().unwrap(); - let tag = msg.tag().unwrap().to_string(); + let msg = base.msg_as_cache_purge_tag().unwrap(); + let tag = msg.tag().unwrap().to_string(); - rt.spawn( - rt.cache_store - .purge_tag(tag) - .map_err(|e| error!("error cache purge_tag future! {:?}", e)), - ); + rt.spawn( + rt.cache_store + .purge_tag(tag) + .map_err(|e| error!("error cache purge_tag future! {:?}", e)), + ); - ok_future(None) + ok_future(None) } diff --git a/src/ops/dns.rs b/src/ops/dns.rs index 4427173..c77cb71 100644 --- a/src/ops/dns.rs +++ b/src/ops/dns.rs @@ -19,350 +19,266 @@ use std::net::{SocketAddr, ToSocketAddrs}; use crate::js::*; lazy_static! { - static ref DEFAULT_RESOLVER_CONFIG: ResolverConfig = { - match trust_dns_resolver::system_conf::read_system_conf() { - Ok((r, _)) => r, - Err(e) => { - warn!("error getting system resolv conf: {}, using google's", e); - ResolverConfig::google() - } - } - }; - static ref DEFAULT_RESOLVER: Mutex> = { - let stream = - trust_dns::udp::UdpClientStream::new(DEFAULT_RESOLVER_CONFIG.name_servers()[0].socket_addr); - let (bg, client) = trust_dns::client::ClientFuture::connect(stream); - EVENT_LOOP.0.spawn(bg); - Mutex::new(client) - }; - static ref DNS_RESOLVERS: Mutex>> = - Mutex::new(HashMap::new()); + static ref DEFAULT_RESOLVER_CONFIG: ResolverConfig = { + match trust_dns_resolver::system_conf::read_system_conf() { + Ok((r, _)) => r, + Err(e) => { + warn!("error getting system resolv conf: {}, using google's", e); + ResolverConfig::google() + } + } + }; + static ref DEFAULT_RESOLVER: Mutex> = { + let stream = trust_dns::udp::UdpClientStream::new( + DEFAULT_RESOLVER_CONFIG.name_servers()[0].socket_addr, + ); + let (bg, client) = trust_dns::client::ClientFuture::connect(stream); + EVENT_LOOP.0.spawn(bg); + Mutex::new(client) + }; + static ref DNS_RESOLVERS: Mutex>> = + Mutex::new(HashMap::new()); } fn dns_query( - cmd_id: u32, - client: &mut trust_dns::client::BasicClientHandle, - name: &str, - query_type: trust_dns::rr::RecordType, + cmd_id: u32, + client: &mut trust_dns::client::BasicClientHandle, + name: &str, + query_type: trust_dns::rr::RecordType, ) -> Box { - debug!("dns_query {} {}", cmd_id, name); - Box::new( - client - .query( - name.parse().unwrap(), - trust_dns::rr::DNSClass::IN, - query_type, - ) - .map_err(|e| format!("dns query error: {}", e).into()) - .and_then(move |res| { - // debug!("got a dns response! {:?}", res); - for q in res.queries() { - debug!("queried: {:?}", q); - } - let builder = &mut FlatBufferBuilder::new(); - let answers: Vec<_> = res - .answers() - .iter() - .map(|ans| { - debug!("answer: {:?}", ans); - use trust_dns::rr::{DNSClass, RData, RecordType}; - let name = builder.create_string(&ans.name().to_utf8()); - let rr_type = match ans.rr_type() { - RecordType::A => msg::DnsRecordType::A, - RecordType::AAAA => msg::DnsRecordType::AAAA, - RecordType::AXFR => msg::DnsRecordType::AXFR, - RecordType::CAA => msg::DnsRecordType::CAA, - RecordType::CNAME => msg::DnsRecordType::CNAME, - RecordType::IXFR => msg::DnsRecordType::IXFR, - RecordType::MX => msg::DnsRecordType::MX, - RecordType::NS => msg::DnsRecordType::NS, - RecordType::NULL => msg::DnsRecordType::NULL, - RecordType::OPT => msg::DnsRecordType::OPT, - RecordType::PTR => msg::DnsRecordType::PTR, - RecordType::SOA => msg::DnsRecordType::SOA, - RecordType::SRV => msg::DnsRecordType::SRV, - RecordType::TLSA => msg::DnsRecordType::TLSA, - RecordType::TXT => msg::DnsRecordType::TXT, - _ => unimplemented!(), - }; - let dns_class = match ans.dns_class() { - DNSClass::IN => msg::DnsClass::IN, - DNSClass::CH => msg::DnsClass::CH, - DNSClass::HS => msg::DnsClass::HS, - DNSClass::NONE => msg::DnsClass::NONE, - DNSClass::ANY => msg::DnsClass::ANY, - _ => unimplemented!(), - }; - let rdata_type = match ans.rdata() { - RData::A(_) => msg::DnsRecordData::DnsA, - RData::AAAA(_) => msg::DnsRecordData::DnsAaaa, - RData::CNAME(_) => msg::DnsRecordData::DnsCname, - RData::MX(_) => msg::DnsRecordData::DnsMx, - RData::NS(_) => msg::DnsRecordData::DnsNs, - RData::PTR(_) => msg::DnsRecordData::DnsPtr, - RData::SOA(_) => msg::DnsRecordData::DnsSoa, - RData::SRV(_) => msg::DnsRecordData::DnsSrv, - RData::TXT(_) => msg::DnsRecordData::DnsTxt, - _ => unimplemented!(), - }; - let rdata = match ans.rdata() { - RData::A(ip) => { - let ipstr = builder.create_string(&ip.to_string()); - msg::DnsA::create( - builder, - &msg::DnsAArgs { - ip: Some(ipstr), - ..Default::default() - }, - ) - .as_union_value() - } - RData::AAAA(ip) => { - let ipstr = builder.create_string(&ip.to_string()); - msg::DnsAaaa::create( - builder, - &msg::DnsAaaaArgs { - ip: Some(ipstr), - ..Default::default() - }, - ) - .as_union_value() - } - RData::CNAME(name) => { - let namestr = builder.create_string(&name.to_utf8()); - msg::DnsCname::create( - builder, - &msg::DnsCnameArgs { - name: Some(namestr), - ..Default::default() - }, - ) - .as_union_value() - } - RData::MX(mx) => { - let exstr = builder.create_string(&mx.exchange().to_utf8()); - msg::DnsMx::create( - builder, - &msg::DnsMxArgs { - exchange: Some(exstr), - preference: mx.preference(), - ..Default::default() - }, - ) - .as_union_value() - } - RData::NS(name) => { - let namestr = builder.create_string(&name.to_utf8()); - msg::DnsNs::create( - builder, - &msg::DnsNsArgs { - name: Some(namestr), - ..Default::default() - }, - ) - .as_union_value() - } - RData::PTR(name) => { - let namestr = builder.create_string(&name.to_utf8()); - msg::DnsPtr::create( - builder, - &msg::DnsPtrArgs { - name: Some(namestr), - ..Default::default() - }, - ) - .as_union_value() - } - RData::SOA(soa) => { - let mnamestr = builder.create_string(&soa.mname().to_utf8()); - let rnamestr = builder.create_string(&soa.rname().to_utf8()); - msg::DnsSoa::create( - builder, - &msg::DnsSoaArgs { - mname: Some(mnamestr), - rname: Some(rnamestr), - serial: soa.serial(), - refresh: soa.refresh(), - retry: soa.retry(), - expire: soa.expire(), - minimum: soa.minimum(), - ..Default::default() - }, - ) - .as_union_value() - } - RData::SRV(srv) => { - let targetstr = builder.create_string(&srv.target().to_utf8()); - msg::DnsSrv::create( - builder, - &msg::DnsSrvArgs { - priority: srv.priority(), - weight: srv.weight(), - port: srv.port(), - target: Some(targetstr), - ..Default::default() - }, - ) - .as_union_value() - } - RData::TXT(txt) => { - let coll: Vec<_> = txt - .iter() - .map(|t| { - let d = builder.create_vector(&Vec::from(t.clone())); - msg::DnsTxtData::create( - builder, - &msg::DnsTxtDataArgs { - data: Some(d), - ..Default::default() - }, - ) - }) - .collect(); - let data = builder.create_vector(&coll); - msg::DnsTxt::create( - builder, - &msg::DnsTxtArgs { - data: Some(data), - ..Default::default() - }, - ) - .as_union_value() - } - _ => unimplemented!(), - }; - msg::DnsRecord::create( - builder, - &msg::DnsRecordArgs { - name: Some(name), - rr_type: rr_type, - dns_class: dns_class, - ttl: ans.ttl(), - rdata_type: rdata_type, - rdata: Some(rdata), - ..Default::default() - }, + debug!("dns_query {} {}", cmd_id, name); + Box::new( + client + .query( + name.parse().unwrap(), + trust_dns::rr::DNSClass::IN, + query_type, ) - }) - .collect(); - let res_answers = builder.create_vector(&answers); - let dns_msg = msg::DnsResponse::create( - builder, - &msg::DnsResponseArgs { - op_code: msg::DnsOpCode::Query, - message_type: msg::DnsMessageType::Response, - authoritative: res.authoritative(), - truncated: res.truncated(), - // response_code: , - answers: Some(res_answers), - // done: body.is_end_stream(), - ..Default::default() - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - msg: Some(dns_msg.as_union_value()), - msg_type: msg::Any::DnsResponse, - ..Default::default() - }, - )) - }), - ) -} - -pub fn op_dns_query(_rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - debug!("handle dns"); - let cmd_id = base.cmd_id(); - let msg = base.msg_as_dns_query().unwrap(); - - let query_type = match msg.rr_type() { - msg::DnsRecordType::A => trust_dns::rr::RecordType::A, - msg::DnsRecordType::AAAA => trust_dns::rr::RecordType::AAAA, - msg::DnsRecordType::ANY => trust_dns::rr::RecordType::ANY, - msg::DnsRecordType::AXFR => trust_dns::rr::RecordType::AXFR, - msg::DnsRecordType::CAA => trust_dns::rr::RecordType::CAA, - msg::DnsRecordType::CNAME => trust_dns::rr::RecordType::CNAME, - msg::DnsRecordType::IXFR => trust_dns::rr::RecordType::IXFR, - msg::DnsRecordType::MX => trust_dns::rr::RecordType::MX, - msg::DnsRecordType::NS => trust_dns::rr::RecordType::NS, - msg::DnsRecordType::NULL => trust_dns::rr::RecordType::NULL, - msg::DnsRecordType::OPT => trust_dns::rr::RecordType::OPT, - msg::DnsRecordType::PTR => trust_dns::rr::RecordType::PTR, - msg::DnsRecordType::SOA => trust_dns::rr::RecordType::SOA, - msg::DnsRecordType::SRV => trust_dns::rr::RecordType::SRV, - msg::DnsRecordType::TLSA => trust_dns::rr::RecordType::TLSA, - msg::DnsRecordType::TXT => trust_dns::rr::RecordType::TXT, - }; - - let name = msg.name().unwrap(); - - if let Some(nss) = msg.name_servers() { - let ns = { - let ns = nss.get(0); - if ns.contains(":") { - ns.to_string() - } else { - format!("{}:53", ns) - } - }; - let sockaddr = ns.to_socket_addrs().unwrap().next().unwrap(); - { - if let Some(client) = DNS_RESOLVERS.lock().unwrap().get_mut(&sockaddr) { - return dns_query(cmd_id, client, name, query_type); - } - } - let stream = trust_dns::udp::UdpClientStream::new(sockaddr.clone()); - let (bg, client) = trust_dns::client::ClientFuture::connect(stream); - EVENT_LOOP.0.spawn(bg); - { - DNS_RESOLVERS - .lock() - .unwrap() - .insert(sockaddr.clone(), client); - } - debug!("INSERTED DNS RESOLVER"); - dns_query( - cmd_id, - DNS_RESOLVERS.lock().unwrap().get_mut(&sockaddr).unwrap(), - name, - query_type, + .map_err(|e| format!("dns query error: {}", e).into()) + .and_then(move |res| { + // debug!("got a dns response! {:?}", res); + for q in res.queries() { + debug!("queried: {:?}", q); + } + let builder = &mut FlatBufferBuilder::new(); + let answers: Vec<_> = res + .answers() + .iter() + .map(|ans| { + debug!("answer: {:?}", ans); + use trust_dns::rr::{DNSClass, RData, RecordType}; + let name = builder.create_string(&ans.name().to_utf8()); + let rr_type = match ans.rr_type() { + RecordType::A => msg::DnsRecordType::A, + RecordType::AAAA => msg::DnsRecordType::AAAA, + RecordType::AXFR => msg::DnsRecordType::AXFR, + RecordType::CAA => msg::DnsRecordType::CAA, + RecordType::CNAME => msg::DnsRecordType::CNAME, + RecordType::IXFR => msg::DnsRecordType::IXFR, + RecordType::MX => msg::DnsRecordType::MX, + RecordType::NS => msg::DnsRecordType::NS, + RecordType::NULL => msg::DnsRecordType::NULL, + RecordType::OPT => msg::DnsRecordType::OPT, + RecordType::PTR => msg::DnsRecordType::PTR, + RecordType::SOA => msg::DnsRecordType::SOA, + RecordType::SRV => msg::DnsRecordType::SRV, + RecordType::TLSA => msg::DnsRecordType::TLSA, + RecordType::TXT => msg::DnsRecordType::TXT, + _ => unimplemented!(), + }; + let dns_class = match ans.dns_class() { + DNSClass::IN => msg::DnsClass::IN, + DNSClass::CH => msg::DnsClass::CH, + DNSClass::HS => msg::DnsClass::HS, + DNSClass::NONE => msg::DnsClass::NONE, + DNSClass::ANY => msg::DnsClass::ANY, + _ => unimplemented!(), + }; + let rdata_type = match ans.rdata() { + RData::A(_) => msg::DnsRecordData::DnsA, + RData::AAAA(_) => msg::DnsRecordData::DnsAaaa, + RData::CNAME(_) => msg::DnsRecordData::DnsCname, + RData::MX(_) => msg::DnsRecordData::DnsMx, + RData::NS(_) => msg::DnsRecordData::DnsNs, + RData::PTR(_) => msg::DnsRecordData::DnsPtr, + RData::SOA(_) => msg::DnsRecordData::DnsSoa, + RData::SRV(_) => msg::DnsRecordData::DnsSrv, + RData::TXT(_) => msg::DnsRecordData::DnsTxt, + _ => unimplemented!(), + }; + let rdata = match ans.rdata() { + RData::A(ip) => { + let ipstr = builder.create_string(&ip.to_string()); + msg::DnsA::create( + builder, + &msg::DnsAArgs { + ip: Some(ipstr), + ..Default::default() + }, + ) + .as_union_value() + } + RData::AAAA(ip) => { + let ipstr = builder.create_string(&ip.to_string()); + msg::DnsAaaa::create( + builder, + &msg::DnsAaaaArgs { + ip: Some(ipstr), + ..Default::default() + }, + ) + .as_union_value() + } + RData::CNAME(name) => { + let namestr = builder.create_string(&name.to_utf8()); + msg::DnsCname::create( + builder, + &msg::DnsCnameArgs { + name: Some(namestr), + ..Default::default() + }, + ) + .as_union_value() + } + RData::MX(mx) => { + let exstr = builder.create_string(&mx.exchange().to_utf8()); + msg::DnsMx::create( + builder, + &msg::DnsMxArgs { + exchange: Some(exstr), + preference: mx.preference(), + ..Default::default() + }, + ) + .as_union_value() + } + RData::NS(name) => { + let namestr = builder.create_string(&name.to_utf8()); + msg::DnsNs::create( + builder, + &msg::DnsNsArgs { + name: Some(namestr), + ..Default::default() + }, + ) + .as_union_value() + } + RData::PTR(name) => { + let namestr = builder.create_string(&name.to_utf8()); + msg::DnsPtr::create( + builder, + &msg::DnsPtrArgs { + name: Some(namestr), + ..Default::default() + }, + ) + .as_union_value() + } + RData::SOA(soa) => { + let mnamestr = builder.create_string(&soa.mname().to_utf8()); + let rnamestr = builder.create_string(&soa.rname().to_utf8()); + msg::DnsSoa::create( + builder, + &msg::DnsSoaArgs { + mname: Some(mnamestr), + rname: Some(rnamestr), + serial: soa.serial(), + refresh: soa.refresh(), + retry: soa.retry(), + expire: soa.expire(), + minimum: soa.minimum(), + ..Default::default() + }, + ) + .as_union_value() + } + RData::SRV(srv) => { + let targetstr = builder.create_string(&srv.target().to_utf8()); + msg::DnsSrv::create( + builder, + &msg::DnsSrvArgs { + priority: srv.priority(), + weight: srv.weight(), + port: srv.port(), + target: Some(targetstr), + ..Default::default() + }, + ) + .as_union_value() + } + RData::TXT(txt) => { + let coll: Vec<_> = txt + .iter() + .map(|t| { + let d = builder.create_vector(&Vec::from(t.clone())); + msg::DnsTxtData::create( + builder, + &msg::DnsTxtDataArgs { + data: Some(d), + ..Default::default() + }, + ) + }) + .collect(); + let data = builder.create_vector(&coll); + msg::DnsTxt::create( + builder, + &msg::DnsTxtArgs { + data: Some(data), + ..Default::default() + }, + ) + .as_union_value() + } + _ => unimplemented!(), + }; + msg::DnsRecord::create( + builder, + &msg::DnsRecordArgs { + name: Some(name), + rr_type: rr_type, + dns_class: dns_class, + ttl: ans.ttl(), + rdata_type: rdata_type, + rdata: Some(rdata), + ..Default::default() + }, + ) + }) + .collect(); + let res_answers = builder.create_vector(&answers); + let dns_msg = msg::DnsResponse::create( + builder, + &msg::DnsResponseArgs { + op_code: msg::DnsOpCode::Query, + message_type: msg::DnsMessageType::Response, + authoritative: res.authoritative(), + truncated: res.truncated(), + // response_code: , + answers: Some(res_answers), + // done: body.is_end_stream(), + ..Default::default() + }, + ); + Ok(serialize_response( + cmd_id, + builder, + msg::BaseArgs { + msg: Some(dns_msg.as_union_value()), + msg_type: msg::Any::DnsResponse, + ..Default::default() + }, + )) + }), ) - // } - } else { - let mut client = DEFAULT_RESOLVER.lock().unwrap(); - dns_query(cmd_id, &mut client, name, query_type) - } } -pub fn op_dns_response(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { - let msg = base.msg_as_dns_response().unwrap(); - let req_id = msg.id(); - - let op_code = match msg.op_code() { - msg::DnsOpCode::Query => trust_dns::op::OpCode::Query, - msg::DnsOpCode::Status => trust_dns::op::OpCode::Status, - msg::DnsOpCode::Notify => trust_dns::op::OpCode::Notify, - msg::DnsOpCode::Update => trust_dns::op::OpCode::Update, - }; - - let res_code = msg.response_code() as u16; - - let message_type = match msg.message_type() { - msg::DnsMessageType::Query => trust_dns::op::MessageType::Query, - msg::DnsMessageType::Response => trust_dns::op::MessageType::Response, - }; - - use trust_dns::rr::RData; - - let queries: Vec = if let Some(msg_queries) = msg.queries() { - let qlen = msg_queries.len(); - let mut queries: Vec = Vec::with_capacity(qlen); - for i in 0..qlen { - let q = msg_queries.get(i); +pub fn op_dns_query(_rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { + debug!("handle dns"); + let cmd_id = base.cmd_id(); + let msg = base.msg_as_dns_query().unwrap(); - let rr_type = match q.rr_type() { + let query_type = match msg.rr_type() { msg::DnsRecordType::A => trust_dns::rr::RecordType::A, msg::DnsRecordType::AAAA => trust_dns::rr::RecordType::AAAA, msg::DnsRecordType::ANY => trust_dns::rr::RecordType::ANY, @@ -379,133 +295,218 @@ pub fn op_dns_response(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box msg::DnsRecordType::SRV => trust_dns::rr::RecordType::SRV, msg::DnsRecordType::TLSA => trust_dns::rr::RecordType::TLSA, msg::DnsRecordType::TXT => trust_dns::rr::RecordType::TXT, - }; + }; - let dns_class = match q.dns_class() { - msg::DnsClass::IN => trust_dns::rr::DNSClass::IN, - msg::DnsClass::CH => trust_dns::rr::DNSClass::CH, - msg::DnsClass::HS => trust_dns::rr::DNSClass::HS, - msg::DnsClass::NONE => trust_dns::rr::DNSClass::NONE, - msg::DnsClass::ANY => trust_dns::rr::DNSClass::ANY, - }; + let name = msg.name().unwrap(); - queries.push(JsDnsQuery { - name: q.name().unwrap().parse().unwrap(), - rr_type: rr_type, - dns_class: dns_class, - }); + if let Some(nss) = msg.name_servers() { + let ns = { + let ns = nss.get(0); + if ns.contains(":") { + ns.to_string() + } else { + format!("{}:53", ns) + } + }; + let sockaddr = ns.to_socket_addrs().unwrap().next().unwrap(); + { + if let Some(client) = DNS_RESOLVERS.lock().unwrap().get_mut(&sockaddr) { + return dns_query(cmd_id, client, name, query_type); + } + } + let stream = trust_dns::udp::UdpClientStream::new(sockaddr.clone()); + let (bg, client) = trust_dns::client::ClientFuture::connect(stream); + EVENT_LOOP.0.spawn(bg); + { + DNS_RESOLVERS + .lock() + .unwrap() + .insert(sockaddr.clone(), client); + } + debug!("INSERTED DNS RESOLVER"); + dns_query( + cmd_id, + DNS_RESOLVERS.lock().unwrap().get_mut(&sockaddr).unwrap(), + name, + query_type, + ) + // } + } else { + let mut client = DEFAULT_RESOLVER.lock().unwrap(); + dns_query(cmd_id, &mut client, name, query_type) } - vec![] - } else { - vec![] - }; +} - let answers = if let Some(msg_answers) = msg.answers() { - let anslen = msg_answers.len(); - let mut answers: Vec = Vec::with_capacity(anslen); - for i in 0..anslen { - let ans = msg_answers.get(i); +pub fn op_dns_response(rt: &mut Runtime, base: &msg::Base, _raw: fly_buf) -> Box { + let msg = base.msg_as_dns_response().unwrap(); + let req_id = msg.id(); - let dns_class = match ans.dns_class() { - msg::DnsClass::IN => trust_dns::rr::DNSClass::IN, - msg::DnsClass::CH => trust_dns::rr::DNSClass::CH, - msg::DnsClass::HS => trust_dns::rr::DNSClass::HS, - msg::DnsClass::NONE => trust_dns::rr::DNSClass::NONE, - msg::DnsClass::ANY => trust_dns::rr::DNSClass::ANY, - }; + let op_code = match msg.op_code() { + msg::DnsOpCode::Query => trust_dns::op::OpCode::Query, + msg::DnsOpCode::Status => trust_dns::op::OpCode::Status, + msg::DnsOpCode::Notify => trust_dns::op::OpCode::Notify, + msg::DnsOpCode::Update => trust_dns::op::OpCode::Update, + }; - let rdata: RData = match ans.rdata_type() { - msg::DnsRecordData::DnsA => { - let d = ans.rdata_as_dns_a().unwrap(); - RData::A(d.ip().unwrap().parse().unwrap()) - } - msg::DnsRecordData::DnsAaaa => { - let d = ans.rdata_as_dns_aaaa().unwrap(); - RData::AAAA(d.ip().unwrap().parse().unwrap()) - } - msg::DnsRecordData::DnsCname => { - let d = ans.rdata_as_dns_cname().unwrap(); - RData::CNAME(d.name().unwrap().parse().unwrap()) - } - msg::DnsRecordData::DnsMx => { - let d = ans.rdata_as_dns_mx().unwrap(); - RData::MX(trust_dns::rr::rdata::mx::MX::new( - d.preference(), - d.exchange().unwrap().parse().unwrap(), - )) - } - msg::DnsRecordData::DnsNs => { - let d = ans.rdata_as_dns_ns().unwrap(); - RData::NS(d.name().unwrap().parse().unwrap()) - } - msg::DnsRecordData::DnsPtr => { - let d = ans.rdata_as_dns_ptr().unwrap(); - RData::PTR(d.name().unwrap().parse().unwrap()) - } - msg::DnsRecordData::DnsSoa => { - let d = ans.rdata_as_dns_soa().unwrap(); - RData::SOA(trust_dns::rr::rdata::soa::SOA::new( - d.mname().unwrap().parse().unwrap(), - d.rname().unwrap().parse().unwrap(), - d.serial(), - d.refresh(), - d.retry(), - d.expire(), - d.minimum(), - )) - } - msg::DnsRecordData::DnsSrv => { - let d = ans.rdata_as_dns_srv().unwrap(); - RData::SRV(trust_dns::rr::rdata::srv::SRV::new( - d.priority(), - d.weight(), - d.port(), - d.target().unwrap().parse().unwrap(), - )) - } - msg::DnsRecordData::DnsTxt => { - let d = ans.rdata_as_dns_txt().unwrap(); - let tdata = d.data().unwrap(); - let data_len = tdata.len(); - let mut txtdata: Vec = Vec::with_capacity(data_len); - for i in 0..data_len { - let td = tdata.get(i); - txtdata.push(String::from_utf8_lossy(td.data().unwrap()).to_string()); - } - RData::TXT(trust_dns::rr::rdata::txt::TXT::new(txtdata)) + let res_code = msg.response_code() as u16; + + let message_type = match msg.message_type() { + msg::DnsMessageType::Query => trust_dns::op::MessageType::Query, + msg::DnsMessageType::Response => trust_dns::op::MessageType::Response, + }; + + use trust_dns::rr::RData; + + let queries: Vec = if let Some(msg_queries) = msg.queries() { + let qlen = msg_queries.len(); + let mut queries: Vec = Vec::with_capacity(qlen); + for i in 0..qlen { + let q = msg_queries.get(i); + + let rr_type = match q.rr_type() { + msg::DnsRecordType::A => trust_dns::rr::RecordType::A, + msg::DnsRecordType::AAAA => trust_dns::rr::RecordType::AAAA, + msg::DnsRecordType::ANY => trust_dns::rr::RecordType::ANY, + msg::DnsRecordType::AXFR => trust_dns::rr::RecordType::AXFR, + msg::DnsRecordType::CAA => trust_dns::rr::RecordType::CAA, + msg::DnsRecordType::CNAME => trust_dns::rr::RecordType::CNAME, + msg::DnsRecordType::IXFR => trust_dns::rr::RecordType::IXFR, + msg::DnsRecordType::MX => trust_dns::rr::RecordType::MX, + msg::DnsRecordType::NS => trust_dns::rr::RecordType::NS, + msg::DnsRecordType::NULL => trust_dns::rr::RecordType::NULL, + msg::DnsRecordType::OPT => trust_dns::rr::RecordType::OPT, + msg::DnsRecordType::PTR => trust_dns::rr::RecordType::PTR, + msg::DnsRecordType::SOA => trust_dns::rr::RecordType::SOA, + msg::DnsRecordType::SRV => trust_dns::rr::RecordType::SRV, + msg::DnsRecordType::TLSA => trust_dns::rr::RecordType::TLSA, + msg::DnsRecordType::TXT => trust_dns::rr::RecordType::TXT, + }; + + let dns_class = match q.dns_class() { + msg::DnsClass::IN => trust_dns::rr::DNSClass::IN, + msg::DnsClass::CH => trust_dns::rr::DNSClass::CH, + msg::DnsClass::HS => trust_dns::rr::DNSClass::HS, + msg::DnsClass::NONE => trust_dns::rr::DNSClass::NONE, + msg::DnsClass::ANY => trust_dns::rr::DNSClass::ANY, + }; + + queries.push(JsDnsQuery { + name: q.name().unwrap().parse().unwrap(), + rr_type: rr_type, + dns_class: dns_class, + }); } - _ => unimplemented!(), - }; + vec![] + } else { + vec![] + }; - answers.push(JsDnsRecord { - name: ans.name().unwrap().parse().unwrap(), - dns_class: dns_class, - ttl: ans.ttl(), - rdata: rdata, - }); - } - answers - } else { - vec![] - }; + let answers = if let Some(msg_answers) = msg.answers() { + let anslen = msg_answers.len(); + let mut answers: Vec = Vec::with_capacity(anslen); + for i in 0..anslen { + let ans = msg_answers.get(i); - let mut responses = rt.dns_responses.lock().unwrap(); - match responses.remove(&req_id) { - Some(sender) => { - if let Err(_) = sender.send(JsDnsResponse { - op_code: op_code, - authoritative: msg.authoritative(), - truncated: msg.truncated(), - response_code: res_code.into(), - message_type: message_type, - queries: queries, - answers: answers, - }) { - return odd_future("error sending dns response".to_string().into()); - } - } - None => return odd_future("no dns response receiver!".to_string().into()), - }; + let dns_class = match ans.dns_class() { + msg::DnsClass::IN => trust_dns::rr::DNSClass::IN, + msg::DnsClass::CH => trust_dns::rr::DNSClass::CH, + msg::DnsClass::HS => trust_dns::rr::DNSClass::HS, + msg::DnsClass::NONE => trust_dns::rr::DNSClass::NONE, + msg::DnsClass::ANY => trust_dns::rr::DNSClass::ANY, + }; + + let rdata: RData = match ans.rdata_type() { + msg::DnsRecordData::DnsA => { + let d = ans.rdata_as_dns_a().unwrap(); + RData::A(d.ip().unwrap().parse().unwrap()) + } + msg::DnsRecordData::DnsAaaa => { + let d = ans.rdata_as_dns_aaaa().unwrap(); + RData::AAAA(d.ip().unwrap().parse().unwrap()) + } + msg::DnsRecordData::DnsCname => { + let d = ans.rdata_as_dns_cname().unwrap(); + RData::CNAME(d.name().unwrap().parse().unwrap()) + } + msg::DnsRecordData::DnsMx => { + let d = ans.rdata_as_dns_mx().unwrap(); + RData::MX(trust_dns::rr::rdata::mx::MX::new( + d.preference(), + d.exchange().unwrap().parse().unwrap(), + )) + } + msg::DnsRecordData::DnsNs => { + let d = ans.rdata_as_dns_ns().unwrap(); + RData::NS(d.name().unwrap().parse().unwrap()) + } + msg::DnsRecordData::DnsPtr => { + let d = ans.rdata_as_dns_ptr().unwrap(); + RData::PTR(d.name().unwrap().parse().unwrap()) + } + msg::DnsRecordData::DnsSoa => { + let d = ans.rdata_as_dns_soa().unwrap(); + RData::SOA(trust_dns::rr::rdata::soa::SOA::new( + d.mname().unwrap().parse().unwrap(), + d.rname().unwrap().parse().unwrap(), + d.serial(), + d.refresh(), + d.retry(), + d.expire(), + d.minimum(), + )) + } + msg::DnsRecordData::DnsSrv => { + let d = ans.rdata_as_dns_srv().unwrap(); + RData::SRV(trust_dns::rr::rdata::srv::SRV::new( + d.priority(), + d.weight(), + d.port(), + d.target().unwrap().parse().unwrap(), + )) + } + msg::DnsRecordData::DnsTxt => { + let d = ans.rdata_as_dns_txt().unwrap(); + let tdata = d.data().unwrap(); + let data_len = tdata.len(); + let mut txtdata: Vec = Vec::with_capacity(data_len); + for i in 0..data_len { + let td = tdata.get(i); + txtdata.push(String::from_utf8_lossy(td.data().unwrap()).to_string()); + } + RData::TXT(trust_dns::rr::rdata::txt::TXT::new(txtdata)) + } + _ => unimplemented!(), + }; + + answers.push(JsDnsRecord { + name: ans.name().unwrap().parse().unwrap(), + dns_class: dns_class, + ttl: ans.ttl(), + rdata: rdata, + }); + } + answers + } else { + vec![] + }; + + let mut responses = rt.dns_responses.lock().unwrap(); + match responses.remove(&req_id) { + Some(sender) => { + if let Err(_) = sender.send(JsDnsResponse { + op_code: op_code, + authoritative: msg.authoritative(), + truncated: msg.truncated(), + response_code: res_code.into(), + message_type: message_type, + queries: queries, + answers: answers, + }) { + return odd_future("error sending dns response".to_string().into()); + } + } + None => return odd_future("no dns response receiver!".to_string().into()), + }; - ok_future(None) + ok_future(None) } diff --git a/src/ops/modules.rs b/src/ops/modules.rs index 1a62a7e..90a4bae 100644 --- a/src/ops/modules.rs +++ b/src/ops/modules.rs @@ -1,8 +1,8 @@ use crate::msg; use flatbuffers::FlatBufferBuilder; -use crate::runtime::Runtime; use crate::errors::permission_denied; +use crate::runtime::Runtime; use libfly::*; use crate::utils::*; diff --git a/src/postgres_data.rs b/src/postgres_data.rs index 29c762e..61ab395 100644 --- a/src/postgres_data.rs +++ b/src/postgres_data.rs @@ -19,197 +19,197 @@ use std::sync::Mutex; use futures::{future, Future}; lazy_static! { - static ref PG_POOLS: Mutex>> = - Mutex::new(HashMap::new()); + static ref PG_POOLS: Mutex>> = + Mutex::new(HashMap::new()); } pub struct PostgresDataStore { - url: String, - db: Option, - tls: Option, + url: String, + db: Option, + tls: Option, } impl PostgresDataStore { - pub fn new(conf: &PostgresStoreConfig) -> Self { - let url = conf.url.clone(); + pub fn new(conf: &PostgresStoreConfig) -> Self { + let url = conf.url.clone(); - let tls = if conf.tls_client_crt.is_some() { - let mut connbuilder = SslConnector::builder(SslMethod::tls()).unwrap(); - if let Some(ref ca) = conf.tls_ca_crt { - connbuilder.set_ca_file(ca).unwrap(); - } - connbuilder - .set_certificate_file(conf.tls_client_crt.as_ref().unwrap(), SslFiletype::PEM) - .unwrap(); - connbuilder - .set_private_key_file(conf.tls_client_key.as_ref().unwrap(), SslFiletype::PEM) - .unwrap(); - Some(connbuilder.build()) - } else { - None - }; - - PostgresDataStore { - url, - db: conf.database.as_ref().cloned(), - tls, - } - } - - fn get_pool(&self) -> r2d2::Pool { - let key = format!( - "{}:{}", - self.url, - self.db.as_ref().unwrap_or(&"".to_string()) - ); - - PG_POOLS - .lock() - .unwrap() - .entry(key) - .or_insert_with(move || { - if let Err(e) = self.ensure_db() { - if let Some(edb) = e.as_db().cloned() { - // db error - if !edb.message.contains("already exists") { - panic!(edb); + let tls = if conf.tls_client_crt.is_some() { + let mut connbuilder = SslConnector::builder(SslMethod::tls()).unwrap(); + if let Some(ref ca) = conf.tls_ca_crt { + connbuilder.set_ca_file(ca).unwrap(); } - } else { - panic!(e); - } - }; // TODO: bubble that error up - - let params: ConnectParams = self.url.as_str().into_connect_params().unwrap(); - let mut builder = Builder::new(); - builder.port(params.port()); - if let Some(user) = params.user() { - builder.user(user.name(), user.password()); + connbuilder + .set_certificate_file(conf.tls_client_crt.as_ref().unwrap(), SslFiletype::PEM) + .unwrap(); + connbuilder + .set_private_key_file(conf.tls_client_key.as_ref().unwrap(), SslFiletype::PEM) + .unwrap(); + Some(connbuilder.build()) + } else { + None + }; + + PostgresDataStore { + url, + db: conf.database.as_ref().cloned(), + tls, } + } - if let Some(ref dbname) = self.db { - builder.database(dbname); - } else if let Some(dbname) = params.database() { - builder.database(dbname); - } + fn get_pool(&self) -> r2d2::Pool { + let key = format!( + "{}:{}", + self.url, + self.db.as_ref().unwrap_or(&"".to_string()) + ); + + PG_POOLS + .lock() + .unwrap() + .entry(key) + .or_insert_with(move || { + if let Err(e) = self.ensure_db() { + if let Some(edb) = e.as_db().cloned() { + // db error + if !edb.message.contains("already exists") { + panic!(edb); + } + } else { + panic!(e); + } + }; // TODO: bubble that error up + + let params: ConnectParams = self.url.as_str().into_connect_params().unwrap(); + let mut builder = Builder::new(); + builder.port(params.port()); + if let Some(user) = params.user() { + builder.user(user.name(), user.password()); + } + + if let Some(ref dbname) = self.db { + builder.database(dbname); + } else if let Some(dbname) = params.database() { + builder.database(dbname); + } + + let params = builder.build(params.host().clone()); + let manager = PostgresConnectionManager::new( + params, + match self.tls { + Some(ref tls) => { + TlsMode::Require(Box::new(postgres_openssl::OpenSsl::from(tls.clone()))) + } + None => TlsMode::None, + }, + ) + .unwrap(); + r2d2::Pool::builder().build(manager).unwrap() + }) + .clone() + } - let params = builder.build(params.host().clone()); - let manager = PostgresConnectionManager::new( - params, - match self.tls { - Some(ref tls) => { - TlsMode::Require(Box::new(postgres_openssl::OpenSsl::from(tls.clone()))) + fn ensure_db(&self) -> postgres::Result { + if let Some(ref dbname) = self.db { + let params: ConnectParams = self.url.as_str().into_connect_params().unwrap(); + let mut builder = Builder::new(); + builder.port(params.port()); + if let Some(user) = params.user() { + builder.user(user.name(), user.password()); } - None => TlsMode::None, - }, - ) - .unwrap(); - r2d2::Pool::builder().build(manager).unwrap() - }) - .clone() - } - - fn ensure_db(&self) -> postgres::Result { - if let Some(ref dbname) = self.db { - let params: ConnectParams = self.url.as_str().into_connect_params().unwrap(); - let mut builder = Builder::new(); - builder.port(params.port()); - if let Some(user) = params.user() { - builder.user(user.name(), user.password()); - } - if let Some(dbname) = params.database() { - builder.database(dbname); - } + if let Some(dbname) = params.database() { + builder.database(dbname); + } - let params = builder.build(params.host().clone()); - - let tls_connector = match self.tls { - Some(ref tls) => Some(postgres_openssl::OpenSsl::from(tls.clone())), - None => None, - }; - let conn = Connection::connect( - params.clone(), - match tls_connector { - Some(ref connector) => postgres::TlsMode::Require(connector), - None => postgres::TlsMode::None, - }, - ) - .unwrap(); - conn.execute(&format!("CREATE DATABASE \"{}\"", dbname), NO_PARAMS) - } else { - Ok(0) + let params = builder.build(params.host().clone()); + + let tls_connector = match self.tls { + Some(ref tls) => Some(postgres_openssl::OpenSsl::from(tls.clone())), + None => None, + }; + let conn = Connection::connect( + params.clone(), + match tls_connector { + Some(ref connector) => postgres::TlsMode::Require(connector), + None => postgres::TlsMode::None, + }, + ) + .unwrap(); + conn.execute(&format!("CREATE DATABASE \"{}\"", dbname), NO_PARAMS) + } else { + Ok(0) + } } - } } const NO_PARAMS: &'static [&'static ToSql] = &[]; impl From for DataError { - #[inline] - fn from(err: postgres::Error) -> DataError { - DataError::Failure(format!("{}", err)) - } + #[inline] + fn from(err: postgres::Error) -> DataError { + DataError::Failure(format!("{}", err)) + } } impl DataStore for PostgresDataStore { - fn get( - &self, - coll: String, - key: String, - ) -> Box, Error = DataError> + Send> { - debug!("postgres data store get coll: {}, key: {}", coll, key); - let pool = self.get_pool(); - Box::new(future::lazy(move || -> DataResult> { - let conn = pool.get().unwrap(); // TODO: no unwrap - - ensure_coll(&*conn, &coll).unwrap(); - - match conn.query( - format!("SELECT obj::text FROM {} WHERE key = $1", coll).as_str(), - &[&key], - ) { - Err(e) => return Err(e.into()), - Ok(rows) => { - if rows.len() == 0 { - return Ok(None); - } - Ok(Some(rows.get(0).get("obj"))) - } - } - })) - } + fn get( + &self, + coll: String, + key: String, + ) -> Box, Error = DataError> + Send> { + debug!("postgres data store get coll: {}, key: {}", coll, key); + let pool = self.get_pool(); + Box::new(future::lazy(move || -> DataResult> { + let conn = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*conn, &coll).unwrap(); + + match conn.query( + format!("SELECT obj::text FROM {} WHERE key = $1", coll).as_str(), + &[&key], + ) { + Err(e) => return Err(e.into()), + Ok(rows) => { + if rows.len() == 0 { + return Ok(None); + } + Ok(Some(rows.get(0).get("obj"))) + } + } + })) + } - fn del(&self, coll: String, key: String) -> Box + Send> { - debug!("postgres data store del coll: {}, key: {}", coll, key); - let pool = self.get_pool(); - Box::new(future::lazy(move || -> DataResult<()> { - let conn = pool.get().unwrap(); // TODO: no unwrap + fn del(&self, coll: String, key: String) -> Box + Send> { + debug!("postgres data store del coll: {}, key: {}", coll, key); + let pool = self.get_pool(); + Box::new(future::lazy(move || -> DataResult<()> { + let conn = pool.get().unwrap(); // TODO: no unwrap - ensure_coll(&*conn, &coll).unwrap(); + ensure_coll(&*conn, &coll).unwrap(); - match conn.execute( - format!("DELETE FROM {} WHERE key = $1", coll).as_str(), - &[&key], - ) { - Ok(_) => Ok(()), - Err(e) => Err(e.into()), - } - })) - } - - fn put( - &self, - coll: String, - key: String, - data: String, - ) -> Box + Send> { - debug!("postgres data store put coll: {}, key: {}", coll, key); - let pool = self.get_pool(); - Box::new(future::lazy(move || -> DataResult<()> { - let conn = pool.get().unwrap(); // TODO: no unwrap - - ensure_coll(&*conn, &coll).unwrap(); - match conn.execute( + match conn.execute( + format!("DELETE FROM {} WHERE key = $1", coll).as_str(), + &[&key], + ) { + Ok(_) => Ok(()), + Err(e) => Err(e.into()), + } + })) + } + + fn put( + &self, + coll: String, + key: String, + data: String, + ) -> Box + Send> { + debug!("postgres data store put coll: {}, key: {}", coll, key); + let pool = self.get_pool(); + Box::new(future::lazy(move || -> DataResult<()> { + let conn = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*conn, &coll).unwrap(); + match conn.execute( &format!( "INSERT INTO {} (key, obj) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET obj = excluded.obj", coll @@ -219,27 +219,27 @@ impl DataStore for PostgresDataStore { Ok(_) => Ok(()), Err(e) => Err(e.into()), } - })) - } - - fn incr( - &self, - coll: String, - key: String, - field: String, - amount: i32, - ) -> Box + Send> { - debug!( - "postgres data store incr coll: {}, key: {}, field: {}, amount: {}", - coll, key, field, amount - ); - let pool = self.get_pool(); - Box::new(future::lazy(move || -> DataResult<()> { - let con = pool.get().unwrap(); // TODO: no unwrap - - ensure_coll(&*con, &coll).unwrap(); - - match con.execute( + })) + } + + fn incr( + &self, + coll: String, + key: String, + field: String, + amount: i32, + ) -> Box + Send> { + debug!( + "postgres data store incr coll: {}, key: {}, field: {}, amount: {}", + coll, key, field, amount + ); + let pool = self.get_pool(); + Box::new(future::lazy(move || -> DataResult<()> { + let con = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*con, &coll).unwrap(); + + match con.execute( format!( "UPDATE {} SET obj = jsonb_set(obj, '{{{}}}', (COALESCE(obj->>'{}', '0')::int + $1)::text::jsonb) WHERE key = $2", coll, field, field @@ -250,163 +250,160 @@ impl DataStore for PostgresDataStore { Ok(_) => Ok(()), Err(e) => Err(e.into()), } - })) - } - - fn drop_coll(&self, coll: String) -> Box + Send> { - debug!("postgres data store drop coll: {}", coll); - let pool = self.get_pool(); - Box::new(future::lazy(move || -> DataResult<()> { - let con = pool.get().unwrap(); // TODO: no unwrap - match con.execute(format!("DROP TABLE IF EXISTS {}", coll).as_str(), NO_PARAMS) { - Ok(_) => Ok(()), - Err(e) => Err(e.into()), - } - })) - } + })) + } + + fn drop_coll(&self, coll: String) -> Box + Send> { + debug!("postgres data store drop coll: {}", coll); + let pool = self.get_pool(); + Box::new(future::lazy(move || -> DataResult<()> { + let con = pool.get().unwrap(); // TODO: no unwrap + match con.execute(format!("DROP TABLE IF EXISTS {}", coll).as_str(), NO_PARAMS) { + Ok(_) => Ok(()), + Err(e) => Err(e.into()), + } + })) + } } fn ensure_coll(conn: &postgres::Connection, name: &str) -> postgres::Result { - conn.execute( - format!( - "CREATE TABLE IF NOT EXISTS {} (key TEXT PRIMARY KEY NOT NULL, obj JSONB NOT NULL)", - name + conn.execute( + format!( + "CREATE TABLE IF NOT EXISTS {} (key TEXT PRIMARY KEY NOT NULL, obj JSONB NOT NULL)", + name + ) + .as_str(), + NO_PARAMS, ) - .as_str(), - NO_PARAMS, - ) } #[cfg(test)] mod tests { - use super::*; - use std::env; - - lazy_static! { - static ref PG_URL: String = { - format!( - "postgres://{}@localhost:5432/{}", - env::var("PG_TEST_USER").unwrap_or("postgres".to_string()), - env::var("PG_TEST_DB").unwrap_or("postgres".to_string()) - ) - }; - } - - fn setup(dbname: Option) -> PostgresDataStore { - let conf = PostgresStoreConfig { - url: (*PG_URL).clone(), - database: dbname, - tls_client_crt: None, - tls_client_key: None, - tls_ca_crt: None, - }; - PostgresDataStore::new(&conf) - } - - fn teardown(dbname: &str) { - PG_POOLS - .lock() - .unwrap() - .remove(&format!("{}:{}", *PG_URL, dbname)); - let conn = Connection::connect((*PG_URL).as_str(), postgres::TlsMode::None).unwrap(); - - conn - .execute(&format!("DROP DATABASE {}", dbname), NO_PARAMS) - .unwrap(); - } - - fn set_value(store: &PostgresDataStore, coll: &str, key: &str, value: &str) { - store - .put(coll.to_string(), key.to_string(), value.to_string()) - .wait() - .unwrap(); - } - - #[test] - fn test_pg_some_dbname() { - let dbname = "testflydata"; - let res: String = { - let store = setup(Some(dbname.to_string())); - let conn = store.get_pool().get().unwrap(); - - conn - .query( - &format!( - "SELECT datname FROM pg_database WHERE datname = '{}' LIMIT 1", - &dbname - ), - NO_PARAMS, - ) - .unwrap() - .get(0) - .get(0) - }; - - teardown(&dbname); - - assert_eq!(&res, dbname); - } - - #[test] - fn test_pg_put_get() { - let dbname = "testflyputget"; - let coll = "coll1"; - let key = "test:key"; - let value = r#"{"foo":"bar"}"#; - let got = { - let store = setup(Some(dbname.to_string())); - set_value(&store, coll, key, value); - - store - .get(coll.to_string(), key.to_string()) - .wait() - .unwrap() - .unwrap() - }; - - teardown(&dbname); - - assert_eq!( - serde_json::from_str::(&got).unwrap(), - serde_json::from_str::(value).unwrap() - ); - } - - #[test] - fn test_pg_incr() { - let dbname = "testflyincr"; - let coll = "coll1"; - let key = "test:key"; - let value = r#"{"counter":0,"foo":"bar"}"#; - - let store = setup(Some(dbname.to_string())); - set_value(&store, coll, key, value); - - store - .incr(coll.to_string(), key.to_string(), "counter".to_string(), 1) - .wait() - .unwrap(); - let got = store - .get(coll.to_string(), key.to_string()) - .wait() - .unwrap() - .unwrap(); - - assert_eq!(got, "{\"foo\": \"bar\", \"counter\": 1}"); - - store - .incr(coll.to_string(), key.to_string(), "counter".to_string(), 15) - .wait() - .unwrap(); - let got = store - .get(coll.to_string(), key.to_string()) - .wait() - .unwrap() - .unwrap(); - - assert_eq!(got, "{\"foo\": \"bar\", \"counter\": 16}"); - - teardown(&dbname); - } + use super::*; + use std::env; + + lazy_static! { + static ref PG_URL: String = { + format!( + "postgres://{}@localhost:5432/{}", + env::var("PG_TEST_USER").unwrap_or("postgres".to_string()), + env::var("PG_TEST_DB").unwrap_or("postgres".to_string()) + ) + }; + } + fn setup(dbname: Option) -> PostgresDataStore { + let conf = PostgresStoreConfig { + url: (*PG_URL).clone(), + database: dbname, + tls_client_crt: None, + tls_client_key: None, + tls_ca_crt: None, + }; + PostgresDataStore::new(&conf) + } + + fn teardown(dbname: &str) { + PG_POOLS + .lock() + .unwrap() + .remove(&format!("{}:{}", *PG_URL, dbname)); + let conn = Connection::connect((*PG_URL).as_str(), postgres::TlsMode::None).unwrap(); + + conn.execute(&format!("DROP DATABASE {}", dbname), NO_PARAMS) + .unwrap(); + } + + fn set_value(store: &PostgresDataStore, coll: &str, key: &str, value: &str) { + store + .put(coll.to_string(), key.to_string(), value.to_string()) + .wait() + .unwrap(); + } + + #[test] + fn test_pg_some_dbname() { + let dbname = "testflydata"; + let res: String = { + let store = setup(Some(dbname.to_string())); + let conn = store.get_pool().get().unwrap(); + + conn.query( + &format!( + "SELECT datname FROM pg_database WHERE datname = '{}' LIMIT 1", + &dbname + ), + NO_PARAMS, + ) + .unwrap() + .get(0) + .get(0) + }; + + teardown(&dbname); + + assert_eq!(&res, dbname); + } + + #[test] + fn test_pg_put_get() { + let dbname = "testflyputget"; + let coll = "coll1"; + let key = "test:key"; + let value = r#"{"foo":"bar"}"#; + let got = { + let store = setup(Some(dbname.to_string())); + set_value(&store, coll, key, value); + + store + .get(coll.to_string(), key.to_string()) + .wait() + .unwrap() + .unwrap() + }; + + teardown(&dbname); + + assert_eq!( + serde_json::from_str::(&got).unwrap(), + serde_json::from_str::(value).unwrap() + ); + } + + #[test] + fn test_pg_incr() { + let dbname = "testflyincr"; + let coll = "coll1"; + let key = "test:key"; + let value = r#"{"counter":0,"foo":"bar"}"#; + + let store = setup(Some(dbname.to_string())); + set_value(&store, coll, key, value); + + store + .incr(coll.to_string(), key.to_string(), "counter".to_string(), 1) + .wait() + .unwrap(); + let got = store + .get(coll.to_string(), key.to_string()) + .wait() + .unwrap() + .unwrap(); + + assert_eq!(got, "{\"foo\": \"bar\", \"counter\": 1}"); + + store + .incr(coll.to_string(), key.to_string(), "counter".to_string(), 15) + .wait() + .unwrap(); + let got = store + .get(coll.to_string(), key.to_string()) + .wait() + .unwrap() + .unwrap(); + + assert_eq!(got, "{\"foo\": \"bar\", \"counter\": 16}"); + + teardown(&dbname); + } } diff --git a/src/redis_cache.rs b/src/redis_cache.rs index 17d71c7..b9f6cf1 100644 --- a/src/redis_cache.rs +++ b/src/redis_cache.rs @@ -23,8 +23,8 @@ use crate::redis_cache_notifier::RedisCacheNotifier; use crate::redis_pool::get_pool; lazy_static! { - static ref REPLACE_HASH: redis::Script = redis::Script::new( - r#" + static ref REPLACE_HASH: redis::Script = redis::Script::new( + r#" local key = KEYS[1] local res = redis.call("DEL", key) local ttl = table.remove(ARGV, 1) @@ -36,10 +36,10 @@ lazy_static! { end return res "# - ); - static ref SET_TAGS: redis::Script = { - let src = format!( - r#" + ); + static ref SET_TAGS: redis::Script = { + let src = format!( + r#" local key = KEYS[1] local ts = table.remove(ARGV, 1) @@ -51,12 +51,12 @@ lazy_static! { return res "#, - TAG_PREFIX - ); - redis::Script::new(src.as_str()) - }; - static ref GET_CACHE: redis::Script = redis::Script::new( - r#" + TAG_PREFIX + ); + redis::Script::new(src.as_str()) + }; + static ref GET_CACHE: redis::Script = redis::Script::new( + r#" local key = KEYS[1] local typ = redis.call("TYPE", key) if typ and typ.ok ~= "hash" then @@ -68,7 +68,7 @@ lazy_static! { return redis.call("HMGET", key, "ts", "meta") "# - ); + ); } use self::r2d2_redis::RedisConnectionManager; @@ -78,683 +78,686 @@ static CACHE_PREFIX: &str = "v2:cache"; static TAG_PREFIX: &str = "v2:tag"; pub struct RedisCacheStore { - pool: r2d2::Pool, - ns: String, - notifier: Option, - metric_get_duration: Histogram, - metric_set_duration: Histogram, - metric_hits_total: IntCounter, - metric_misses_total: IntCounter, - metric_errors_total: IntCounter, - metric_gets_total: IntCounter, - metric_get_size_total: IntCounter, - metric_sets_total: IntCounter, - metric_set_size_total: IntCounter, - metric_dels_total: IntCounter, - metric_expires_total: IntCounter, - metric_ttls_total: IntCounter, - metric_set_tags_total: IntCounter, + pool: r2d2::Pool, + ns: String, + notifier: Option, + metric_get_duration: Histogram, + metric_set_duration: Histogram, + metric_hits_total: IntCounter, + metric_misses_total: IntCounter, + metric_errors_total: IntCounter, + metric_gets_total: IntCounter, + metric_get_size_total: IntCounter, + metric_sets_total: IntCounter, + metric_set_size_total: IntCounter, + metric_dels_total: IntCounter, + metric_expires_total: IntCounter, + metric_ttls_total: IntCounter, + metric_set_tags_total: IntCounter, } impl RedisCacheStore { - pub fn new(conf: &RedisStoreConfig, notifier_conf: Option) -> Self { - let ns = conf.namespace.as_ref().cloned().unwrap_or("".to_string()); - let ns_str = ns.as_str(); - - RedisCacheStore { - pool: get_pool(conf.url.clone()), - ns: ns.clone(), - notifier: match notifier_conf { - None => None, - Some(csnconf) => Some(RedisCacheNotifier::new(csnconf, conf.url.clone())), - }, - metric_get_duration: CACHE_GET_DURATION.with_label_values(&["redis", ns_str]), - metric_set_duration: CACHE_SET_DURATION.with_label_values(&["redis", ns_str]), - metric_hits_total: CACHE_HITS_TOTAL.with_label_values(&["redis", ns_str]), - metric_misses_total: CACHE_MISSES_TOTAL.with_label_values(&["redis", ns_str]), - metric_errors_total: CACHE_ERRORS_TOTAL.with_label_values(&["redis", ns_str]), - metric_gets_total: CACHE_GETS_TOTAL.with_label_values(&["redis", ns_str]), - metric_get_size_total: CACHE_GET_SIZE_TOTAL.with_label_values(&["redis", ns_str]), - metric_sets_total: CACHE_SETS_TOTAL.with_label_values(&["redis", ns_str]), - metric_set_size_total: CACHE_SET_SIZE_TOTAL.with_label_values(&["redis", ns_str]), - metric_dels_total: CACHE_DELS_TOTAL.with_label_values(&["redis", ns_str]), - metric_expires_total: CACHE_EXPIRES_TOTAL.with_label_values(&["redis", ns_str]), - metric_ttls_total: CACHE_TTLS_TOTAL.with_label_values(&["redis", ns_str]), - metric_set_tags_total: CACHE_SET_TAGS_TOTAL.with_label_values(&["redis", ns_str]), + pub fn new(conf: &RedisStoreConfig, notifier_conf: Option) -> Self { + let ns = conf.namespace.as_ref().cloned().unwrap_or("".to_string()); + let ns_str = ns.as_str(); + + RedisCacheStore { + pool: get_pool(conf.url.clone()), + ns: ns.clone(), + notifier: match notifier_conf { + None => None, + Some(csnconf) => Some(RedisCacheNotifier::new(csnconf, conf.url.clone())), + }, + metric_get_duration: CACHE_GET_DURATION.with_label_values(&["redis", ns_str]), + metric_set_duration: CACHE_SET_DURATION.with_label_values(&["redis", ns_str]), + metric_hits_total: CACHE_HITS_TOTAL.with_label_values(&["redis", ns_str]), + metric_misses_total: CACHE_MISSES_TOTAL.with_label_values(&["redis", ns_str]), + metric_errors_total: CACHE_ERRORS_TOTAL.with_label_values(&["redis", ns_str]), + metric_gets_total: CACHE_GETS_TOTAL.with_label_values(&["redis", ns_str]), + metric_get_size_total: CACHE_GET_SIZE_TOTAL.with_label_values(&["redis", ns_str]), + metric_sets_total: CACHE_SETS_TOTAL.with_label_values(&["redis", ns_str]), + metric_set_size_total: CACHE_SET_SIZE_TOTAL.with_label_values(&["redis", ns_str]), + metric_dels_total: CACHE_DELS_TOTAL.with_label_values(&["redis", ns_str]), + metric_expires_total: CACHE_EXPIRES_TOTAL.with_label_values(&["redis", ns_str]), + metric_ttls_total: CACHE_TTLS_TOTAL.with_label_values(&["redis", ns_str]), + metric_set_tags_total: CACHE_SET_TAGS_TOTAL.with_label_values(&["redis", ns_str]), + } } - } - fn cache_key(&self, key: S) -> String { - format!("{}:{}:{}", CACHE_PREFIX, self.ns, key) - } + fn cache_key(&self, key: S) -> String { + format!("{}:{}:{}", CACHE_PREFIX, self.ns, key) + } - fn tag_key(&self, tag: S) -> String { - format!("{}:{}:{}", TAG_PREFIX, self.ns, tag) - } + fn tag_key(&self, tag: S) -> String { + format!("{}:{}:{}", TAG_PREFIX, self.ns, tag) + } } impl CacheStore for RedisCacheStore { - fn set( - &self, - key: String, - data: Box, Error = ()> + Send>, - opts: CacheSetOptions, - ) -> EmptyCacheFuture { - self.metric_sets_total.inc(); - let fullkey = self.cache_key(key); - let cfullkey = fullkey.clone(); - - let ns = self.ns.clone(); - let timer = self.metric_set_duration.start_timer(); - let size_metric = self.metric_set_size_total.clone(); - - let pool = self.pool.clone(); - let cpool = pool.clone(); - - Box::new( - future::lazy(move || match pool.get() { - Ok(conn) => { - let ts = time::SystemTime::now() - .duration_since(time::UNIX_EPOCH) - .unwrap() - .as_secs(); - let mut script = REPLACE_HASH.key(&fullkey); - script.arg(opts.ttl.unwrap_or(0)); - script.arg("ts").arg(ts); - - if let Some(meta) = opts.meta { - script.arg("meta").arg(meta); - } - - match script.invoke::<()>(&*conn) { - Ok(_) => { - if let Some(tags) = opts.tags { - for tag in tags.iter() { - match redis::cmd("ZADD") - .arg(format!("{}:{}:{}", TAG_PREFIX, ns, tag)) - .arg(ts) - .arg(&fullkey) - .query::<()>(&*conn) - { - Ok(_) => {} - Err(e) => return Err(CacheError::Failure(format!("{}", e))), - } + fn set( + &self, + key: String, + data: Box, Error = ()> + Send>, + opts: CacheSetOptions, + ) -> EmptyCacheFuture { + self.metric_sets_total.inc(); + let fullkey = self.cache_key(key); + let cfullkey = fullkey.clone(); + + let ns = self.ns.clone(); + let timer = self.metric_set_duration.start_timer(); + let size_metric = self.metric_set_size_total.clone(); + + let pool = self.pool.clone(); + let cpool = pool.clone(); + + Box::new( + future::lazy(move || match pool.get() { + Ok(conn) => { + let ts = time::SystemTime::now() + .duration_since(time::UNIX_EPOCH) + .unwrap() + .as_secs(); + let mut script = REPLACE_HASH.key(&fullkey); + script.arg(opts.ttl.unwrap_or(0)); + script.arg("ts").arg(ts); + + if let Some(meta) = opts.meta { + script.arg("meta").arg(meta); + } + + match script.invoke::<()>(&*conn) { + Ok(_) => { + if let Some(tags) = opts.tags { + for tag in tags.iter() { + match redis::cmd("ZADD") + .arg(format!("{}:{}:{}", TAG_PREFIX, ns, tag)) + .arg(ts) + .arg(&fullkey) + .query::<()>(&*conn) + { + Ok(_) => {} + Err(e) => { + return Err(CacheError::Failure(format!("{}", e))) + } + } + } + } + Ok(()) + } + Err(e) => Err(CacheError::Failure(format!("{}", e))), + } } - } - Ok(()) - } - Err(e) => Err(CacheError::Failure(format!("{}", e))), - } - } - Err(e) => Err(CacheError::Failure(format!("{}", e))), - }) - .and_then(move |_| { - data - .map_err(|_| CacheError::Unknown) - .fold(0, move |idx, chunk| match cpool.get() { - Ok(conn) => match redis::cmd("HSET") - .arg(&cfullkey) - .arg(format!("chunk:{}", idx)) - .arg(chunk.as_slice()) - .query::<()>(&*conn) + Err(e) => Err(CacheError::Failure(format!("{}", e))), + }) + .and_then(move |_| { + data.map_err(|_| CacheError::Unknown) + .fold(0, move |idx, chunk| match cpool.get() { + Ok(conn) => match redis::cmd("HSET") + .arg(&cfullkey) + .arg(format!("chunk:{}", idx)) + .arg(chunk.as_slice()) + .query::<()>(&*conn) + { + Ok(_) => { + size_metric.inc_by(chunk.len() as i64); + Ok(idx + 1) + } + Err(e) => Err(CacheError::Failure(format!("{}", e))), + }, + Err(e) => Err(CacheError::Failure(format!("{}", e))), + }) + .and_then(move |_| { + timer.observe_duration(); + Ok(()) + }) + }), + ) + } + + fn get( + &self, + key: String, + ) -> Box, Error = CacheError> + Send> { + self.metric_gets_total.inc(); + let fullkey = self.cache_key(key); + debug!("redis cache get with key: {}", fullkey); + + let timer = Arc::new(self.metric_get_duration.start_timer()); + let size_metric = self.metric_get_size_total.clone(); + let metric_misses = self.metric_misses_total.clone(); + let metric_hits = self.metric_hits_total.clone(); + let metric_errors = self.metric_errors_total.clone(); + + let pool = self.pool.clone(); + + Box::new(future::lazy(move || match pool.get() { + Ok(conn) => match GET_CACHE + .key(&fullkey) + .invoke::<(i32, Option)>(&*conn) { - Ok(_) => { - size_metric.inc_by(chunk.len() as i64); - Ok(idx + 1) - } - Err(e) => Err(CacheError::Failure(format!("{}", e))), - }, - Err(e) => Err(CacheError::Failure(format!("{}", e))), - }) - .and_then(move |_| { - timer.observe_duration(); - Ok(()) - }) - }), - ) - } - - fn get(&self, key: String) -> Box, Error = CacheError> + Send> { - self.metric_gets_total.inc(); - let fullkey = self.cache_key(key); - debug!("redis cache get with key: {}", fullkey); - - let timer = Arc::new(self.metric_get_duration.start_timer()); - let size_metric = self.metric_get_size_total.clone(); - let metric_misses = self.metric_misses_total.clone(); - let metric_hits = self.metric_hits_total.clone(); - let metric_errors = self.metric_errors_total.clone(); - - let pool = self.pool.clone(); - - Box::new(future::lazy(move || match pool.get() { - Ok(conn) => match GET_CACHE - .key(&fullkey) - .invoke::<(i32, Option)>(&*conn) - { - Ok(vals) => { - if vals.0 == 0 { - metric_misses.inc(); - return Ok(None); - } - metric_hits.inc(); - Ok(Some(CacheEntry { - meta: vals.1, - stream: Box::new(stream::unfold(0, move |idx| match pool.get() { - Ok(conn) => match redis::cmd("HGET") - .arg(&fullkey) - .arg(format!("chunk:{}", idx)) - .query::>(&*conn) - { - Ok(r) => { - if r.len() == 0 { - return None; - } - size_metric.inc_by(r.len() as i64); - let _t = timer.clone(); // keep it alive. - Some(future::ok((r, idx + 1))) + Ok(vals) => { + if vals.0 == 0 { + metric_misses.inc(); + return Ok(None); + } + metric_hits.inc(); + Ok(Some(CacheEntry { + meta: vals.1, + stream: Box::new(stream::unfold(0, move |idx| match pool.get() { + Ok(conn) => match redis::cmd("HGET") + .arg(&fullkey) + .arg(format!("chunk:{}", idx)) + .query::>(&*conn) + { + Ok(r) => { + if r.len() == 0 { + return None; + } + size_metric.inc_by(r.len() as i64); + let _t = timer.clone(); // keep it alive. + Some(future::ok((r, idx + 1))) + } + Err(e) => { + metric_errors.inc(); + Some(future::err(CacheError::Failure(format!("{}", e)))) + } + }, + Err(e) => { + metric_errors.inc(); + Some(future::err(CacheError::Failure(format!("{}", e)))) + } + })), + })) } Err(e) => { - metric_errors.inc(); - Some(future::err(CacheError::Failure(format!("{}", e)))) + metric_errors.inc(); + Err(CacheError::Failure(format!("{}", e))) } - }, - Err(e) => { + }, + Err(e) => { metric_errors.inc(); - Some(future::err(CacheError::Failure(format!("{}", e)))) - } - })), - })) - } - Err(e) => { - metric_errors.inc(); - Err(CacheError::Failure(format!("{}", e))) - } - }, - Err(e) => { - metric_errors.inc(); - Err(CacheError::Failure(format!("{}", e))) - } - })) - } - - fn del(&self, key: String) -> EmptyCacheFuture { - self.metric_dels_total.inc(); - let fullkey = self.cache_key(key); - debug!("redis cache del key: {}", fullkey); - let pool = self.pool.clone(); - Box::new(future::lazy(move || match pool.get() { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(conn) => match redis::cmd("DEL").arg(&fullkey).query::<()>(&*conn) { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(_) => Ok(()), - }, - })) - } - - fn expire(&self, key: String, ttl: u32) -> EmptyCacheFuture { - self.metric_expires_total.inc(); - let fullkey = self.cache_key(key); - debug!("redis cache expire key: {} w/ ttl: {}", fullkey, ttl); - - let pool = self.pool.clone(); - Box::new(future::lazy(move || match pool.get() { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(conn) => match redis::cmd("EXPIRE") - .arg(&fullkey) - .arg(ttl) - .query::<()>(&*conn) - { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(_) => Ok(()), - }, - })) - } - - fn ttl(&self, key: String) -> Box + Send> { - self.metric_ttls_total.inc(); - let fullkey = self.cache_key(key); - debug!("redis cache ttl key: {}", fullkey); - - let pool = self.pool.clone(); - Box::new(future::lazy(move || match pool.get() { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(conn) => match redis::cmd("TTL").arg(&fullkey).query::(&*conn) { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(i) => Ok(i), - }, - })) - } - - fn purge_tag(&self, tag: String) -> EmptyCacheFuture { - CACHE_PURGES_TOTAL - .with_label_values(&["redis", self.ns.as_str(), tag.as_str()]) - .inc(); // can't do that oen statically. - debug!("redis cache purge_tag tag: {}", tag); - let tagkey = self.tag_key(tag); - let pool = self.pool.clone(); - - Box::new(future::lazy(move || match pool.get() { - Ok(conn) => match purge_tag(&*conn, tagkey) { - Ok(_) => Ok(()), - Err(e) => Err(CacheError::Failure(format!("{}", e))), - }, - Err(e) => Err(CacheError::Failure(format!("{}", e))), - })) - } - - fn set_tags(&self, key: String, tags: Vec) -> EmptyCacheFuture { - self.metric_set_tags_total.inc(); - debug!("redis cache set tags key: {}, tags: {:?}", key, tags); - let fullkey = self.cache_key(&key); - - let ns = self.ns.clone(); - let pool = self.pool.clone(); - Box::new(future::lazy(move || match pool.get() { - Ok(conn) => { - let ts = time::SystemTime::now() - .duration_since(time::UNIX_EPOCH) - .unwrap() - .as_secs(); - let mut script = SET_TAGS.key(&fullkey); - script.arg(ts); - for tag in tags.iter() { - script.arg(tag); - } - match script.invoke::<()>(&*conn) { - Ok(_) => { - for tag in tags.iter() { - match redis::cmd("ZADD") - .arg(format!("{}:{}:{}", TAG_PREFIX, ns, tag)) - .arg(ts) + Err(CacheError::Failure(format!("{}", e))) + } + })) + } + + fn del(&self, key: String) -> EmptyCacheFuture { + self.metric_dels_total.inc(); + let fullkey = self.cache_key(key); + debug!("redis cache del key: {}", fullkey); + let pool = self.pool.clone(); + Box::new(future::lazy(move || match pool.get() { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(conn) => match redis::cmd("DEL").arg(&fullkey).query::<()>(&*conn) { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(_) => Ok(()), + }, + })) + } + + fn expire(&self, key: String, ttl: u32) -> EmptyCacheFuture { + self.metric_expires_total.inc(); + let fullkey = self.cache_key(key); + debug!("redis cache expire key: {} w/ ttl: {}", fullkey, ttl); + + let pool = self.pool.clone(); + Box::new(future::lazy(move || match pool.get() { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(conn) => match redis::cmd("EXPIRE") .arg(&fullkey) + .arg(ttl) .query::<()>(&*conn) - { - Ok(_) => {} - Err(e) => return Err(CacheError::Failure(format!("{}", e))), - } + { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(_) => Ok(()), + }, + })) + } + + fn ttl(&self, key: String) -> Box + Send> { + self.metric_ttls_total.inc(); + let fullkey = self.cache_key(key); + debug!("redis cache ttl key: {}", fullkey); + + let pool = self.pool.clone(); + Box::new(future::lazy(move || match pool.get() { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(conn) => match redis::cmd("TTL").arg(&fullkey).query::(&*conn) { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(i) => Ok(i), + }, + })) + } + + fn purge_tag(&self, tag: String) -> EmptyCacheFuture { + CACHE_PURGES_TOTAL + .with_label_values(&["redis", self.ns.as_str(), tag.as_str()]) + .inc(); // can't do that oen statically. + debug!("redis cache purge_tag tag: {}", tag); + let tagkey = self.tag_key(tag); + let pool = self.pool.clone(); + + Box::new(future::lazy(move || match pool.get() { + Ok(conn) => match purge_tag(&*conn, tagkey) { + Ok(_) => Ok(()), + Err(e) => Err(CacheError::Failure(format!("{}", e))), + }, + Err(e) => Err(CacheError::Failure(format!("{}", e))), + })) + } + + fn set_tags(&self, key: String, tags: Vec) -> EmptyCacheFuture { + self.metric_set_tags_total.inc(); + debug!("redis cache set tags key: {}, tags: {:?}", key, tags); + let fullkey = self.cache_key(&key); + + let ns = self.ns.clone(); + let pool = self.pool.clone(); + Box::new(future::lazy(move || match pool.get() { + Ok(conn) => { + let ts = time::SystemTime::now() + .duration_since(time::UNIX_EPOCH) + .unwrap() + .as_secs(); + let mut script = SET_TAGS.key(&fullkey); + script.arg(ts); + for tag in tags.iter() { + script.arg(tag); + } + match script.invoke::<()>(&*conn) { + Ok(_) => { + for tag in tags.iter() { + match redis::cmd("ZADD") + .arg(format!("{}:{}:{}", TAG_PREFIX, ns, tag)) + .arg(ts) + .arg(&fullkey) + .query::<()>(&*conn) + { + Ok(_) => {} + Err(e) => return Err(CacheError::Failure(format!("{}", e))), + } + } + Ok(()) + } + Err(e) => Err(CacheError::Failure(format!("{}", e))), + } } - Ok(()) - } - Err(e) => Err(CacheError::Failure(format!("{}", e))), + Err(e) => Err(CacheError::Failure(format!("{}", e))), + })) + } + + fn notify( + &self, + op: CacheOperation, + value: String, + ) -> Box + Send> { + if self.notifier.is_none() { + return Box::new(future::err(CacheStoreNotifierError::Unavailable)); } - } - Err(e) => Err(CacheError::Failure(format!("{}", e))), - })) - } - - fn notify( - &self, - op: CacheOperation, - value: String, - ) -> Box + Send> { - if self.notifier.is_none() { - return Box::new(future::err(CacheStoreNotifierError::Unavailable)); + + let notifier = self.notifier.as_ref().unwrap(); + + notifier.notify(op, self.ns.clone(), value) } - let notifier = self.notifier.as_ref().unwrap(); - - notifier.notify(op, self.ns.clone(), value) - } - - fn set_meta(&self, key: String, meta: String) -> EmptyCacheFuture { - self.metric_ttls_total.inc(); - let fullkey = self.cache_key(key); - debug!("redis cache set_meta key: {}", fullkey); - - let pool = self.pool.clone(); - Box::new(future::lazy(move || match pool.get() { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(conn) => match redis::cmd("HSET") - .arg(&fullkey) - .arg("meta") - .arg(meta) - .query::<()>(&*conn) - { - Err(e) => Err(CacheError::Failure(format!("{}", e))), - Ok(_) => Ok(()), - }, - })) - } + fn set_meta(&self, key: String, meta: String) -> EmptyCacheFuture { + self.metric_ttls_total.inc(); + let fullkey = self.cache_key(key); + debug!("redis cache set_meta key: {}", fullkey); + + let pool = self.pool.clone(); + Box::new(future::lazy(move || match pool.get() { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(conn) => match redis::cmd("HSET") + .arg(&fullkey) + .arg("meta") + .arg(meta) + .query::<()>(&*conn) + { + Err(e) => Err(CacheError::Failure(format!("{}", e))), + Ok(_) => Ok(()), + }, + })) + } } pub fn purge_tag(conn: &redis::Connection, tagkey: String) -> Result<(), redis::RedisError> { - let keysts = redis::cmd("ZRANGE") - .arg(&tagkey) - .arg(0) - .arg(-1) - .arg("WITHSCORES") - .query::>(conn)?; - for (key, tagts) in keysts.iter() { - let ref ts = redis::cmd("HGET").arg(key).arg("ts").query::(conn)?; - if ts == tagts { - redis::cmd("DEL").arg(key).execute(conn); + let keysts = redis::cmd("ZRANGE") + .arg(&tagkey) + .arg(0) + .arg(-1) + .arg("WITHSCORES") + .query::>(conn)?; + for (key, tagts) in keysts.iter() { + let ref ts = redis::cmd("HGET").arg(key).arg("ts").query::(conn)?; + if ts == tagts { + redis::cmd("DEL").arg(key).execute(conn); + } } - } - Ok(()) + Ok(()) } #[cfg(test)] mod tests { - use super::*; - extern crate rand; - use self::rand::{thread_rng, RngCore}; - - fn setup() -> RedisCacheStore { - RedisCacheStore::new( - &RedisStoreConfig { - url: "redis://localhost:6379".to_string(), - namespace: Some("test".to_string()), - }, - None, - ) - } - - fn set_value( - store: &RedisCacheStore, - key: &str, - v: &[u8], - opts: CacheSetOptions, - ) -> CacheResult<()> { - let size = 256; - let value = v.to_vec(); - store - .set( - key.to_string(), - Box::new(stream::unfold(0, move |pos| { - if pos >= value.len() { - return None; - } - let end = pos + size; - if end > value.len() { - Some(future::ok((value[pos..].to_vec(), end))) - } else { - Some(future::ok((value[pos..end].to_vec(), end))) - } - })), - opts, - ) - .wait() - } - - #[test] - fn test_redis_cache_set() { - let store = setup(); - let mut v = [0u8; 1000]; - thread_rng().fill_bytes(&mut v); - let key = "testset"; - set_value( - &store, - key, - &v, - CacheSetOptions { - tags: None, - ttl: None, - meta: None, - }, - ) - .unwrap(); - - let entry = store.get(key.to_string()).wait().unwrap().unwrap(); - assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); - - let conn = store.pool.get().unwrap(); - - assert!(redis::cmd("HEXISTS") - .arg(store.cache_key(key)) - .arg("ts") - .query::(&*conn) - .unwrap()); - } - - #[test] - fn test_redis_cache_set_w_tags() { - let store = setup(); - let mut v = [0u8; 1000]; - thread_rng().fill_bytes(&mut v); - let key = "testsetwtags"; - let tags = vec!["foo".to_string(), "bar".to_string()]; - - set_value( - &store, - key, - &v, - CacheSetOptions { - tags: Some(tags.clone()), - ttl: None, - meta: None, - }, - ) - .unwrap(); - - let entry = store.get(key.to_string()).wait().unwrap().unwrap(); - assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); - - let conn = store.pool.get().unwrap(); - - let fullkey = store.cache_key(key); - let ts = redis::cmd("HGET") - .arg(&fullkey) - .arg("ts") - .query::(&*conn) - .unwrap(); - - for tag in tags.iter() { - assert_eq!( - ts, - redis::cmd("ZSCORE") - .arg(store.tag_key(tag)) - .arg(&fullkey) - .query::(&*conn) - .unwrap() - ); + use super::*; + extern crate rand; + use self::rand::{thread_rng, RngCore}; + + fn setup() -> RedisCacheStore { + RedisCacheStore::new( + &RedisStoreConfig { + url: "redis://localhost:6379".to_string(), + namespace: Some("test".to_string()), + }, + None, + ) } - } - - #[test] - fn test_redis_cache_set_w_meta() { - let store = setup(); - let mut v = [0u8; 1000]; - thread_rng().fill_bytes(&mut v); - let key = "testsetwmeta"; - let meta = "foobar"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - tags: None, - ttl: None, - meta: Some(meta.to_string()), - }, - ) - .unwrap(); - - let entry = store.get(key.to_string()).wait().unwrap().unwrap(); - assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); - - let conn = store.pool.get().unwrap(); - - assert_eq!( - redis::cmd("HGET") - .arg(store.cache_key(key)) - .arg("meta") - .query::(&*conn) - .unwrap(), - meta - ); - } - - #[test] - fn test_redis_cache_purge_tags() { - let store = setup(); - let mut v = [0u8; 1000]; - thread_rng().fill_bytes(&mut v); - let key1 = "testpurge1"; - let key2 = "testpurge2"; - - set_value( - &store, - key1, - &v, - CacheSetOptions { - tags: Some(vec!["tag1".to_string(), "tag2".to_string()]), - ttl: None, - meta: None, - }, - ) - .unwrap(); - - set_value( - &store, - key2, - &v, - CacheSetOptions { - tags: Some(vec!["tag1".to_string()]), - ttl: None, - meta: None, - }, - ) - .unwrap(); - - store.purge_tag("tag2".to_string()).wait().unwrap(); - - let conn = store.pool.get().unwrap(); - - assert_eq!( - false, - redis::cmd("EXISTS") - .arg(store.cache_key(key1)) - .query::(&*conn) - .unwrap() - ); - } - - #[test] - fn test_redis_cache_set_w_ttl() { - let store = setup(); - let mut v = [0u8; 1000]; - thread_rng().fill_bytes(&mut v); - let key = "testsetwttl"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - tags: None, - ttl: Some(100), - meta: None, - }, - ) - .unwrap(); - - let entry = store.get(key.to_string()).wait().unwrap().unwrap(); - assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); - - let conn = store.pool.get().unwrap(); - - assert_eq!( - redis::cmd("TTL") - .arg(store.cache_key(key)) - .query::(&*conn) - .unwrap(), - 100 - ); - } - - #[test] - fn test_redis_cache_expire() { - let store = setup(); - let key = "testexpire"; - - store - .set( - key.to_string(), - Box::new(stream::empty::, ()>()), - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ) - .wait() - .unwrap(); - - store.expire(key.to_string(), 100).wait().unwrap(); - - let res = store.ttl(key.to_string()).wait().unwrap(); - - assert_eq!(res, 100); - } - - #[test] - fn test_redis_cache_del() { - let store = setup(); - let key = "testdel"; - - store - .set( - key.to_string(), - Box::new(stream::empty::, ()>()), - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ) - .wait() - .unwrap(); - - store.del(key.to_string()).wait().unwrap(); - - assert!(store.get(key.to_string()).wait().unwrap().is_none()); - } - - #[test] - fn test_redis_cache_set_tags() { - let store = setup(); - let key = "testsettags"; - - store - .set( - key.to_string(), - Box::new(stream::empty::, ()>()), - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ) - .wait() - .unwrap(); - - let tags = vec!["hello".to_string(), "world".to_string()]; - store - .set_tags(key.to_string(), tags.clone()) - .wait() - .unwrap(); - - let conn = store.pool.get().unwrap(); - - let fullkey = store.cache_key(key); - let ts = redis::cmd("HGET") - .arg(&fullkey) - .arg("ts") - .query::(&*conn) - .unwrap(); - - for tag in tags.iter() { - assert_eq!( - ts, - redis::cmd("ZSCORE") - .arg(store.tag_key(tag)) - .arg(&fullkey) - .query::(&*conn) - .unwrap() - ); + + fn set_value( + store: &RedisCacheStore, + key: &str, + v: &[u8], + opts: CacheSetOptions, + ) -> CacheResult<()> { + let size = 256; + let value = v.to_vec(); + store + .set( + key.to_string(), + Box::new(stream::unfold(0, move |pos| { + if pos >= value.len() { + return None; + } + let end = pos + size; + if end > value.len() { + Some(future::ok((value[pos..].to_vec(), end))) + } else { + Some(future::ok((value[pos..end].to_vec(), end))) + } + })), + opts, + ) + .wait() + } + + #[test] + fn test_redis_cache_set() { + let store = setup(); + let mut v = [0u8; 1000]; + thread_rng().fill_bytes(&mut v); + let key = "testset"; + set_value( + &store, + key, + &v, + CacheSetOptions { + tags: None, + ttl: None, + meta: None, + }, + ) + .unwrap(); + + let entry = store.get(key.to_string()).wait().unwrap().unwrap(); + assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); + + let conn = store.pool.get().unwrap(); + + assert!(redis::cmd("HEXISTS") + .arg(store.cache_key(key)) + .arg("ts") + .query::(&*conn) + .unwrap()); + } + + #[test] + fn test_redis_cache_set_w_tags() { + let store = setup(); + let mut v = [0u8; 1000]; + thread_rng().fill_bytes(&mut v); + let key = "testsetwtags"; + let tags = vec!["foo".to_string(), "bar".to_string()]; + + set_value( + &store, + key, + &v, + CacheSetOptions { + tags: Some(tags.clone()), + ttl: None, + meta: None, + }, + ) + .unwrap(); + + let entry = store.get(key.to_string()).wait().unwrap().unwrap(); + assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); + + let conn = store.pool.get().unwrap(); + + let fullkey = store.cache_key(key); + let ts = redis::cmd("HGET") + .arg(&fullkey) + .arg("ts") + .query::(&*conn) + .unwrap(); + + for tag in tags.iter() { + assert_eq!( + ts, + redis::cmd("ZSCORE") + .arg(store.tag_key(tag)) + .arg(&fullkey) + .query::(&*conn) + .unwrap() + ); + } + } + + #[test] + fn test_redis_cache_set_w_meta() { + let store = setup(); + let mut v = [0u8; 1000]; + thread_rng().fill_bytes(&mut v); + let key = "testsetwmeta"; + let meta = "foobar"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + tags: None, + ttl: None, + meta: Some(meta.to_string()), + }, + ) + .unwrap(); + + let entry = store.get(key.to_string()).wait().unwrap().unwrap(); + assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); + + let conn = store.pool.get().unwrap(); + + assert_eq!( + redis::cmd("HGET") + .arg(store.cache_key(key)) + .arg("meta") + .query::(&*conn) + .unwrap(), + meta + ); + } + + #[test] + fn test_redis_cache_purge_tags() { + let store = setup(); + let mut v = [0u8; 1000]; + thread_rng().fill_bytes(&mut v); + let key1 = "testpurge1"; + let key2 = "testpurge2"; + + set_value( + &store, + key1, + &v, + CacheSetOptions { + tags: Some(vec!["tag1".to_string(), "tag2".to_string()]), + ttl: None, + meta: None, + }, + ) + .unwrap(); + + set_value( + &store, + key2, + &v, + CacheSetOptions { + tags: Some(vec!["tag1".to_string()]), + ttl: None, + meta: None, + }, + ) + .unwrap(); + + store.purge_tag("tag2".to_string()).wait().unwrap(); + + let conn = store.pool.get().unwrap(); + + assert_eq!( + false, + redis::cmd("EXISTS") + .arg(store.cache_key(key1)) + .query::(&*conn) + .unwrap() + ); } - } + #[test] + fn test_redis_cache_set_w_ttl() { + let store = setup(); + let mut v = [0u8; 1000]; + thread_rng().fill_bytes(&mut v); + let key = "testsetwttl"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + tags: None, + ttl: Some(100), + meta: None, + }, + ) + .unwrap(); + + let entry = store.get(key.to_string()).wait().unwrap().unwrap(); + assert_eq!(v.to_vec(), entry.stream.concat2().wait().unwrap()); + + let conn = store.pool.get().unwrap(); + + assert_eq!( + redis::cmd("TTL") + .arg(store.cache_key(key)) + .query::(&*conn) + .unwrap(), + 100 + ); + } + + #[test] + fn test_redis_cache_expire() { + let store = setup(); + let key = "testexpire"; + + store + .set( + key.to_string(), + Box::new(stream::empty::, ()>()), + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ) + .wait() + .unwrap(); + + store.expire(key.to_string(), 100).wait().unwrap(); + + let res = store.ttl(key.to_string()).wait().unwrap(); + + assert_eq!(res, 100); + } + + #[test] + fn test_redis_cache_del() { + let store = setup(); + let key = "testdel"; + + store + .set( + key.to_string(), + Box::new(stream::empty::, ()>()), + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ) + .wait() + .unwrap(); + + store.del(key.to_string()).wait().unwrap(); + + assert!(store.get(key.to_string()).wait().unwrap().is_none()); + } + + #[test] + fn test_redis_cache_set_tags() { + let store = setup(); + let key = "testsettags"; + + store + .set( + key.to_string(), + Box::new(stream::empty::, ()>()), + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ) + .wait() + .unwrap(); + + let tags = vec!["hello".to_string(), "world".to_string()]; + store + .set_tags(key.to_string(), tags.clone()) + .wait() + .unwrap(); + + let conn = store.pool.get().unwrap(); + + let fullkey = store.cache_key(key); + let ts = redis::cmd("HGET") + .arg(&fullkey) + .arg("ts") + .query::(&*conn) + .unwrap(); + + for tag in tags.iter() { + assert_eq!( + ts, + redis::cmd("ZSCORE") + .arg(store.tag_key(tag)) + .arg(&fullkey) + .query::(&*conn) + .unwrap() + ); + } + } } diff --git a/src/redis_cache_notifier.rs b/src/redis_cache_notifier.rs index 6b47590..c7d2895 100644 --- a/src/redis_cache_notifier.rs +++ b/src/redis_cache_notifier.rs @@ -127,8 +127,7 @@ fn notification_listen(reader_url: String, cache_url: String) { // } // } // }; - - + let mut pubcon = client.get_connection().unwrap(); let mut pubsub = pubcon.as_pubsub(); @@ -218,7 +217,11 @@ mod tests { use super::*; fn setup() -> RedisCacheNotifier { - redis::cmd("CONFIG").arg("SET").arg("notify-keyspace-events").arg("KEA").execute(&redis::Client::open("redis://localhost:6379").unwrap()); + redis::cmd("CONFIG") + .arg("SET") + .arg("notify-keyspace-events") + .arg("KEA") + .execute(&redis::Client::open("redis://localhost:6379").unwrap()); RedisCacheNotifier::new( RedisCacheNotifierConfig { @@ -230,7 +233,10 @@ mod tests { } fn redis_conn() -> redis::Connection { - redis::Client::open("redis://localhost:6379").unwrap().get_connection().unwrap() + redis::Client::open("redis://localhost:6379") + .unwrap() + .get_connection() + .unwrap() } #[test] @@ -256,10 +262,12 @@ mod tests { let testns = "testns".to_string(); - let handle = thread::spawn(move||{ + let handle = thread::spawn(move || { let mut conn_for_pubsub = redis_conn(); let mut pconn = conn_for_pubsub.as_pubsub(); - pconn.subscribe(format!("__keyspace@0__:{}", key).as_str()).unwrap(); + pconn + .subscribe(format!("__keyspace@0__:{}", key).as_str()) + .unwrap(); pconn.get_message().unwrap(); }); diff --git a/src/runtime.rs b/src/runtime.rs index 534c97e..27549eb 100644 --- a/src/runtime.rs +++ b/src/runtime.rs @@ -12,8 +12,8 @@ use std::io::Read; use libfly::*; use futures::{ - sync::{mpsc, oneshot}, - Future, + sync::{mpsc, oneshot}, + Future, }; use std::collections::HashMap; @@ -53,12 +53,12 @@ use crate::v8env::{DEV_TOOLS_SOURCE, FLY_SNAPSHOT}; use crate::runtime_permissions::RuntimePermissions; use crate::settings::{ - AcmeStoreConfig, CacheStore, CacheStoreNotifier, DataStore, FsStore, Settings, + AcmeStoreConfig, CacheStore, CacheStoreNotifier, DataStore, FsStore, Settings, }; use crate::module_resolver::{ - LoadedModule, LocalDiskModuleResolver, ModuleResolver, ModuleResolverManager, RefererInfo, - StandardModuleResolverManager, + LoadedModule, LocalDiskModuleResolver, ModuleResolver, ModuleResolverManager, RefererInfo, + StandardModuleResolverManager, }; use super::NEXT_FUTURE_ID; @@ -74,505 +74,505 @@ unsafe impl Send for JsRuntime {} unsafe impl Sync for JsRuntime {} impl JsRuntime { - pub fn send(&self, buf: fly_buf, raw: Option) { - unsafe { - js_send( - self.0, - buf, - match raw { - Some(r) => r, - None => null_buf(), - }, - ) - }; - } + pub fn send(&self, buf: fly_buf, raw: Option) { + unsafe { + js_send( + self.0, + buf, + match raw { + Some(r) => r, + None => null_buf(), + }, + ) + }; + } - pub fn send_error(&self, cmd_id: u32, err: FlyError) { - let buf = build_error(cmd_id, err).unwrap(); - self.send(fly_buf_from(buf), None); - } + pub fn send_error(&self, cmd_id: u32, err: FlyError) { + let buf = build_error(cmd_id, err).unwrap(); + self.send(fly_buf_from(buf), None); + } - pub fn to_runtime<'a>(&self) -> &'a mut Runtime { - unsafe { Runtime::from_raw(self.0) } - } + pub fn to_runtime<'a>(&self) -> &'a mut Runtime { + unsafe { Runtime::from_raw(self.0) } + } } pub struct Runtime { - pub ptr: JsRuntime, - pub name: String, - pub version: String, - pub app_logger: Logger, - pub event_loop: Mutex, - pub timers: Mutex>>, - pub responses: Mutex>>, - pub dns_responses: Mutex>>, - pub streams: Mutex>>>, - pub cache_store: Box, - pub data_store: Box, - pub fs_store: Box, - pub acme_store: Option>, - pub fetch_events: Option>, - pub resolv_events: Option>, - pub last_event_at: AtomicUsize, - pub module_resolver_manager: Box, - pub msg_handler: Box, - pub permissions: RuntimePermissions, - pub dev_tools: bool, - metadata_cache: RwLock>>, - ready_ch: Option>, - quit_ch: Option>, + pub ptr: JsRuntime, + pub name: String, + pub version: String, + pub app_logger: Logger, + pub event_loop: Mutex, + pub timers: Mutex>>, + pub responses: Mutex>>, + pub dns_responses: Mutex>>, + pub streams: Mutex>>>, + pub cache_store: Box, + pub data_store: Box, + pub fs_store: Box, + pub acme_store: Option>, + pub fetch_events: Option>, + pub resolv_events: Option>, + pub last_event_at: AtomicUsize, + pub module_resolver_manager: Box, + pub msg_handler: Box, + pub permissions: RuntimePermissions, + pub dev_tools: bool, + metadata_cache: RwLock>>, + ready_ch: Option>, + quit_ch: Option>, } static JSINIT: Once = Once::new(); fn init_event_loop( - name: String, + name: String, ) -> ( - current_thread::Handle, - oneshot::Sender<()>, - oneshot::Receiver<()>, -) { - let (c, p) = oneshot::channel::<( current_thread::Handle, oneshot::Sender<()>, oneshot::Receiver<()>, - )>(); - thread::Builder::new() - .name(format!("runtime-loop-{}", name)) - .spawn(move || { - let mut el = current_thread::Runtime::new().unwrap(); - let (txready, rxready) = oneshot::channel::<()>(); - let (txquit, rxquit) = oneshot::channel::<()>(); - - c.send((el.handle(), txready, rxquit)).unwrap(); - - // keep it alive at least until all scripts are evaled - el.spawn( - rxready - .map_err(|_| error!("error recving ready signal for runtime")) - .and_then(|_| Ok(trace!("ready ch received!"))), - ); - - match el.run() { - Ok(_) => trace!("runtime event loop ran fine"), - Err(e) => error!("error running runtime event loop: {}", e), - }; - trace!("Event loop has run its course."); - match txquit.send(()) { - Ok(_) => trace!("Sent quit () in channel successfully."), - Err(_) => error!("error sending quit signal for runtime"), - }; - }) - .unwrap(); - p.wait().unwrap() +) { + let (c, p) = oneshot::channel::<( + current_thread::Handle, + oneshot::Sender<()>, + oneshot::Receiver<()>, + )>(); + thread::Builder::new() + .name(format!("runtime-loop-{}", name)) + .spawn(move || { + let mut el = current_thread::Runtime::new().unwrap(); + let (txready, rxready) = oneshot::channel::<()>(); + let (txquit, rxquit) = oneshot::channel::<()>(); + + c.send((el.handle(), txready, rxquit)).unwrap(); + + // keep it alive at least until all scripts are evaled + el.spawn( + rxready + .map_err(|_| error!("error recving ready signal for runtime")) + .and_then(|_| Ok(trace!("ready ch received!"))), + ); + + match el.run() { + Ok(_) => trace!("runtime event loop ran fine"), + Err(e) => error!("error running runtime event loop: {}", e), + }; + trace!("Event loop has run its course."); + match txquit.send(()) { + Ok(_) => trace!("Sent quit () in channel successfully."), + Err(_) => error!("error sending quit signal for runtime"), + }; + }) + .unwrap(); + p.wait().unwrap() } pub struct RuntimeConfig<'a> { - pub name: Option, - pub version: Option, - pub settings: &'a Settings, - pub module_resolvers: Option>>, - pub app_logger: &'a Logger, - pub msg_handler: Option>, - pub permissions: Option, - pub dev_tools: bool, + pub name: Option, + pub version: Option, + pub settings: &'a Settings, + pub module_resolvers: Option>>, + pub app_logger: &'a Logger, + pub msg_handler: Option>, + pub permissions: Option, + pub dev_tools: bool, } impl Runtime { - pub fn new(config: RuntimeConfig) -> Box { - JSINIT.call_once(|| unsafe { js_init() }); - - let rt_name = config.name.unwrap_or("v8".to_string()); - let rt_version = config.version.unwrap_or("0".to_string()); - let app_logger = config - .app_logger - .new(slog_o!("app_name" => rt_name.to_owned(), "app_version" => rt_version.to_owned())); - let (rthandle, txready, rxquit) = init_event_loop(format!("{}-{}", rt_name, rt_version)); - let rt_module_resolvers = - config.module_resolvers.unwrap_or(vec![ - Box::new(LocalDiskModuleResolver::new(None)) as Box - ]); - - let mut rt = Box::new(Runtime { - ptr: JsRuntime(ptr::null() as *const js_runtime), - name: rt_name, - version: rt_version, - app_logger: app_logger, - event_loop: Mutex::new(rthandle.clone()), - ready_ch: Some(txready), - quit_ch: Some(rxquit), - timers: Mutex::new(HashMap::new()), - responses: Mutex::new(HashMap::new()), - dns_responses: Mutex::new(HashMap::new()), - streams: Mutex::new(HashMap::new()), - // stream_recv: Mutex::new(HashMap::new()), - fetch_events: None, - resolv_events: None, - cache_store: match config.settings.cache_store { - Some(ref store) => match store { - CacheStore::Sqlite(conf) => { - Box::new(sqlite_cache::SqliteCacheStore::new(conf.filename.clone())) - } - CacheStore::Redis(conf) => Box::new(redis_cache::RedisCacheStore::new( - &conf, - match config.settings.cache_store_notifier { - None => None, - Some(CacheStoreNotifier::Redis(ref csnconf)) => Some(csnconf.clone()), + pub fn new(config: RuntimeConfig) -> Box { + JSINIT.call_once(|| unsafe { js_init() }); + + let rt_name = config.name.unwrap_or("v8".to_string()); + let rt_version = config.version.unwrap_or("0".to_string()); + let app_logger = config + .app_logger + .new(slog_o!("app_name" => rt_name.to_owned(), "app_version" => rt_version.to_owned())); + let (rthandle, txready, rxquit) = init_event_loop(format!("{}-{}", rt_name, rt_version)); + let rt_module_resolvers = + config.module_resolvers.unwrap_or(vec![ + Box::new(LocalDiskModuleResolver::new(None)) as Box + ]); + + let mut rt = Box::new(Runtime { + ptr: JsRuntime(ptr::null() as *const js_runtime), + name: rt_name, + version: rt_version, + app_logger: app_logger, + event_loop: Mutex::new(rthandle.clone()), + ready_ch: Some(txready), + quit_ch: Some(rxquit), + timers: Mutex::new(HashMap::new()), + responses: Mutex::new(HashMap::new()), + dns_responses: Mutex::new(HashMap::new()), + streams: Mutex::new(HashMap::new()), + // stream_recv: Mutex::new(HashMap::new()), + fetch_events: None, + resolv_events: None, + cache_store: match config.settings.cache_store { + Some(ref store) => match store { + CacheStore::Sqlite(conf) => { + Box::new(sqlite_cache::SqliteCacheStore::new(conf.filename.clone())) + } + CacheStore::Redis(conf) => Box::new(redis_cache::RedisCacheStore::new( + &conf, + match config.settings.cache_store_notifier { + None => None, + Some(CacheStoreNotifier::Redis(ref csnconf)) => Some(csnconf.clone()), + }, + )), + }, + None => Box::new(sqlite_cache::SqliteCacheStore::new("cache.db".to_string())), }, - )), - }, - None => Box::new(sqlite_cache::SqliteCacheStore::new("cache.db".to_string())), - }, - data_store: match config.settings.data_store { - Some(ref store) => match store { - DataStore::Sqlite(conf) => { - Box::new(sqlite_data::SqliteDataStore::new(conf.filename.clone())) - } - DataStore::Postgres(conf) => Box::new(postgres_data::PostgresDataStore::new(&conf)), - }, - None => Box::new(sqlite_data::SqliteDataStore::new("data.db".to_string())), - }, - fs_store: match config.settings.fs_store { - Some(ref store) => match store { - FsStore::Redis(conf) => Box::new(redis_fs::RedisFsStore::new(&conf)), - FsStore::Disk => Box::new(disk_fs::DiskFsStore::new()), - }, - None => Box::new(disk_fs::DiskFsStore::new()), - }, - acme_store: match config.settings.acme_store { - Some(ref config) => match config { - AcmeStoreConfig::Redis(config) => { - Some(Box::new(redis_acme::RedisAcmeStore::new(&config))) - } - }, - None => None, - }, - last_event_at: ATOMIC_USIZE_INIT, - module_resolver_manager: Box::new(StandardModuleResolverManager::new( - rt_module_resolvers, - None, - )), - metadata_cache: RwLock::new(HashMap::new()), - msg_handler: config - .msg_handler - .unwrap_or(Box::new(DefaultMessageHandler {})), - permissions: config.permissions.unwrap_or_default(), - dev_tools: config.dev_tools, - }); - - (*rt).ptr.0 = unsafe { - let ptr = js_runtime_new(js_runtime_options { - snapshot: *FLY_SNAPSHOT, - data: rt.as_ref() as *const _ as *mut libc::c_void, - recv_cb: msg_from_js, - print_cb: print_from_js, - resolve_cb: resolve_callback, - soft_memory_limit: 128, - hard_memory_limit: 256, - }); - let cfilename = CString::new("fly_main.js").unwrap(); - let cscript = CString::new("flyMain()").unwrap(); - js_eval(ptr, cfilename.as_ptr(), cscript.as_ptr()); - ptr - }; + data_store: match config.settings.data_store { + Some(ref store) => match store { + DataStore::Sqlite(conf) => { + Box::new(sqlite_data::SqliteDataStore::new(conf.filename.clone())) + } + DataStore::Postgres(conf) => { + Box::new(postgres_data::PostgresDataStore::new(&conf)) + } + }, + None => Box::new(sqlite_data::SqliteDataStore::new("data.db".to_string())), + }, + fs_store: match config.settings.fs_store { + Some(ref store) => match store { + FsStore::Redis(conf) => Box::new(redis_fs::RedisFsStore::new(&conf)), + FsStore::Disk => Box::new(disk_fs::DiskFsStore::new()), + }, + None => Box::new(disk_fs::DiskFsStore::new()), + }, + acme_store: match config.settings.acme_store { + Some(ref config) => match config { + AcmeStoreConfig::Redis(config) => { + Some(Box::new(redis_acme::RedisAcmeStore::new(&config))) + } + }, + None => None, + }, + last_event_at: ATOMIC_USIZE_INIT, + module_resolver_manager: Box::new(StandardModuleResolverManager::new( + rt_module_resolvers, + None, + )), + metadata_cache: RwLock::new(HashMap::new()), + msg_handler: config + .msg_handler + .unwrap_or(Box::new(DefaultMessageHandler {})), + permissions: config.permissions.unwrap_or_default(), + dev_tools: config.dev_tools, + }); + + (*rt).ptr.0 = unsafe { + let ptr = js_runtime_new(js_runtime_options { + snapshot: *FLY_SNAPSHOT, + data: rt.as_ref() as *const _ as *mut libc::c_void, + recv_cb: msg_from_js, + print_cb: print_from_js, + resolve_cb: resolve_callback, + soft_memory_limit: 128, + hard_memory_limit: 256, + }); + let cfilename = CString::new("fly_main.js").unwrap(); + let cscript = CString::new("flyMain()").unwrap(); + js_eval(ptr, cfilename.as_ptr(), cscript.as_ptr()); + ptr + }; + + if config.dev_tools { + debug!("Loading dev tools"); + rt.eval("dev-tools.js", *DEV_TOOLS_SOURCE); + rt.eval("", "installDevTools();"); + debug!("Loading dev tools done"); + } - if config.dev_tools { - debug!("Loading dev tools"); - rt.eval("dev-tools.js", *DEV_TOOLS_SOURCE); - rt.eval("", "installDevTools();"); - debug!("Loading dev tools done"); + rt } - rt - } + pub fn eval(&self, filename: &str, code: &str) { + debug!("evaluating '{}'", filename); + let cfilename = CString::new(filename).unwrap(); + let ccode = CString::new(code).unwrap(); + let ptr = self.ptr; + unsafe { + js_eval(ptr.0, cfilename.as_ptr(), ccode.as_ptr()); + } + debug!("finished evaluating '{}'", cfilename.to_string_lossy()); + } + + pub fn eval_file(&self, filename: &str) { + let mut file = File::open(filename).unwrap(); + let mut contents = String::new(); + file.read_to_string(&mut contents).unwrap(); - pub fn eval(&self, filename: &str, code: &str) { - debug!("evaluating '{}'", filename); - let cfilename = CString::new(filename).unwrap(); - let ccode = CString::new(code).unwrap(); - let ptr = self.ptr; - unsafe { - js_eval(ptr.0, cfilename.as_ptr(), ccode.as_ptr()); + self.eval(filename, contents.as_str()) } - debug!("finished evaluating '{}'", cfilename.to_string_lossy()); - } - pub fn eval_file(&self, filename: &str) { - let mut file = File::open(filename).unwrap(); - let mut contents = String::new(); - file.read_to_string(&mut contents).unwrap(); + pub fn eval_file_with_dev_tools(&self, filename: &str) { + self.eval(filename, &format!("dev.run('{}')", filename)); + } - self.eval(filename, contents.as_str()) - } + pub fn heap_statistics(&self) -> js_heap_stats { + unsafe { js_runtime_heap_statistics(self.ptr.0) } + } - pub fn eval_file_with_dev_tools(&self, filename: &str) { - self.eval(filename, &format!("dev.run('{}')", filename)); - } + pub unsafe fn from_raw<'a>(raw: *const js_runtime) -> &'a mut Self { + let ptr = js_get_data(raw) as *mut _; + &mut *ptr + } - pub fn heap_statistics(&self) -> js_heap_stats { - unsafe { js_runtime_heap_statistics(self.ptr.0) } - } + pub fn dispose(&mut self) { + { + // stop listening to events + self.fetch_events.take(); + self.resolv_events.take(); + }; + + match self.timers.lock() { + Ok(mut timers) => timers.clear(), + Err(_) => error!("error acquiring lock to clear timers"), + }; + + match self.streams.lock() { + Ok(mut streams) => streams.clear(), + Err(_) => error!("error acquiring lock to clear streams"), + }; + + unsafe { + js_runtime_dispose(self.ptr.0); + }; + } - pub unsafe fn from_raw<'a>(raw: *const js_runtime) -> &'a mut Self { - let ptr = js_get_data(raw) as *mut _; - &mut *ptr - } + pub fn run(&mut self) -> oneshot::Receiver<()> { + self.ready_ch.take().unwrap().send(()).unwrap(); //TODO: no unwrap + self.quit_ch.take().unwrap() + } - pub fn dispose(&mut self) { + pub fn spawn(&self, fut: F) + where + F: Future + Send + 'static, { - // stop listening to events - self.fetch_events.take(); - self.resolv_events.take(); - }; - - match self.timers.lock() { - Ok(mut timers) => timers.clear(), - Err(_) => error!("error acquiring lock to clear timers"), - }; + let n = NEXT_FUTURE_ID.fetch_add(1, Ordering::SeqCst); + trace!("SPAWNING A FUTURE! id: {}", n); + self.event_loop + .lock() + .unwrap() + .spawn(fut.then(move |_| Ok(trace!("SPAWNED FUTURE IS DONE id: {}", n)))) + .unwrap(); + } - match self.streams.lock() { - Ok(mut streams) => streams.clear(), - Err(_) => error!("error acquiring lock to clear streams"), - }; + pub fn dispatch_event( + &self, + id: u32, + event: JsEvent, + ) -> Option> { + let res = match event { + JsEvent::Fetch(req) => match self.fetch_events { + None => return None, + Some(ref ch) => match self.responses.lock() { + Ok(mut guard) => { + let (tx, rx) = oneshot::channel::(); + guard.insert(id, tx); + match ch.unbounded_send(req) { + Ok(_) => EventResponseChannel::Http(rx), + Err(e) => return Some(Err(EventDispatchError::Http(e))), + } + } + Err(_) => return Some(Err(EventDispatchError::PoisonedLock)), + }, + }, + JsEvent::Resolv(req) => match self.resolv_events { + None => return None, + Some(ref ch) => match self.dns_responses.lock() { + Ok(mut guard) => { + let (tx, rx) = oneshot::channel::(); + guard.insert(id, tx); + match ch.unbounded_send(req) { + Ok(_) => EventResponseChannel::Dns(rx), + Err(e) => return Some(Err(EventDispatchError::Dns(e))), + } + } + Err(_) => return Some(Err(EventDispatchError::PoisonedLock)), + }, + }, + }; - unsafe { - js_runtime_dispose(self.ptr.0); - }; - } - - pub fn run(&mut self) -> oneshot::Receiver<()> { - self.ready_ch.take().unwrap().send(()).unwrap(); //TODO: no unwrap - self.quit_ch.take().unwrap() - } - - pub fn spawn(&self, fut: F) - where - F: Future + Send + 'static, - { - let n = NEXT_FUTURE_ID.fetch_add(1, Ordering::SeqCst); - trace!("SPAWNING A FUTURE! id: {}", n); - self - .event_loop - .lock() - .unwrap() - .spawn(fut.then(move |_| Ok(trace!("SPAWNED FUTURE IS DONE id: {}", n)))) - .unwrap(); - } - - pub fn dispatch_event( - &self, - id: u32, - event: JsEvent, - ) -> Option> { - let res = match event { - JsEvent::Fetch(req) => match self.fetch_events { - None => return None, - Some(ref ch) => match self.responses.lock() { - Ok(mut guard) => { - let (tx, rx) = oneshot::channel::(); - guard.insert(id, tx); - match ch.unbounded_send(req) { - Ok(_) => EventResponseChannel::Http(rx), - Err(e) => return Some(Err(EventDispatchError::Http(e))), - } - } - Err(_) => return Some(Err(EventDispatchError::PoisonedLock)), - }, - }, - JsEvent::Resolv(req) => match self.resolv_events { - None => return None, - Some(ref ch) => match self.dns_responses.lock() { - Ok(mut guard) => { - let (tx, rx) = oneshot::channel::(); - guard.insert(id, tx); - match ch.unbounded_send(req) { - Ok(_) => EventResponseChannel::Dns(rx), - Err(e) => return Some(Err(EventDispatchError::Dns(e))), - } - } - Err(_) => return Some(Err(EventDispatchError::PoisonedLock)), - }, - }, - }; + if let Ok(epoch) = time::SystemTime::now().duration_since(time::UNIX_EPOCH) { + self.last_event_at + .store(epoch.as_secs() as usize, Ordering::SeqCst); + } - if let Ok(epoch) = time::SystemTime::now().duration_since(time::UNIX_EPOCH) { - self - .last_event_at - .store(epoch.as_secs() as usize, Ordering::SeqCst); + Some(Ok(res)) } - Some(Ok(res)) - } - - pub fn get_module_metadata(&self, hash: &i32) -> Option> { - return match self.metadata_cache.read().unwrap().get(hash) { - Some(v) => Some((*v).clone()), - None => None, - }; - } + pub fn get_module_metadata(&self, hash: &i32) -> Option> { + return match self.metadata_cache.read().unwrap().get(hash) { + Some(v) => Some((*v).clone()), + None => None, + }; + } - pub fn insert_module_metadata(&mut self, hash: i32, module_metadata: LoadedModule) { - let locked_cache = self.metadata_cache.get_mut().unwrap(); - if locked_cache.contains_key(&hash) { - error!("Attempted to overwrite entry in module metadata cache."); - } else { - locked_cache.insert(hash, Box::new(module_metadata)); + pub fn insert_module_metadata(&mut self, hash: i32, module_metadata: LoadedModule) { + let locked_cache = self.metadata_cache.get_mut().unwrap(); + if locked_cache.contains_key(&hash) { + error!("Attempted to overwrite entry in module metadata cache."); + } else { + locked_cache.insert(hash, Box::new(module_metadata)); + } } - } } lazy_static! { - static ref GENERIC_EVENT_LOOP: tokio::runtime::Runtime = { - let el = tokio::runtime::Runtime::new().unwrap(); - el - }; - pub static ref EVENT_LOOP: (tokio::runtime::TaskExecutor, oneshot::Sender<()>) = { - let el = tokio::runtime::Runtime::new().unwrap(); - let exec = el.executor(); - let (tx, rx) = oneshot::channel::<()>(); - thread::Builder::new() - .name("main-event-loop".to_string()) - .spawn(move || { - el.block_on_all(rx).unwrap(); - }) - .unwrap(); - (exec, tx) - }; + static ref GENERIC_EVENT_LOOP: tokio::runtime::Runtime = { + let el = tokio::runtime::Runtime::new().unwrap(); + el + }; + pub static ref EVENT_LOOP: (tokio::runtime::TaskExecutor, oneshot::Sender<()>) = { + let el = tokio::runtime::Runtime::new().unwrap(); + let exec = el.executor(); + let (tx, rx) = oneshot::channel::<()>(); + thread::Builder::new() + .name("main-event-loop".to_string()) + .spawn(move || { + el.block_on_all(rx).unwrap(); + }) + .unwrap(); + (exec, tx) + }; } pub extern "C" fn msg_from_js(raw: *const js_runtime, buf: fly_buf, raw_buf: fly_buf) { - let bytes = unsafe { slice::from_raw_parts(buf.data_ptr, buf.data_len) }; - let base = msg::get_root_as_base(bytes); - let ptr = JsRuntime(raw); - let rt = ptr.to_runtime(); - - let msg_type = base.msg_type(); - let cmd_id = base.cmd_id(); - - let fut = rt - .msg_handler - .handle_msg(ptr.to_runtime(), &base, raw_buf) - .or_else(move |err| { - error!("error in {:?}: {:?}", msg_type, err); - Ok(build_error(cmd_id, err)) - }); - - if base.sync() { - // Execute future synchronously. - let maybe_box_u8 = fut.wait().unwrap(); - match maybe_box_u8 { - None => {} - Some(box_u8) => { - let buf = fly_buf_from(box_u8); - // Set the synchronous response, the value returned from deno.send(). - unsafe { js_set_response(ptr.0, buf) } - } - } - } else { - // debug!("DOING ASYNC MSG"); - let fut = fut.and_then(move |maybe_box_u8| { - let buf = match maybe_box_u8 { - Some(box_u8) => fly_buf_from(box_u8), - None => { - // async RPCs that return None still need to - // send a message back to signal completion. - let builder = &mut FlatBufferBuilder::new(); - fly_buf_from( - serialize_response( - cmd_id, - builder, - msg::BaseArgs { - ..Default::default() - }, - ) - .unwrap(), - ) - } - }; - ptr.send(buf, None); - Ok(()) - }); + let bytes = unsafe { slice::from_raw_parts(buf.data_ptr, buf.data_len) }; + let base = msg::get_root_as_base(bytes); + let ptr = JsRuntime(raw); let rt = ptr.to_runtime(); - rt.spawn(fut); - } + + let msg_type = base.msg_type(); + let cmd_id = base.cmd_id(); + + let fut = rt + .msg_handler + .handle_msg(ptr.to_runtime(), &base, raw_buf) + .or_else(move |err| { + error!("error in {:?}: {:?}", msg_type, err); + Ok(build_error(cmd_id, err)) + }); + + if base.sync() { + // Execute future synchronously. + let maybe_box_u8 = fut.wait().unwrap(); + match maybe_box_u8 { + None => {} + Some(box_u8) => { + let buf = fly_buf_from(box_u8); + // Set the synchronous response, the value returned from deno.send(). + unsafe { js_set_response(ptr.0, buf) } + } + } + } else { + // debug!("DOING ASYNC MSG"); + let fut = fut.and_then(move |maybe_box_u8| { + let buf = match maybe_box_u8 { + Some(box_u8) => fly_buf_from(box_u8), + None => { + // async RPCs that return None still need to + // send a message back to signal completion. + let builder = &mut FlatBufferBuilder::new(); + fly_buf_from( + serialize_response( + cmd_id, + builder, + msg::BaseArgs { + ..Default::default() + }, + ) + .unwrap(), + ) + } + }; + ptr.send(buf, None); + Ok(()) + }); + let rt = ptr.to_runtime(); + rt.spawn(fut); + } } pub unsafe extern "C" fn print_from_js(raw: *const js_runtime, lvl: i8, msg: *const libc::c_char) { - let rt = Runtime::from_raw(raw); - let msg = CStr::from_ptr(msg).to_string_lossy().into_owned(); - - match lvl { - // print to STDOUT, no logging - 0 => println!("{}", msg), - - // runtime messages from logger - 1 => slog_error!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), - 2 => slog_warn!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), - 3 => slog_info!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), - 4 => slog_debug!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), - 5 => slog_trace!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), - - // app messages from console - 11 => slog_error!(rt.app_logger, #"app", "{}", msg; "source" => "app"), - 12 => slog_warn!(rt.app_logger, #"app", "{}", msg; "source" => "app"), - 13 => slog_info!(rt.app_logger, #"app", "{}", msg; "source" => "app"), - 14 => slog_debug!(rt.app_logger, #"app", "{}", msg; "source" => "app"), - 15 => slog_trace!(rt.app_logger, #"app", "{}", msg; "source" => "app"), - - _ => slog_info!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), - }; + let rt = Runtime::from_raw(raw); + let msg = CStr::from_ptr(msg).to_string_lossy().into_owned(); + + match lvl { + // print to STDOUT, no logging + 0 => println!("{}", msg), + + // runtime messages from logger + 1 => slog_error!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), + 2 => slog_warn!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), + 3 => slog_info!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), + 4 => slog_debug!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), + 5 => slog_trace!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), + + // app messages from console + 11 => slog_error!(rt.app_logger, #"app", "{}", msg; "source" => "app"), + 12 => slog_warn!(rt.app_logger, #"app", "{}", msg; "source" => "app"), + 13 => slog_info!(rt.app_logger, #"app", "{}", msg; "source" => "app"), + 14 => slog_debug!(rt.app_logger, #"app", "{}", msg; "source" => "app"), + 15 => slog_trace!(rt.app_logger, #"app", "{}", msg; "source" => "app"), + + _ => slog_info!(rt.app_logger, #"runtime", "{}", msg; "source" => "v8env"), + }; } pub unsafe extern "C" fn resolve_callback( - raw: *const js_runtime, - specifier: *const libc::c_char, - referer_identity_hash: i32, + raw: *const js_runtime, + specifier: *const libc::c_char, + referer_identity_hash: i32, ) -> js_compiled_module { - let rt = Runtime::from_raw(raw); - let specifier_str = CStr::from_ptr(specifier).to_string_lossy().into_owned(); - - let referer_loaded_module = match rt.get_module_metadata(&referer_identity_hash) { - Some(v) => v, - None => { - error!("Failed to find module hash in metadata cache! Exiting."); - std::process::exit(1); - } - }; - - let loaded_module = match rt.module_resolver_manager.resolve_module( - specifier_str, - Some(RefererInfo { - origin_url: referer_loaded_module.origin_url, - is_wasm: Some(referer_loaded_module.loaded_source.is_wasm), - source_code: Some(referer_loaded_module.loaded_source.source), - indentifier_hash: Some(referer_identity_hash), - }), - ) { - Ok(v) => v, - Err(e) => { - error!("Failed to resolve and load module! Exiting. {}", e); - std::process::exit(1); + let rt = Runtime::from_raw(raw); + let specifier_str = CStr::from_ptr(specifier).to_string_lossy().into_owned(); + + let referer_loaded_module = match rt.get_module_metadata(&referer_identity_hash) { + Some(v) => v, + None => { + error!("Failed to find module hash in metadata cache! Exiting."); + std::process::exit(1); + } + }; + + let loaded_module = match rt.module_resolver_manager.resolve_module( + specifier_str, + Some(RefererInfo { + origin_url: referer_loaded_module.origin_url, + is_wasm: Some(referer_loaded_module.loaded_source.is_wasm), + source_code: Some(referer_loaded_module.loaded_source.source), + indentifier_hash: Some(referer_identity_hash), + }), + ) { + Ok(v) => v, + Err(e) => { + error!("Failed to resolve and load module! Exiting. {}", e); + std::process::exit(1); + } + }; + + let module_data = js_module_data { + origin_url: CString::new(loaded_module.origin_url).unwrap().as_ptr(), + source_map_url: CString::new("").unwrap().as_ptr(), + is_wasm: loaded_module.loaded_source.is_wasm, + source_code: fly_simple_buf { + ptr: CString::new(loaded_module.loaded_source.source.as_str()) + .unwrap() + .as_ptr(), + len: loaded_module.loaded_source.source.len() as i32, + }, + }; + + let compile_result = js_compile_module(raw, module_data); + + if compile_result.success { + return compile_result.compiled_module; + } else { + error!("Module compile failed! Exiting."); + std::process::exit(1); } - }; - - let module_data = js_module_data { - origin_url: CString::new(loaded_module.origin_url).unwrap().as_ptr(), - source_map_url: CString::new("").unwrap().as_ptr(), - is_wasm: loaded_module.loaded_source.is_wasm, - source_code: fly_simple_buf { - ptr: CString::new(loaded_module.loaded_source.source.as_str()) - .unwrap() - .as_ptr(), - len: loaded_module.loaded_source.source.len() as i32, - }, - }; - - let compile_result = js_compile_module(raw, module_data); - - if compile_result.success { - return compile_result.compiled_module; - } else { - error!("Module compile failed! Exiting."); - std::process::exit(1); - } } diff --git a/src/runtime_permissions.rs b/src/runtime_permissions.rs index 7bc900c..3e7629a 100644 --- a/src/runtime_permissions.rs +++ b/src/runtime_permissions.rs @@ -2,25 +2,25 @@ use crate::errors::{permission_denied, FlyResult}; #[derive(Debug)] pub struct RuntimePermissions { - pub allow_os: bool, + pub allow_os: bool, } impl RuntimePermissions { - pub fn new(allow_os: bool) -> Self { - Self { allow_os } - } + pub fn new(allow_os: bool) -> Self { + Self { allow_os } + } - pub fn check_os(&self) -> FlyResult<()> { - if self.allow_os { - Ok(()) - } else { - Err(permission_denied()) + pub fn check_os(&self) -> FlyResult<()> { + if self.allow_os { + Ok(()) + } else { + Err(permission_denied()) + } } - } } impl Default for RuntimePermissions { - fn default() -> Self { - RuntimePermissions { allow_os: false } - } + fn default() -> Self { + RuntimePermissions { allow_os: false } + } } diff --git a/src/settings.rs b/src/settings.rs index a2006fb..4dd2bbb 100644 --- a/src/settings.rs +++ b/src/settings.rs @@ -3,95 +3,95 @@ use self::config::{Config, ConfigError, Environment, File}; use std::sync::RwLock; lazy_static! { - pub static ref SETTINGS: RwLock = RwLock::new(Settings::new().unwrap()); + pub static ref SETTINGS: RwLock = RwLock::new(Settings::new().unwrap()); } #[derive(Debug, Deserialize, Clone)] pub struct SqliteStoreConfig { - pub filename: String, + pub filename: String, } #[derive(Debug, Deserialize, Clone)] pub struct PostgresStoreConfig { - pub url: String, - pub database: Option, - pub tls_client_crt: Option, - pub tls_client_key: Option, - pub tls_ca_crt: Option, + pub url: String, + pub database: Option, + pub tls_client_crt: Option, + pub tls_client_key: Option, + pub tls_ca_crt: Option, } #[derive(Debug, Deserialize, Clone)] pub struct RedisStoreConfig { - pub url: String, - pub namespace: Option, + pub url: String, + pub namespace: Option, } #[derive(Debug, Deserialize, Clone)] pub struct RedisCacheNotifierConfig { - pub reader_url: String, - pub writer_url: String, + pub reader_url: String, + pub writer_url: String, } #[derive(Debug, Deserialize, Clone)] #[serde(tag = "type", rename_all = "snake_case")] pub enum FsStore { - Redis(RedisStoreConfig), - Disk, + Redis(RedisStoreConfig), + Disk, } #[derive(Debug, Deserialize, Clone)] #[serde(tag = "type", rename_all = "snake_case")] pub enum DataStore { - Sqlite(SqliteStoreConfig), - Postgres(PostgresStoreConfig), + Sqlite(SqliteStoreConfig), + Postgres(PostgresStoreConfig), } #[derive(Debug, Deserialize, Clone)] #[serde(tag = "type", rename_all = "snake_case")] pub enum CacheStore { - Sqlite(SqliteStoreConfig), - Redis(RedisStoreConfig), + Sqlite(SqliteStoreConfig), + Redis(RedisStoreConfig), } #[derive(Debug, Deserialize, Clone)] #[serde(tag = "type", rename_all = "snake_case")] pub enum AcmeStoreConfig { - Redis(RedisStoreConfig), + Redis(RedisStoreConfig), } #[derive(Debug, Deserialize, Clone)] #[serde(tag = "type", rename_all = "snake_case")] pub enum CacheStoreNotifier { - Redis(RedisCacheNotifierConfig), + Redis(RedisCacheNotifierConfig), } #[derive(Debug, Deserialize, Clone)] pub struct Settings { - pub data_store: Option, - pub cache_store: Option, - pub cache_store_notifier: Option, - pub fs_store: Option, - pub acme_store: Option, + pub data_store: Option, + pub cache_store: Option, + pub cache_store_notifier: Option, + pub fs_store: Option, + pub acme_store: Option, } impl Settings { - pub fn new() -> Result { - let mut s = Config::new(); + pub fn new() -> Result { + let mut s = Config::new(); - s.merge(File::with_name(".fly").required(false))?; - s.merge(Environment::with_prefix("FLY"))?; - s.try_into() - } + s.merge(File::with_name(".fly").required(false))?; + s.merge(Environment::with_prefix("FLY"))?; + s.try_into() + } } impl Default for Settings { - fn default() -> Self { - Settings { - data_store: None, - cache_store: None, - cache_store_notifier: None, - fs_store: None, - acme_store: None, + fn default() -> Self { + Settings { + data_store: None, + cache_store: None, + cache_store_notifier: None, + fs_store: None, + acme_store: None, + } } - } } diff --git a/src/sqlite_cache.rs b/src/sqlite_cache.rs index c282fc6..d45a9a4 100644 --- a/src/sqlite_cache.rs +++ b/src/sqlite_cache.rs @@ -15,24 +15,23 @@ use crate::cache_store::*; use crate::cache_store_notifier::{CacheOperation, CacheStoreNotifierError}; impl From for CacheError { - #[inline] - fn from(err: rusqlite::Error) -> CacheError { - CacheError::Failure(format!("{}", err)) - } + #[inline] + fn from(err: rusqlite::Error) -> CacheError { + CacheError::Failure(format!("{}", err)) + } } pub struct SqliteCacheStore { - pool: r2d2::Pool, + pool: r2d2::Pool, } impl SqliteCacheStore { - pub fn new(filename: String) -> Self { - let manager = SqliteConnectionManager::file(filename); - let pool = r2d2::Pool::new(manager).unwrap(); - let con = pool.get().unwrap(); // TODO: no unwrap - con - .execute( - "CREATE TABLE IF NOT EXISTS cache ( + pub fn new(filename: String) -> Self { + let manager = SqliteConnectionManager::file(filename); + let pool = r2d2::Pool::new(manager).unwrap(); + let con = pool.get().unwrap(); // TODO: no unwrap + con.execute( + "CREATE TABLE IF NOT EXISTS cache ( key TEXT PRIMARY KEY NOT NULL, value BLOB NOT NULL, meta TEXT, @@ -40,547 +39,548 @@ impl SqliteCacheStore { ); CREATE UNIQUE INDEX IF NOT EXISTS ON cache (key); CREATE INDEX IF NOT EXISTS ON cache (key, expires_at);", - NO_PARAMS, - ) - .unwrap(); + NO_PARAMS, + ) + .unwrap(); - SqliteCacheStore { pool } - } + SqliteCacheStore { pool } + } } impl CacheStore for SqliteCacheStore { - fn get(&self, key: String) -> Box, Error = CacheError> + Send> { - debug!("sqlite cache get with key: {}", key); - let pool = self.pool.clone(); - let conn = pool.get().unwrap(); // TODO: no unwrap + fn get( + &self, + key: String, + ) -> Box, Error = CacheError> + Send> { + debug!("sqlite cache get with key: {}", key); + let pool = self.pool.clone(); + let conn = pool.get().unwrap(); // TODO: no unwrap - Box::new(future::lazy(move || { - let size = 256 * 1024; + Box::new(future::lazy(move || { + let size = 256 * 1024; - let mut stmt = conn - .prepare( - "SELECT rowid,meta FROM cache + let mut stmt = conn + .prepare( + "SELECT rowid,meta FROM cache WHERE key = ? AND ( expires_at IS NULL OR expires_at >= datetime('now') ) LIMIT 1", - ) - .unwrap(); - - let mut rows = stmt.query(&[&key])?; - - let row_res = rows.next(); - - let rowid: i64 = match row_res { - Some(Ok(ref row)) => row.get(0), - Some(Err(e)) => return Err(CacheError::Failure(format!("{}", e))), - None => { - debug!("row not found"); - return Ok(None); - } - }; + ) + .unwrap(); + + let mut rows = stmt.query(&[&key])?; + + let row_res = rows.next(); + + let rowid: i64 = match row_res { + Some(Ok(ref row)) => row.get(0), + Some(Err(e)) => return Err(CacheError::Failure(format!("{}", e))), + None => { + debug!("row not found"); + return Ok(None); + } + }; + + let meta: Option = match row_res { + Some(Ok(ref row)) => row.get(1), + Some(Err(e)) => { + error!("error getting metadata from row: {}", e); + None + } + None => None, + }; + + Ok(Some(CacheEntry { + meta: meta, + stream: Box::new(stream::unfold(0, move |pos| { + debug!("sqlite cache get in stream future, pos: {}", pos); + + // End early given some rules! + // not a multiple of size, means we're done. + if pos > 0 && pos % size > 0 { + return None; + } + + let conn = pool.get().unwrap(); + + let mut blob = match conn.deref().blob_open( + rusqlite::DatabaseName::Main, + "cache", + "value", + rowid, + true, + ) { + Ok(b) => b, + Err(e) => return Some(future::err(e.into())), + }; + + if let Err(e) = blob.seek(SeekFrom::Start(pos)) { + return Some(future::err(e.into())); + } + let mut buf = [0u8; 256 * 1024]; + match blob.read(&mut buf[..]) { + Ok(bytes_read) => { + if bytes_read == 0 { + return None; + } + Some(future::ok::<(Vec, u64), _>(( + buf[..bytes_read].to_vec(), + pos + bytes_read as u64, + ))) + } + Err(e) => Some(future::err(e.into())), + } + })), + })) + })) + } - let meta: Option = match row_res { - Some(Ok(ref row)) => row.get(1), - Some(Err(e)) => { - error!("error getting metadata from row: {}", e); - None - } - None => None, - }; - - Ok(Some(CacheEntry { - meta: meta, - stream: Box::new(stream::unfold(0, move |pos| { - debug!("sqlite cache get in stream future, pos: {}", pos); - - // End early given some rules! - // not a multiple of size, means we're done. - if pos > 0 && pos % size > 0 { - return None; - } - - let conn = pool.get().unwrap(); - - let mut blob = match conn.deref().blob_open( - rusqlite::DatabaseName::Main, - "cache", - "value", - rowid, - true, - ) { - Ok(b) => b, - Err(e) => return Some(future::err(e.into())), - }; - - if let Err(e) = blob.seek(SeekFrom::Start(pos)) { - return Some(future::err(e.into())); - } - let mut buf = [0u8; 256 * 1024]; - match blob.read(&mut buf[..]) { - Ok(bytes_read) => { - if bytes_read == 0 { - return None; - } - Some(future::ok::<(Vec, u64), _>(( - buf[..bytes_read].to_vec(), - pos + bytes_read as u64, - ))) - } - Err(e) => Some(future::err(e.into())), - } - })), - })) - })) - } - - fn set( - &self, - key: String, - data_stream: Box, Error = ()> + Send>, - opts: CacheSetOptions, - ) -> EmptyCacheFuture { - debug!("sqlite cache set with key: {} and ttl: {:?}", key, opts.ttl); - - let pool = self.pool.clone(); - - Box::new( - data_stream - .concat2() - .map_err(|_e| { - error!("sqlite cache set error concatenating stream"); - CacheError::Unknown - }) - .and_then(move |b| { - let conn = pool.get().unwrap(); // TODO: no unwrap - - if let Some(ttl) = opts.ttl { - let mut stmt = conn - .prepare( - "INSERT INTO cache(key, value, meta, expires_at) + fn set( + &self, + key: String, + data_stream: Box, Error = ()> + Send>, + opts: CacheSetOptions, + ) -> EmptyCacheFuture { + debug!("sqlite cache set with key: {} and ttl: {:?}", key, opts.ttl); + + let pool = self.pool.clone(); + + Box::new( + data_stream + .concat2() + .map_err(|_e| { + error!("sqlite cache set error concatenating stream"); + CacheError::Unknown + }) + .and_then(move |b| { + let conn = pool.get().unwrap(); // TODO: no unwrap + + if let Some(ttl) = opts.ttl { + let mut stmt = conn + .prepare( + "INSERT INTO cache(key, value, meta, expires_at) VALUES (?, ?, ?, datetime('now', ?)) ON CONFLICT (key) DO UPDATE SET value=excluded.value,meta=excluded.meta,expires_at=excluded.expires_at ", - ) - .unwrap(); - - stmt - .insert(&[ - &key as &ToSql, - &b as &ToSql, - &opts.meta as &ToSql, - &format!("+{} seconds", ttl) as &ToSql, - ]) - .unwrap() - } else { - let mut stmt = conn - .prepare( - "INSERT INTO cache(key, value, meta, expires_at) + ) + .unwrap(); + + stmt.insert(&[ + &key as &ToSql, + &b as &ToSql, + &opts.meta as &ToSql, + &format!("+{} seconds", ttl) as &ToSql, + ]) + .unwrap() + } else { + let mut stmt = conn + .prepare( + "INSERT INTO cache(key, value, meta, expires_at) VALUES (?, ?, ?, NULL) ON CONFLICT (key) DO UPDATE SET value=excluded.value,meta=excluded.meta,expires_at=excluded.expires_at ", - ) - .unwrap(); - - stmt - .insert(&[&key as &ToSql, &b as &ToSql, &opts.meta as &ToSql]) - .unwrap() - }; - Ok(()) - }), - ) - } - - fn del(&self, key: String) -> EmptyCacheFuture { - debug!("sqlite cache del key: {}", key); - - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> Result<(), CacheError> { - let conn = pool.get().unwrap(); // TODO: no unwrap - - let mut stmt = match conn.prepare("DELETE FROM cache WHERE key = ?") { - Ok(s) => s, - Err(e) => return Err(e.into()), - }; - let ret = match stmt.execute(&[&key]) { - Ok(r) => r, - Err(e) => return Err(e.into()), - }; - debug!("sqlite cache del for key: {} returned: {}", key, ret); - Ok(()) - })) - } - - fn expire(&self, key: String, ttl: u32) -> EmptyCacheFuture { - debug!("sqlite cache expire key: {} w/ ttl: {}", key, ttl); - - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> CacheResult<()> { - let conn = pool.get().unwrap(); // TODO: no unwrap - - let mut stmt = match conn.prepare( - "UPDATE cache + ) + .unwrap(); + + stmt.insert(&[&key as &ToSql, &b as &ToSql, &opts.meta as &ToSql]) + .unwrap() + }; + Ok(()) + }), + ) + } + + fn del(&self, key: String) -> EmptyCacheFuture { + debug!("sqlite cache del key: {}", key); + + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> Result<(), CacheError> { + let conn = pool.get().unwrap(); // TODO: no unwrap + + let mut stmt = match conn.prepare("DELETE FROM cache WHERE key = ?") { + Ok(s) => s, + Err(e) => return Err(e.into()), + }; + let ret = match stmt.execute(&[&key]) { + Ok(r) => r, + Err(e) => return Err(e.into()), + }; + debug!("sqlite cache del for key: {} returned: {}", key, ret); + Ok(()) + })) + } + + fn expire(&self, key: String, ttl: u32) -> EmptyCacheFuture { + debug!("sqlite cache expire key: {} w/ ttl: {}", key, ttl); + + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> CacheResult<()> { + let conn = pool.get().unwrap(); // TODO: no unwrap + + let mut stmt = match conn.prepare( + "UPDATE cache SET expires_at = datetime('now', ?) WHERE key = ?", - ) { - Ok(s) => s, - Err(e) => return Err(e.into()), - }; - let ret = match stmt.execute(&[&format!("+{} seconds", ttl), &key]) { - Ok(r) => r, - Err(e) => return Err(e.into()), - }; - debug!("sqlite cache expire for key: {} returned: {}", key, ret); - Ok(()) - })) - } - - fn ttl(&self, _key: String) -> Box + Send> { - unimplemented!() - } - - fn purge_tag(&self, _tag: String) -> EmptyCacheFuture { - unimplemented!() - } - - fn set_tags(&self, _key: String, _tags: Vec) -> EmptyCacheFuture { - unimplemented!() - } - - fn notify( - &self, - _op: CacheOperation, - _value: String, - ) -> Box + Send> { - Box::new(future::err(CacheStoreNotifierError::Unavailable)) - } - - fn set_meta(&self, key: String, meta: String) -> EmptyCacheFuture { - debug!("sqlite cache set_meta key: {}", key); - - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> CacheResult<()> { - let conn = pool.get().unwrap(); // TODO: no unwrap - - let mut stmt = match conn.prepare( - "UPDATE cache - SET meta = ? - WHERE key = ?", - ) { - Ok(s) => s, - Err(e) => return Err(e.into()), - }; - let ret = match stmt.execute(&[&meta, &key]) { - Ok(r) => r, - Err(e) => return Err(e.into()), - }; - debug!("sqlite cache set_meta for key: {} returned: {}", key, ret); - Ok(()) - })) - } -} + ) { + Ok(s) => s, + Err(e) => return Err(e.into()), + }; + let ret = match stmt.execute(&[&format!("+{} seconds", ttl), &key]) { + Ok(r) => r, + Err(e) => return Err(e.into()), + }; + debug!("sqlite cache expire for key: {} returned: {}", key, ret); + Ok(()) + })) + } -#[cfg(test)] -mod tests { - use super::*; + fn ttl(&self, _key: String) -> Box + Send> { + unimplemented!() + } - extern crate chrono; - use self::chrono::{DateTime, Utc}; + fn purge_tag(&self, _tag: String) -> EmptyCacheFuture { + unimplemented!() + } - use std::thread::sleep; - use std::time::Duration; + fn set_tags(&self, _key: String, _tags: Vec) -> EmptyCacheFuture { + unimplemented!() + } - extern crate rand; - use self::rand::{thread_rng, RngCore}; + fn notify( + &self, + _op: CacheOperation, + _value: String, + ) -> Box + Send> { + Box::new(future::err(CacheStoreNotifierError::Unavailable)) + } - fn setup() -> SqliteCacheStore { - SqliteCacheStore::new("testcache.db".to_string()) - } + fn set_meta(&self, key: String, meta: String) -> EmptyCacheFuture { + debug!("sqlite cache set_meta key: {}", key); - fn set_value(store: &SqliteCacheStore, key: &str, value: &[u8], opts: CacheSetOptions) { - store - .set( - key.to_string(), - Box::new(stream::once::, ()>(Ok(value.to_vec()))), - opts, - ) - .wait() - .unwrap(); - } - - #[test] - fn test_sqlite_cache_set() { - let store = setup(); - let mut v = [0u8; 1000000]; - thread_rng().fill_bytes(&mut v); - let key = "test"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ); + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> CacheResult<()> { + let conn = pool.get().unwrap(); // TODO: no unwrap - let pool = &store.pool.clone(); - let conn = pool.get().unwrap(); // TODO: no unwrap + let mut stmt = match conn.prepare( + "UPDATE cache + SET meta = ? + WHERE key = ?", + ) { + Ok(s) => s, + Err(e) => return Err(e.into()), + }; + let ret = match stmt.execute(&[&meta, &key]) { + Ok(r) => r, + Err(e) => return Err(e.into()), + }; + debug!("sqlite cache set_meta for key: {} returned: {}", key, ret); + Ok(()) + })) + } +} - let mut stmt = conn - .prepare("SELECT key,value,expires_at FROM cache WHERE key = ? LIMIT 1;") - .unwrap(); +#[cfg(test)] +mod tests { + use super::*; - let mut rows = stmt.query(&[key]).unwrap(); - let row = rows.next().unwrap().unwrap(); - - let gotkey: String = row.get(0); - let gotv: Vec = row.get(1); - let gotex: rusqlite::types::Value = row.get(2); - - assert_eq!(gotkey, key); - assert_eq!(gotv, v.to_vec()); - assert_eq!(gotex, rusqlite::types::Value::Null); - } - - #[test] - fn test_sqlite_cache_set_ttl() { - let store = setup(); - let mut v = [0u8; 1000000]; - thread_rng().fill_bytes(&mut v); - let key = "test:ttl"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: Some(10), - meta: None, - tags: None, - }, - ); + extern crate chrono; + use self::chrono::{DateTime, Utc}; - let pool = &store.pool.clone(); - let conn = pool.get().unwrap(); // TODO: no unwrap + use std::thread::sleep; + use std::time::Duration; - let mut stmt = conn - .prepare("SELECT key,value,expires_at FROM cache WHERE key = ? AND expires_at > datetime('now') LIMIT 1;") - .unwrap(); + extern crate rand; + use self::rand::{thread_rng, RngCore}; - let mut rows = stmt.query(&[key]).unwrap(); - let row = rows.next().unwrap().unwrap(); - - let gotkey: String = row.get(0); - let gotv: Vec = row.get(1); - let gotex: DateTime = row.get(2); - - assert_eq!(gotkey, key); - assert_eq!(gotv, v.to_vec()); - assert!(gotex > Utc::now() && gotex < Utc::now() + chrono::FixedOffset::east(10)); - } - - #[test] - fn test_sqlite_cache_update_ttl() { - let store = setup(); - let mut v = [0u8; 1000000]; - thread_rng().fill_bytes(&mut v); - let key = "test:ttl"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ); - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: Some(10), - meta: None, - tags: None, - }, - ); + fn setup() -> SqliteCacheStore { + SqliteCacheStore::new("testcache.db".to_string()) + } - let pool = &store.pool.clone(); - let conn = pool.get().unwrap(); // TODO: no unwrap + fn set_value(store: &SqliteCacheStore, key: &str, value: &[u8], opts: CacheSetOptions) { + store + .set( + key.to_string(), + Box::new(stream::once::, ()>(Ok(value.to_vec()))), + opts, + ) + .wait() + .unwrap(); + } - let mut stmt = conn + #[test] + fn test_sqlite_cache_set() { + let store = setup(); + let mut v = [0u8; 1000000]; + thread_rng().fill_bytes(&mut v); + let key = "test"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ); + + let pool = &store.pool.clone(); + let conn = pool.get().unwrap(); // TODO: no unwrap + + let mut stmt = conn + .prepare("SELECT key,value,expires_at FROM cache WHERE key = ? LIMIT 1;") + .unwrap(); + + let mut rows = stmt.query(&[key]).unwrap(); + let row = rows.next().unwrap().unwrap(); + + let gotkey: String = row.get(0); + let gotv: Vec = row.get(1); + let gotex: rusqlite::types::Value = row.get(2); + + assert_eq!(gotkey, key); + assert_eq!(gotv, v.to_vec()); + assert_eq!(gotex, rusqlite::types::Value::Null); + } + + #[test] + fn test_sqlite_cache_set_ttl() { + let store = setup(); + let mut v = [0u8; 1000000]; + thread_rng().fill_bytes(&mut v); + let key = "test:ttl"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: Some(10), + meta: None, + tags: None, + }, + ); + + let pool = &store.pool.clone(); + let conn = pool.get().unwrap(); // TODO: no unwrap + + let mut stmt = conn .prepare("SELECT key,value,expires_at FROM cache WHERE key = ? AND expires_at > datetime('now') LIMIT 1;") .unwrap(); - let mut rows = stmt.query(&[key]).unwrap(); - let row = rows.next().unwrap().unwrap(); - - let gotkey: String = row.get(0); - let gotv: Vec = row.get(1); - let gotex: DateTime = row.get(2); - - assert_eq!(gotkey, key); - assert_eq!(gotv, v.to_vec()); - assert!(gotex > Utc::now() && gotex < Utc::now() + chrono::FixedOffset::east(10)); - } - - #[test] - fn test_sqlite_cache_get() { - let store = setup(); - let mut v = [0u8; 1000000]; - thread_rng().fill_bytes(&mut v); - let key = "test:get"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ); + let mut rows = stmt.query(&[key]).unwrap(); + let row = rows.next().unwrap().unwrap(); - let got = store - .get(key.to_string()) - .wait() - .unwrap() - .unwrap() - .stream - .concat2() - .wait() - .unwrap(); + let gotkey: String = row.get(0); + let gotv: Vec = row.get(1); + let gotex: DateTime = row.get(2); - assert_eq!(got, v.to_vec()); - } - - #[test] - fn test_sqlite_cache_get_ttl() { - let store = setup(); - let mut v = [0u8; 1000000]; - thread_rng().fill_bytes(&mut v); - let key = "test:get:ttl"; - - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: Some(10), - meta: None, - tags: None, - }, - ); + assert_eq!(gotkey, key); + assert_eq!(gotv, v.to_vec()); + assert!(gotex > Utc::now() && gotex < Utc::now() + chrono::FixedOffset::east(10)); + } - let got = store - .get(key.to_string()) - .wait() - .unwrap() - .unwrap() - .stream - .concat2() - .wait() + #[test] + fn test_sqlite_cache_update_ttl() { + let store = setup(); + let mut v = [0u8; 1000000]; + thread_rng().fill_bytes(&mut v); + let key = "test:ttl"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ); + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: Some(10), + meta: None, + tags: None, + }, + ); + + let pool = &store.pool.clone(); + let conn = pool.get().unwrap(); // TODO: no unwrap + + let mut stmt = conn + .prepare("SELECT key,value,expires_at FROM cache WHERE key = ? AND expires_at > datetime('now') LIMIT 1;") .unwrap(); - assert_eq!(got, v.to_vec()); - } - - #[test] - fn test_sqlite_cache_get_expired() { - let store = setup(); - let v = [0u8; 1]; - let key = "test:get:expired"; - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: Some(1), - meta: None, - tags: None, - }, - ); + let mut rows = stmt.query(&[key]).unwrap(); + let row = rows.next().unwrap().unwrap(); - sleep(Duration::from_secs(2)); // inefficient, but these are just tests + let gotkey: String = row.get(0); + let gotv: Vec = row.get(1); + let gotex: DateTime = row.get(2); - let entry = store.get(key.to_string()).wait().unwrap(); + assert_eq!(gotkey, key); + assert_eq!(gotv, v.to_vec()); + assert!(gotex > Utc::now() && gotex < Utc::now() + chrono::FixedOffset::east(10)); + } - assert!(entry.is_none()); - } + #[test] + fn test_sqlite_cache_get() { + let store = setup(); + let mut v = [0u8; 1000000]; + thread_rng().fill_bytes(&mut v); + let key = "test:get"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ); + + let got = store + .get(key.to_string()) + .wait() + .unwrap() + .unwrap() + .stream + .concat2() + .wait() + .unwrap(); + + assert_eq!(got, v.to_vec()); + } - #[test] - fn test_sqlite_cache_del() { - let store = setup(); - let v = [0u8; 1]; - let key = "test:del"; + #[test] + fn test_sqlite_cache_get_ttl() { + let store = setup(); + let mut v = [0u8; 1000000]; + thread_rng().fill_bytes(&mut v); + let key = "test:get:ttl"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: Some(10), + meta: None, + tags: None, + }, + ); + + let got = store + .get(key.to_string()) + .wait() + .unwrap() + .unwrap() + .stream + .concat2() + .wait() + .unwrap(); + + assert_eq!(got, v.to_vec()); + } - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ); + #[test] + fn test_sqlite_cache_get_expired() { + let store = setup(); + let v = [0u8; 1]; + let key = "test:get:expired"; + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: Some(1), + meta: None, + tags: None, + }, + ); + + sleep(Duration::from_secs(2)); // inefficient, but these are just tests + + let entry = store.get(key.to_string()).wait().unwrap(); + + assert!(entry.is_none()); + } - store.del(key.to_string()).wait().unwrap(); + #[test] + fn test_sqlite_cache_del() { + let store = setup(); + let v = [0u8; 1]; + let key = "test:del"; - let entry = store.get(key.to_string()).wait().unwrap(); + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ); - assert!(entry.is_none()); - } + store.del(key.to_string()).wait().unwrap(); - #[test] - fn test_sqlite_cache_expire() { - let store = setup(); - let v = [0u8; 1]; - let key = "test:expire"; + let entry = store.get(key.to_string()).wait().unwrap(); - set_value( - &store, - key, - &v, - CacheSetOptions { - ttl: None, - meta: None, - tags: None, - }, - ); + assert!(entry.is_none()); + } - let pool = &store.pool.clone(); - let conn = pool.get().unwrap(); // TODO: no unwrap + #[test] + fn test_sqlite_cache_expire() { + let store = setup(); + let v = [0u8; 1]; + let key = "test:expire"; + + set_value( + &store, + key, + &v, + CacheSetOptions { + ttl: None, + meta: None, + tags: None, + }, + ); + + let pool = &store.pool.clone(); + let conn = pool.get().unwrap(); // TODO: no unwrap + + let mut stmt = conn + .prepare("SELECT expires_at FROM cache WHERE key = ? LIMIT 1;") + .unwrap(); + + { + let mut rows = stmt.query(&[key]).unwrap(); + let row = rows.next().unwrap().unwrap(); + + let gotex: rusqlite::types::Value = row.get(0); + + assert_eq!(gotex, rusqlite::types::Value::Null); + } - let mut stmt = conn - .prepare("SELECT expires_at FROM cache WHERE key = ? LIMIT 1;") - .unwrap(); + store.expire(key.to_string(), 10).wait().unwrap(); - { - let mut rows = stmt.query(&[key]).unwrap(); - let row = rows.next().unwrap().unwrap(); + let mut rows = stmt.query(&[key]).unwrap(); + let row = rows.next().unwrap().unwrap(); - let gotex: rusqlite::types::Value = row.get(0); + let gotex: DateTime = row.get(0); - assert_eq!(gotex, rusqlite::types::Value::Null); + assert!(gotex > Utc::now() && gotex < Utc::now() + chrono::FixedOffset::east(10)); } - - store.expire(key.to_string(), 10).wait().unwrap(); - - let mut rows = stmt.query(&[key]).unwrap(); - let row = rows.next().unwrap().unwrap(); - - let gotex: DateTime = row.get(0); - - assert!(gotex > Utc::now() && gotex < Utc::now() + chrono::FixedOffset::east(10)); - } } diff --git a/src/sqlite_data.rs b/src/sqlite_data.rs index 6baae8c..29c957b 100644 --- a/src/sqlite_data.rs +++ b/src/sqlite_data.rs @@ -9,114 +9,114 @@ use self::rusqlite::NO_PARAMS; use futures::{future, Future}; pub struct SqliteDataStore { - pool: r2d2::Pool, + pool: r2d2::Pool, } impl SqliteDataStore { - pub fn new(filename: String) -> Self { - SqliteDataStore { - pool: r2d2::Pool::new(SqliteConnectionManager::file(filename)).unwrap(), + pub fn new(filename: String) -> Self { + SqliteDataStore { + pool: r2d2::Pool::new(SqliteConnectionManager::file(filename)).unwrap(), + } } - } } impl From for DataError { - #[inline] - fn from(err: rusqlite::Error) -> DataError { - DataError::Failure(format!("{}", err)) - } + #[inline] + fn from(err: rusqlite::Error) -> DataError { + DataError::Failure(format!("{}", err)) + } } impl DataStore for SqliteDataStore { - fn get( - &self, - coll: String, - key: String, - ) -> Box, Error = DataError> + Send> { - debug!("sqlite data store get coll: {}, key: {}", coll, key); - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> DataResult> { - let con = pool.get().unwrap(); // TODO: no unwrap - - ensure_coll(&*con, &coll).unwrap(); - - match con.query_row::( - format!("SELECT obj FROM {} WHERE key == ?", coll).as_str(), - &[&key], - |row| row.get(0), - ) { - Err(e) => { - if let rusqlite::Error::QueryReturnedNoRows = e { - Ok(None) - } else { - Err(e.into()) - } - } - Ok(s) => Ok(Some(s)), - } - })) - } + fn get( + &self, + coll: String, + key: String, + ) -> Box, Error = DataError> + Send> { + debug!("sqlite data store get coll: {}, key: {}", coll, key); + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> DataResult> { + let con = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*con, &coll).unwrap(); + + match con.query_row::( + format!("SELECT obj FROM {} WHERE key == ?", coll).as_str(), + &[&key], + |row| row.get(0), + ) { + Err(e) => { + if let rusqlite::Error::QueryReturnedNoRows = e { + Ok(None) + } else { + Err(e.into()) + } + } + Ok(s) => Ok(Some(s)), + } + })) + } - fn del(&self, coll: String, key: String) -> Box + Send> { - debug!("sqlite data store del coll: {}, key: {}", coll, key); - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> DataResult<()> { - let con = pool.get().unwrap(); // TODO: no unwrap + fn del(&self, coll: String, key: String) -> Box + Send> { + debug!("sqlite data store del coll: {}, key: {}", coll, key); + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> DataResult<()> { + let con = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*con, &coll).unwrap(); + + match con.execute( + format!("DELETE FROM {} WHERE key == ?", coll).as_str(), + &[&key], + ) { + Ok(_) => Ok(()), + Err(e) => Err(e.into()), + } + })) + } - ensure_coll(&*con, &coll).unwrap(); + fn put( + &self, + coll: String, + key: String, + data: String, + ) -> Box + Send> { + debug!("sqlite data store put coll: {}, key: {}", coll, key); + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> DataResult<()> { + let con = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*con, &coll).unwrap(); + match con.execute( + format!("INSERT OR REPLACE INTO {} VALUES (?, ?)", coll).as_str(), + &[&key, &data], + ) { + Ok(_) => Ok(()), + Err(e) => Err(e.into()), + } + })) + } - match con.execute( - format!("DELETE FROM {} WHERE key == ?", coll).as_str(), - &[&key], - ) { - Ok(_) => Ok(()), - Err(e) => Err(e.into()), - } - })) - } - - fn put( - &self, - coll: String, - key: String, - data: String, - ) -> Box + Send> { - debug!("sqlite data store put coll: {}, key: {}", coll, key); - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> DataResult<()> { - let con = pool.get().unwrap(); // TODO: no unwrap - - ensure_coll(&*con, &coll).unwrap(); - match con.execute( - format!("INSERT OR REPLACE INTO {} VALUES (?, ?)", coll).as_str(), - &[&key, &data], - ) { - Ok(_) => Ok(()), - Err(e) => Err(e.into()), - } - })) - } - - fn incr( - &self, - coll: String, - key: String, - field: String, - amount: i32, - ) -> Box + Send> { - debug!( - "sqlite data store incr coll: {}, key: {}, amount: {}", - coll, key, amount - ); - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> DataResult<()> { - let con = pool.get().unwrap(); // TODO: no unwrap - - ensure_coll(&*con, &coll).unwrap(); - - let selector = format!("$.{}", field); - - match con.execute( + fn incr( + &self, + coll: String, + key: String, + field: String, + amount: i32, + ) -> Box + Send> { + debug!( + "sqlite data store incr coll: {}, key: {}, amount: {}", + coll, key, amount + ); + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> DataResult<()> { + let con = pool.get().unwrap(); // TODO: no unwrap + + ensure_coll(&*con, &coll).unwrap(); + + let selector = format!("$.{}", field); + + match con.execute( format!( "UPDATE {} SET obj = json_set(obj, '{}', COALESCE(json_extract(obj, '{}'), '0') + ?) WHERE key == ?", coll, selector, selector @@ -127,123 +127,123 @@ impl DataStore for SqliteDataStore { Ok(_) => Ok(()), Err(e) => Err(e.into()), } - })) - } - - fn drop_coll(&self, coll: String) -> Box + Send> { - debug!("sqlite data store drop coll: {}", coll); - let pool = self.pool.clone(); - Box::new(future::lazy(move || -> DataResult<()> { - let con = pool.get().unwrap(); // TODO: no unwrap - match con.execute( - format!("DROP TABLE IF EXISTS {}", coll).as_str(), - rusqlite::NO_PARAMS, - ) { - Ok(_) => Ok(()), - Err(e) => Err(e.into()), - } - })) - } + })) + } + + fn drop_coll(&self, coll: String) -> Box + Send> { + debug!("sqlite data store drop coll: {}", coll); + let pool = self.pool.clone(); + Box::new(future::lazy(move || -> DataResult<()> { + let con = pool.get().unwrap(); // TODO: no unwrap + match con.execute( + format!("DROP TABLE IF EXISTS {}", coll).as_str(), + rusqlite::NO_PARAMS, + ) { + Ok(_) => Ok(()), + Err(e) => Err(e.into()), + } + })) + } } fn ensure_coll(conn: &rusqlite::Connection, name: &str) -> rusqlite::Result { - conn.execute( - format!( - "CREATE TABLE IF NOT EXISTS {} (key TEXT PRIMARY KEY NOT NULL, obj JSON NOT NULL)", - name + conn.execute( + format!( + "CREATE TABLE IF NOT EXISTS {} (key TEXT PRIMARY KEY NOT NULL, obj JSON NOT NULL)", + name + ) + .as_str(), + NO_PARAMS, ) - .as_str(), - NO_PARAMS, - ) } #[cfg(test)] mod tests { - use super::*; - - fn setup() -> SqliteDataStore { - SqliteDataStore::new("testdata.db".to_string()) - } - - fn set_value(store: &SqliteDataStore, coll: &str, key: &str, value: &str) { - store - .put(coll.to_string(), key.to_string(), value.to_string()) - .wait() - .unwrap(); - } - - #[test] - fn test_sqlite_data_put_get() { - let store = setup(); - let coll = "coll1"; - let key = "test:key"; - let value = r#"{"foo": "bar"}"#; - set_value(&store, coll, key, value); - - let got = store - .get(coll.to_string(), key.to_string()) - .wait() - .unwrap() - .unwrap(); - - assert_eq!(got, value.to_string()); - } - - #[test] - fn test_sqlite_data_incr() { - let store = setup(); - let coll = "collincr"; - let key = "test:key"; - let value = r#"{"counter": 0, "foo": "bar"}"#; - set_value(&store, coll, key, value); - - store - .incr(coll.to_string(), key.to_string(), "counter".to_string(), 1) - .wait() - .unwrap(); - let got = store - .get(coll.to_string(), key.to_string()) - .wait() - .unwrap() - .unwrap(); - - assert_eq!(got, r#"{"counter":1,"foo":"bar"}"#); - - store - .incr(coll.to_string(), key.to_string(), "counter".to_string(), 15) - .wait() - .unwrap(); - let got = store - .get(coll.to_string(), key.to_string()) - .wait() - .unwrap() - .unwrap(); - - assert_eq!(got, r#"{"counter":16,"foo":"bar"}"#); - } - - #[test] - fn test_sqlite_data_del() { - let store = setup(); - let mut el = tokio::runtime::Runtime::new().unwrap(); - let coll = "coll1"; - let key = "test:key"; - let value = "{}"; - set_value(&store, coll, key, value); - - let got_res = el - .block_on(store.get(coll.to_string(), key.to_string())) - .unwrap() - .unwrap(); - assert_eq!(got_res, value.to_string()); - - el.block_on(store.del(coll.to_string(), key.to_string())) - .unwrap(); - - let got = el - .block_on(store.get(coll.to_string(), key.to_string())) - .unwrap(); - - assert!(got.is_none()); - } + use super::*; + + fn setup() -> SqliteDataStore { + SqliteDataStore::new("testdata.db".to_string()) + } + + fn set_value(store: &SqliteDataStore, coll: &str, key: &str, value: &str) { + store + .put(coll.to_string(), key.to_string(), value.to_string()) + .wait() + .unwrap(); + } + + #[test] + fn test_sqlite_data_put_get() { + let store = setup(); + let coll = "coll1"; + let key = "test:key"; + let value = r#"{"foo": "bar"}"#; + set_value(&store, coll, key, value); + + let got = store + .get(coll.to_string(), key.to_string()) + .wait() + .unwrap() + .unwrap(); + + assert_eq!(got, value.to_string()); + } + + #[test] + fn test_sqlite_data_incr() { + let store = setup(); + let coll = "collincr"; + let key = "test:key"; + let value = r#"{"counter": 0, "foo": "bar"}"#; + set_value(&store, coll, key, value); + + store + .incr(coll.to_string(), key.to_string(), "counter".to_string(), 1) + .wait() + .unwrap(); + let got = store + .get(coll.to_string(), key.to_string()) + .wait() + .unwrap() + .unwrap(); + + assert_eq!(got, r#"{"counter":1,"foo":"bar"}"#); + + store + .incr(coll.to_string(), key.to_string(), "counter".to_string(), 15) + .wait() + .unwrap(); + let got = store + .get(coll.to_string(), key.to_string()) + .wait() + .unwrap() + .unwrap(); + + assert_eq!(got, r#"{"counter":16,"foo":"bar"}"#); + } + + #[test] + fn test_sqlite_data_del() { + let store = setup(); + let mut el = tokio::runtime::Runtime::new().unwrap(); + let coll = "coll1"; + let key = "test:key"; + let value = "{}"; + set_value(&store, coll, key, value); + + let got_res = el + .block_on(store.get(coll.to_string(), key.to_string())) + .unwrap() + .unwrap(); + assert_eq!(got_res, value.to_string()); + + el.block_on(store.del(coll.to_string(), key.to_string())) + .unwrap(); + + let got = el + .block_on(store.get(coll.to_string(), key.to_string())) + .unwrap(); + + assert!(got.is_none()); + } } diff --git a/src/utils.rs b/src/utils.rs index 9444c6b..7b508f5 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -4,9 +4,9 @@ use crate::msg; use crate::runtime::{JsRuntime, Runtime}; use flatbuffers::FlatBufferBuilder; use futures::{ - future, - sync::{mpsc, oneshot}, - Future, Stream, + future, + sync::{mpsc, oneshot}, + Future, Stream, }; use libfly::*; use std::ptr; @@ -24,208 +24,208 @@ pub type Op = Future + Send; pub type Handler = fn(&mut Runtime, &msg::Base, fly_buf) -> Box; pub fn take_last_n(str: &str, n: usize) -> Option<&str> { - if str.len() >= n { - Some(&str[str.len() - n..]) - } else { - None - } + if str.len() >= n { + Some(&str[str.len() - n..]) + } else { + None + } } pub fn serialize_response( - cmd_id: u32, - builder: &mut FlatBufferBuilder, - mut args: msg::BaseArgs, + cmd_id: u32, + builder: &mut FlatBufferBuilder, + mut args: msg::BaseArgs, ) -> Buf { - args.cmd_id = cmd_id; - let base = msg::Base::create(builder, &args); - msg::finish_base_buffer(builder, base); - let data = builder.finished_data(); - let vec = data.to_vec(); - Some(vec.into_boxed_slice()) + args.cmd_id = cmd_id; + let base = msg::Base::create(builder, &args); + msg::finish_base_buffer(builder, base); + let data = builder.finished_data(); + let vec = data.to_vec(); + Some(vec.into_boxed_slice()) } pub fn build_error(cmd_id: u32, err: FlyError) -> Buf { - let builder = &mut FlatBufferBuilder::new(); - let errmsg_offset = builder.create_string(&format!("{}", err)); - serialize_response( - cmd_id, - builder, - msg::BaseArgs { - error: Some(errmsg_offset), - error_kind: err.kind(), - ..Default::default() - }, - ) + let builder = &mut FlatBufferBuilder::new(); + let errmsg_offset = builder.create_string(&format!("{}", err)); + serialize_response( + cmd_id, + builder, + msg::BaseArgs { + error: Some(errmsg_offset), + error_kind: err.kind(), + ..Default::default() + }, + ) } pub fn null_buf() -> fly_buf { - fly_buf { - alloc_ptr: 0 as *mut u8, - alloc_len: 0, - data_ptr: 0 as *mut u8, - data_len: 0, - } + fly_buf { + alloc_ptr: 0 as *mut u8, + alloc_len: 0, + data_ptr: 0 as *mut u8, + data_len: 0, + } } pub fn ok_future(buf: Buf) -> Box { - Box::new(future::ok(buf)) + Box::new(future::ok(buf)) } pub fn odd_future(err: FlyError) -> Box { - Box::new(future::err(err)) + Box::new(future::err(err)) } pub fn fly_buf_from(x: Box<[u8]>) -> fly_buf { - let len = x.len(); - let ptr = Box::into_raw(x); - fly_buf { - alloc_ptr: 0 as *mut u8, - alloc_len: 0, - data_ptr: ptr as *mut u8, - data_len: len, - } + let len = x.len(); + let ptr = Box::into_raw(x); + fly_buf { + alloc_ptr: 0 as *mut u8, + alloc_len: 0, + data_ptr: ptr as *mut u8, + data_len: len, + } } pub fn send_body_stream(ptr: JsRuntime, req_id: u32, stream: JsBody) { - let rt = ptr.to_runtime(); - - match stream { - JsBody::BoxedStream(s) => rt.spawn( - s.map_err(|e| error!("error sending boxed stream: {}", e)) - .for_each(move |v| { - send_stream_chunk(ptr, req_id, v.as_ptr() as *mut u8, v.len(), false); - Ok(()) - }) - .and_then(move |_| { - send_done_stream(ptr, req_id); - Ok(()) - }), - ), - JsBody::Static(v) => { - rt.spawn(future::lazy(move || { - send_stream_chunk(ptr, req_id, v.as_ptr() as *mut u8, v.len(), true); - Ok(()) - })); - } - JsBody::Stream(rx) => { - rt.spawn( - rx.map_err(move |e| error!("error reading from stream channel: {:?}", e)) - .for_each(move |v| { - send_stream_chunk(ptr, req_id, v.as_ptr() as *mut u8, v.len(), false); - Ok(()) - }) - .and_then(move |_| { - send_done_stream(ptr, req_id); - Ok(()) - }), - ); - } - }; + let rt = ptr.to_runtime(); + + match stream { + JsBody::BoxedStream(s) => rt.spawn( + s.map_err(|e| error!("error sending boxed stream: {}", e)) + .for_each(move |v| { + send_stream_chunk(ptr, req_id, v.as_ptr() as *mut u8, v.len(), false); + Ok(()) + }) + .and_then(move |_| { + send_done_stream(ptr, req_id); + Ok(()) + }), + ), + JsBody::Static(v) => { + rt.spawn(future::lazy(move || { + send_stream_chunk(ptr, req_id, v.as_ptr() as *mut u8, v.len(), true); + Ok(()) + })); + } + JsBody::Stream(rx) => { + rt.spawn( + rx.map_err(move |e| error!("error reading from stream channel: {:?}", e)) + .for_each(move |v| { + send_stream_chunk(ptr, req_id, v.as_ptr() as *mut u8, v.len(), false); + Ok(()) + }) + .and_then(move |_| { + send_done_stream(ptr, req_id); + Ok(()) + }), + ); + } + }; } pub fn send_stream_chunk(ptr: JsRuntime, req_id: u32, chunk: *mut u8, len: usize, done: bool) { - let builder = &mut FlatBufferBuilder::new(); - let chunk_msg = msg::StreamChunk::create( - builder, - &msg::StreamChunkArgs { - id: req_id, - done: done, - }, - ); - ptr.send( - fly_buf_from( - serialize_response( - 0, + let builder = &mut FlatBufferBuilder::new(); + let chunk_msg = msg::StreamChunk::create( builder, - msg::BaseArgs { - msg: Some(chunk_msg.as_union_value()), - msg_type: msg::Any::StreamChunk, - ..Default::default() + &msg::StreamChunkArgs { + id: req_id, + done: done, }, - ) - .unwrap(), - ), - Some(fly_buf { - alloc_ptr: ptr::null_mut() as *mut u8, - alloc_len: 0, - data_ptr: chunk, - data_len: len, - }), - ); + ); + ptr.send( + fly_buf_from( + serialize_response( + 0, + builder, + msg::BaseArgs { + msg: Some(chunk_msg.as_union_value()), + msg_type: msg::Any::StreamChunk, + ..Default::default() + }, + ) + .unwrap(), + ), + Some(fly_buf { + alloc_ptr: ptr::null_mut() as *mut u8, + alloc_len: 0, + data_ptr: chunk, + data_len: len, + }), + ); } pub fn send_done_stream(ptr: JsRuntime, req_id: u32) { - let builder = &mut FlatBufferBuilder::new(); - let chunk_msg = msg::StreamChunk::create( - builder, - &msg::StreamChunkArgs { - id: req_id, - done: true, - }, - ); - ptr.send( - fly_buf_from( - serialize_response( - 0, + let builder = &mut FlatBufferBuilder::new(); + let chunk_msg = msg::StreamChunk::create( builder, - msg::BaseArgs { - msg: Some(chunk_msg.as_union_value()), - msg_type: msg::Any::StreamChunk, - ..Default::default() + &msg::StreamChunkArgs { + id: req_id, + done: true, }, - ) - .unwrap(), - ), - None, - ); + ); + ptr.send( + fly_buf_from( + serialize_response( + 0, + builder, + msg::BaseArgs { + msg: Some(chunk_msg.as_union_value()), + msg_type: msg::Any::StreamChunk, + ..Default::default() + }, + ) + .unwrap(), + ), + None, + ); } pub enum EventResponseChannel { - Http(oneshot::Receiver), - Dns(oneshot::Receiver), + Http(oneshot::Receiver), + Dns(oneshot::Receiver), } #[derive(Debug)] pub enum EventDispatchError { - PoisonedLock, - Http(mpsc::SendError), - Dns(mpsc::SendError), + PoisonedLock, + Http(mpsc::SendError), + Dns(mpsc::SendError), } pub fn signal_monitor() -> ( - impl Future + Send + 'static, - oneshot::Receiver<()>, + impl Future + Send + 'static, + oneshot::Receiver<()>, ) { - let (sigtx, sigrx) = oneshot::channel(); - ( - Signal::new(SIGTERM) - .join(Signal::new(SIGINT)) - .map_err(|error| { - error!("Failed to set up process signal monitoring: {:?}", error); - }) - .and_then(|(sigterms, sigints)| { - // Stream of all signals we care about - let signals = sigterms.select(sigints); - // Take only the first signal in the stream and log that it was triggered - signals - .take(1) - .map_err(|error| { - error!("Error while listening on process signals: {:?}", error); - }) - .for_each(|signal| { - let signal_name = match signal { - SIGTERM => "SIGTERM", - SIGINT => "SIGINT", - _ => unreachable!(), - }; - info!("Received {}, gracefully shutting down", signal_name); - Ok(()) - }) - }) - .and_then(move |_| { - sigtx.send(()).ok(); // don't care. - Ok(()) - }), - sigrx, - ) + let (sigtx, sigrx) = oneshot::channel(); + ( + Signal::new(SIGTERM) + .join(Signal::new(SIGINT)) + .map_err(|error| { + error!("Failed to set up process signal monitoring: {:?}", error); + }) + .and_then(|(sigterms, sigints)| { + // Stream of all signals we care about + let signals = sigterms.select(sigints); + // Take only the first signal in the stream and log that it was triggered + signals + .take(1) + .map_err(|error| { + error!("Error while listening on process signals: {:?}", error); + }) + .for_each(|signal| { + let signal_name = match signal { + SIGTERM => "SIGTERM", + SIGINT => "SIGINT", + _ => unreachable!(), + }; + info!("Received {}, gracefully shutting down", signal_name); + Ok(()) + }) + }) + .and_then(move |_| { + sigtx.send(()).ok(); // don't care. + Ok(()) + }), + sigrx, + ) } diff --git a/src/v8env.rs b/src/v8env.rs index 0e9c61c..3d6c376 100644 --- a/src/v8env.rs +++ b/src/v8env.rs @@ -1,36 +1,36 @@ +use libc::c_char; use libfly::*; use std::ffi::CString; use std::fs::File; use std::io::Read; use std::slice; -use libc::c_char; #[cfg(not(debug_assertions))] const V8ENV_SNAPSHOT: &'static [u8] = include_bytes!("../v8env.bin"); #[cfg(debug_assertions)] lazy_static! { - static ref V8ENV_SNAPSHOT: Box<[u8]> = { - let filename = "v8env/dist/v8env.js"; - let mut file = File::open(filename).unwrap(); - let mut contents = String::new(); - file.read_to_string(&mut contents).unwrap(); - let snap = unsafe { - let cfilename = CString::new(filename).unwrap(); - let ccontents = CString::new(contents).unwrap(); - js_create_snapshot(cfilename.as_ptr(), ccontents.as_ptr()) + static ref V8ENV_SNAPSHOT: Box<[u8]> = { + let filename = "v8env/dist/v8env.js"; + let mut file = File::open(filename).unwrap(); + let mut contents = String::new(); + file.read_to_string(&mut contents).unwrap(); + let snap = unsafe { + let cfilename = CString::new(filename).unwrap(); + let ccontents = CString::new(contents).unwrap(); + js_create_snapshot(cfilename.as_ptr(), ccontents.as_ptr()) + }; + let bytes: Vec = + unsafe { slice::from_raw_parts(snap.ptr as *const u8, snap.len as usize) }.to_vec(); + bytes.into_boxed_slice() }; - let bytes: Vec = - unsafe { slice::from_raw_parts(snap.ptr as *const u8, snap.len as usize) }.to_vec(); - bytes.into_boxed_slice() - }; } lazy_static! { - pub static ref FLY_SNAPSHOT: fly_simple_buf = fly_simple_buf { - ptr: V8ENV_SNAPSHOT.as_ptr() as *const c_char, - len: V8ENV_SNAPSHOT.len() as i32 - }; + pub static ref FLY_SNAPSHOT: fly_simple_buf = fly_simple_buf { + ptr: V8ENV_SNAPSHOT.as_ptr() as *const c_char, + len: V8ENV_SNAPSHOT.len() as i32 + }; } lazy_static_include_bytes!(pub V8ENV_SOURCEMAP, "v8env/dist/v8env.js.map");