Skip to content

R
rust-rocksdb
Commit f340e74c authored by Tyler Neely's avatar Tyler Neely
Browse files
Options

add cargo build for rocksdb 3.8.1, no more LD_PRELOAD

parent d2d4a551
Hide whitespace changes
Inline Side-by-side
Showing with 152 additions and 53 deletions
Cargo.toml
View file @ f340e74c
......@@ -3,3 +3,7 @@
name = "rocksdb"
version = "0.0.1"
authors = ["Tyler Neely <t@jujit.su>"]
[dependencies.rocksdb-sys]
path = "rocksdb-sys"
version = "*"
rocksdb-sys/Cargo.toml 0 → 100644
View file @ f340e74c
[package]
name = "rocksdb-sys"
version = "0.0.1"
authors = []
links = "rocksdb"
build = "build.rs"
[build-dependencies.pkg-config]
git = "https://github.com/alexcrichton/pkg-config-rs"
[lib]
name = "rocksdb-sys"
path = "lib.rs"
rocksdb-sys/build.rs 0 → 100644
View file @ f340e74c
extern crate "pkg-config" as pkg_config;
use std::os;
use std::io::{mod, fs, Command};
use std::io::process::InheritFd;
//TODO windows + osx support
fn main() {
// Next, fall back and try to use pkg-config if its available.
match pkg_config::find_library("librocksdb") {
Ok(()) => return,
Err(..) => {}
}
let src = os::getcwd().unwrap();
let dst = Path::new(os::getenv("OUT_DIR").unwrap());
let _ = fs::mkdir(&dst.join("build"), io::USER_DIR);
let mut config_opts = Vec::new();
config_opts.push("--enable-static=yes".to_string());
config_opts.push(format!("--prefix={}", dst.display()));
config_opts.push("--disable-manual".to_string());
println!("cwd: {}", src.as_str());
run(Command::new(make())
.arg("shared_lib")
.arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap()))
.cwd(&src.join("rocksdb")));
// Don't run `make install` because apparently it's a little buggy on mingw
// for windows.
fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap();
fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap();
println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display());
println!("cargo:root={}", dst.display());
println!("cargo:include={}/include", src.join("rocksdb").display());
}
fn run(cmd: &mut Command) {
println!("running: {}", cmd);
assert!(cmd.stdout(InheritFd(1))
.stderr(InheritFd(2))
.status()
.unwrap()
.success());
}
fn make() -> &'static str {
if cfg!(target_os = "freebsd") {"gmake"} else {"make"}
}
src/ffi.rs → rocksdb-sys/lib.rs
View file @ f340e74c
extern crate libc;
use self::libc::{c_int, c_void, size_t};
use std::io::{IoResult, IoError};
use std::c_vec::CVec;
use std::c_str::CString;
#[repr(C)]
pub struct RocksdbOptions(pub *const c_void);
......@@ -19,9 +16,8 @@ pub struct RocksdbMergeOperator(pub *const c_void);
#[repr(C)]
pub struct RocksdbFilterPolicy(pub *const c_void);
#[allow(dead_code)]
#[repr(C)]
enum RocksdbCompressionType {
pub enum RocksdbCompressionType {
RocksdbNoCompression = 0,
RocksdbSnappyCompression = 1,
RocksdbZlibCompression = 2,
......@@ -30,22 +26,19 @@ enum RocksdbCompressionType {
RocksdbLz4hcCompression = 5
}
#[allow(dead_code)]
#[repr(C)]
enum RocksdbCompactionStyle {
pub enum RocksdbCompactionStyle {
RocksdbLevelCompaction = 0,
RocksdbUniversalCompaction = 1,
RocksdbFifoCompaction = 2
}
#[allow(dead_code)]
#[repr(C)]
enum RocksdbUniversalCompactionStyle {
pub enum RocksdbUniversalCompactionStyle {
rocksdb_similar_size_compaction_stop_style = 0,
rocksdb_total_size_compaction_stop_style = 1
}
#[allow(dead_code)]
#[link(name = "rocksdb")]
extern {
pub fn rocksdb_options_create() -> RocksdbOptions;
......@@ -114,8 +107,15 @@ extern {
k: *const u8, kLen: size_t,
valLen: *const size_t, err: *mut i8) -> *mut u8;
pub fn rocksdb_close(db: RocksdbInstance);
pub fn rocksdb_destroy_db(
options: RocksdbOptions, path: *const i8, err: *mut i8);
pub fn rocksdb_repair_db(
options: RocksdbOptions, path: *const i8, err: *mut i8);
}
#[allow(dead_code)]
#[test]
fn internal() {
unsafe {
......@@ -127,11 +127,10 @@ fn internal() {
rocksdb_options_optimize_level_style_compaction(opts, 0);
rocksdb_options_set_create_if_missing(opts, 1);
let rustpath = "datadir";
let rustpath = "internaltest";
let cpath = rustpath.to_c_str();
let cpath_ptr = cpath.as_ptr();
//TODO this will SIGSEGV
let err = 0 as *mut i8;
let db = rocksdb_open(opts, cpath_ptr, err);
assert!(err.is_null());
......@@ -153,7 +152,7 @@ fn internal() {
assert!(read_opts_ptr.is_not_null());
libc::free(err as *mut c_void);
let mut val_len: size_t = 0;
let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t;
rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err);
assert!(err.is_null());
......
src/lib.rs
View file @ f340e74c
#![crate_id = "rocksdb"]
#![crate_type = "lib"]
#![feature(globs)]
#![allow(dead_code)]
extern crate "rocksdb-sys" as rocksdb_ffi;
pub use rocksdb::{
open,
......@@ -8,4 +10,3 @@ pub use rocksdb::{
RocksdbResult,
};
pub mod rocksdb;
mod ffi;
src/main.rs
View file @ f340e74c
......@@ -3,13 +3,15 @@ extern crate test;
use rocksdb::open;
use test::Bencher;
#[allow(dead_code)]
fn main() {
let db = open("testdb".to_string(), true).unwrap();
db.put(b"hey", b"v1111");
db.get(b"hey").map(|v| { println!("value: {}", v.as_slice()); });
assert!(db.put(b"hey", b"v1111").is_ok());
db.get(b"hey").map(|raw| { std::str::from_utf8(raw.as_slice()).map(|v| {println!("value: {}", v); })});
db.close();
}
#[allow(dead_code)]
#[bench]
fn writes(b: &mut Bencher) {
let db = open("testdb".to_string(), true).unwrap();
......@@ -21,7 +23,8 @@ fn writes(b: &mut Bencher) {
db.close();
}
#[bbench]
#[allow(dead_code)]
#[bench]
fn reads(b: &mut Bencher) {
let db = open("testdb".to_string(), true).unwrap();
let mut i = 0 as u64;
......
src/rocksdb.rs
View file @ f340e74c
extern crate libc;
use self::libc::{c_int, c_void, size_t};
use std::io::{IoResult, IoError};
use self::libc::{c_void, size_t};
use std::io::{IoError};
use std::c_vec::CVec;
use std::c_str::CString;
use ffi;
use rocksdb_ffi;
// TODO learn more about lifetimes and determine if it's appropriate to keep
// inner on the stack, instead.
......@@ -15,12 +15,13 @@ pub struct RocksdbVector {
impl RocksdbVector {
pub fn from_c(val: *mut u8, val_len: size_t) -> RocksdbVector {
unsafe {
RocksdbVector{
RocksdbVector {
inner:
box CVec::new_with_dtor(val, val_len as uint,
proc(){
libc::free(val as *mut c_void);
})}
})
}
}
}
......@@ -29,7 +30,8 @@ impl RocksdbVector {
}
}
// RocksdbResult exists because of the inherent difference between
// an operational failure and the absence of a possible result.
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
pub enum RocksdbResult<T, E> {
Some(T),
......@@ -37,6 +39,27 @@ pub enum RocksdbResult<T, E> {
Error(E),
}
/*
impl <E> RocksdbResult<Box<CVec<u8>>, E> {
pub fn from_c(val: *mut u8, val_len: size_t) -> RocksdbResult<Box<CVec<u8>>, E> {
unsafe {
RocksdbResult::Some(
box CVec::new_with_dtor(val, val_len as uint,
proc(){
libc::free(val as *mut c_void);
}))
}
}
pub fn as_slice<'a>(self) -> Option<&'a [u8]> {
match self {
RocksdbResult::Some(x) => Some(x.as_slice()),
RocksdbResult::None => None,
RocksdbResult::Error(e) => None,
}
}
}
*/
impl <T,E> RocksdbResult<T,E> {
#[unstable = "waiting for unboxed closures"]
pub fn map<U>(self, f: |T| -> U) -> RocksdbResult<U,E> {
......@@ -70,38 +93,37 @@ impl <T,E> RocksdbResult<T,E> {
pub fn is_some(self) -> bool {
match self {
RocksdbResult::Some(T) => true,
RocksdbResult::Some(_) => true,
RocksdbResult::None => false,
RocksdbResult::Error(E) => false,
RocksdbResult::Error(_) => false,
}
}
pub fn is_none(self) -> bool {
match self {
RocksdbResult::Some(T) => false,
RocksdbResult::Some(_) => false,
RocksdbResult::None => true,
RocksdbResult::Error(E) => false,
RocksdbResult::Error(_) => false,
}
}
pub fn is_error(self) -> bool {
match self {
RocksdbResult::Some(T) => false,
RocksdbResult::Some(_) => false,
RocksdbResult::None => false,
RocksdbResult::Error(E) => true,
RocksdbResult::Error(_) => true,
}
}
}
pub struct Rocksdb {
inner: ffi::RocksdbInstance,
path: String,
inner: rocksdb_ffi::RocksdbInstance,
}
impl Rocksdb {
pub fn put(&self, key: &[u8], value: &[u8]) -> Result<bool, String> {
unsafe {
let writeopts = ffi::rocksdb_writeoptions_create();
unsafe {
let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
let err = 0 as *mut i8;
ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
key.len() as size_t, value.as_ptr(),
value.len() as size_t, err);
if err.is_not_null() {
......@@ -112,7 +134,7 @@ impl Rocksdb {
None => {
let ie = IoError::last_error();
return Err(format!(
"ERROR: desc:{}, details:{}",
"ERROR: desc:{}, details:{}",
ie.desc,
ie.detail.unwrap_or_else(
|| {"none provided by OS".to_string()})))
......@@ -125,8 +147,8 @@ impl Rocksdb {
pub fn get(&self, key: &[u8]) -> RocksdbResult<RocksdbVector, String> {
unsafe {
let readopts = ffi::rocksdb_readoptions_create();
let ffi::RocksdbReadOptions(read_opts_ptr) = readopts;
let readopts = rocksdb_ffi::rocksdb_readoptions_create();
let rocksdb_ffi::RocksdbReadOptions(read_opts_ptr) = readopts;
if read_opts_ptr.is_null() {
return RocksdbResult::Error("Unable to create rocksdb read \
options. This is a fairly trivial call, and its failure \
......@@ -137,7 +159,7 @@ impl Rocksdb {
let val_len: size_t = 0;
let val_len_ptr = &val_len as *const size_t;
let err = 0 as *mut i8;
let val = ffi::rocksdb_get(self.inner, readopts, key.as_ptr(),
let val = rocksdb_ffi::rocksdb_get(self.inner, readopts, key.as_ptr(),
key.len() as size_t, val_len_ptr, err);
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
......@@ -160,33 +182,33 @@ impl Rocksdb {
}
pub fn close(&self) {
unsafe { ffi::rocksdb_close(self.inner); }
unsafe { rocksdb_ffi::rocksdb_close(self.inner); }
}
}
pub fn open(path: String, create_if_missing: bool) -> Result<Rocksdb, String> {
unsafe {
let opts = ffi::rocksdb_options_create();
let ffi::RocksdbOptions(opt_ptr) = opts;
let opts = rocksdb_ffi::rocksdb_options_create();
let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts;
if opt_ptr.is_null() {
return Err("Could not create options".to_string());
}
ffi::rocksdb_options_increase_parallelism(opts, 2);
//ffi::rocksdb_options_optimize_level_style_compaction(opts, 0);
//rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2);
//rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0);
match create_if_missing {
true => ffi::rocksdb_options_set_create_if_missing(opts, 1),
false => ffi::rocksdb_options_set_create_if_missing(opts, 0),
true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1),
false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0),
}
let cpath = path.to_c_str();
let cpath_ptr = cpath.as_ptr();
let err = 0 as *mut i8;
let db = ffi::rocksdb_open(opts, cpath_ptr, err);
let ffi::RocksdbInstance(db_ptr) = db;
let db = rocksdb_ffi::rocksdb_open(opts, cpath_ptr, err);
let rocksdb_ffi::RocksdbInstance(db_ptr) = db;
if err.is_not_null() {
let cs = CString::new(err as *const i8, true);
match cs.as_str() {
......@@ -199,14 +221,16 @@ pub fn open(path: String, create_if_missing: bool) -> Result<Rocksdb, String> {
if db_ptr.is_null() {
return Err("Could not initialize database.".to_string());
}
Ok(Rocksdb{inner: db, path: path})
Ok(Rocksdb{inner: db})
}
}
#[allow(dead_code)]
#[test]
fn external() {
let db = open("testdb".to_string(), true).unwrap();
db.put(b"k1", b"v1111");
let db = open("externaltest".to_string(), true).unwrap();
let p = db.put(b"k1", b"v1111");
assert!(p.is_ok());
let r: RocksdbResult<RocksdbVector, String> = db.get(b"k1");
//assert!(r.is_some());
r.map(|v| { assert!(v.as_slice().len() == 5); } );
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment