Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 153 insertions, 0 deletions

diff --git a/third_party/rust/rkv/src/bin/dump.rs b/third_party/rust/rkv/src/bin/dump.rs
new file mode 100644
index 0000000000..c0e12b986f
--- /dev/null
+++ b/third_party/rust/rkv/src/bin/dump.rs
@@ -0,0 +1,47 @@
+// Copyright 2018-2019 Mozilla
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+use std::{env::args, io, path::Path};
+
+use rkv::migrator::{LmdbArchMigrateError, LmdbArchMigrator};
+
+fn main() -> Result<(), LmdbArchMigrateError> {
+    let mut cli_args = args();
+    let mut db_name = None;
+    let mut env_path = None;
+
+    // The first arg is the name of the program, which we can ignore.
+    cli_args.next();
+
+    while let Some(arg) = cli_args.next() {
+        if &arg[0..1] == "-" {
+            match &arg[1..] {
+                "s" => {
+                    db_name = match cli_args.next() {
+                        None => return Err("-s must be followed by database name".into()),
+                        Some(str) => Some(str),
+                    };
+                }
+                str => return Err(format!("arg -{str} not recognized").into()),
+            }
+        } else {
+            if env_path.is_some() {
+                return Err("must provide only one path to the LMDB environment".into());
+            }
+            env_path = Some(arg);
+        }
+    }
+
+    let env_path = env_path.ok_or("must provide a path to the LMDB environment")?;
+    let mut migrator = LmdbArchMigrator::new(Path::new(&env_path))?;
+    migrator.dump(db_name.as_deref(), io::stdout()).unwrap();
+
+    Ok(())
+}
diff --git a/third_party/rust/rkv/src/bin/rand.rs b/third_party/rust/rkv/src/bin/rand.rs
new file mode 100644
index 0000000000..56d578c22e
--- /dev/null
+++ b/third_party/rust/rkv/src/bin/rand.rs
@@ -0,0 +1,106 @@
+// Copyright 2018-2019 Mozilla
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+// this file except in compliance with the License. You may obtain a copy of the
+// License at http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software distributed
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations under the License.
+
+//! A command-line utility to create an LMDB environment containing random data.
+//! It requires one flag, `-s path/to/environment`, which specifies the location
+//! where the tool should create the environment.  Optionally, you may specify
+//! the number of key/value pairs to create via the `-n <number>` flag
+//! (for which the default value is 50).
+
+use std::{env::args, fs, fs::File, io::Read, path::Path};
+
+use rkv::{
+    backend::{BackendEnvironmentBuilder, Lmdb},
+    Rkv, StoreOptions, Value,
+};
+
+fn main() {
+    let mut args = args();
+    let mut database = None;
+    let mut path = None;
+    let mut num_pairs = 50;
+
+    // The first arg is the name of the program, which we can ignore.
+    args.next();
+
+    while let Some(arg) = args.next() {
+        if &arg[0..1] == "-" {
+            match &arg[1..] {
+                "s" => {
+                    database = match args.next() {
+                        None => panic!("-s must be followed by database arg"),
+                        Some(str) => Some(str),
+                    };
+                }
+                "n" => {
+                    num_pairs = match args.next() {
+                        None => panic!("-s must be followed by number of pairs"),
+                        Some(str) => str.parse().expect("number"),
+                    };
+                }
+                str => panic!("arg -{} not recognized", str),
+            }
+        } else {
+            if path.is_some() {
+                panic!("must provide only one path to the LMDB environment");
+            }
+            path = Some(arg);
+        }
+    }
+
+    if path.is_none() {
+        panic!("must provide a path to the LMDB environment");
+    }
+
+    let path = path.unwrap();
+    fs::create_dir_all(&path).expect("dir created");
+
+    let mut builder = Rkv::environment_builder::<Lmdb>();
+    builder.set_max_dbs(2);
+    // Allocate enough map to accommodate the largest random collection.
+    // We currently do this by allocating twice the maximum possible size
+    // of the pairs (assuming maximum key and value sizes).
+    builder.set_map_size((511 + 65535) * num_pairs * 2);
+    let rkv = Rkv::from_builder(Path::new(&path), builder).expect("Rkv");
+    let store = rkv
+        .open_single(database.as_deref(), StoreOptions::create())
+        .expect("opened");
+    let mut writer = rkv.write().expect("writer");
+
+    // Generate random values for the number of keys and key/value lengths.
+    // On Linux, "Just use /dev/urandom!" <https://www.2uo.de/myths-about-urandom/>.
+    // On macOS it doesn't matter (/dev/random and /dev/urandom are identical).
+    let mut random = File::open("/dev/urandom").unwrap();
+    let mut nums = [0u8; 4];
+    random.read_exact(&mut nums).unwrap();
+
+    // Generate 0–255 pairs.
+    for _ in 0..num_pairs {
+        // Generate key and value lengths.  The key must be 1–511 bytes long.
+        // The value length can be 0 and is essentially unbounded; we generate
+        // value lengths of 0–0xffff (65535).
+        // NB: the modulus method for generating a random number within a range
+        // introduces distribution skew, but we don't need it to be perfect.
+        let key_len = ((u16::from(nums[0]) + (u16::from(nums[1]) << 8)) % 511 + 1) as usize;
+        let value_len = (u16::from(nums[2]) + (u16::from(nums[3]) << 8)) as usize;
+
+        let mut key: Vec<u8> = vec![0; key_len];
+        random.read_exact(&mut key[0..key_len]).unwrap();
+
+        let mut value: Vec<u8> = vec![0; value_len];
+        random.read_exact(&mut value[0..value_len]).unwrap();
+
+        store
+            .put(&mut writer, key, &Value::Blob(&value))
+            .expect("wrote");
+    }
+
+    writer.commit().expect("committed");
+}