rrudb 0.0.2

data/ext/rudb/NuDB/include/nudb/win32_file.hpp

@@ -0,0 +1,246 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_DETAIL_WIN32_FILE_HPP
+#define NUDB_DETAIL_WIN32_FILE_HPP
+
+#include <nudb/file.hpp>
+#include <nudb/error.hpp>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#ifndef NUDB_WIN32_FILE
+# ifdef _MSC_VER
+#  define NUDB_WIN32_FILE 1
+# else
+#  define NUDB_WIN32_FILE 0
+# endif
+#endif
+
+#if NUDB_WIN32_FILE
+#pragma push_macro("NOMINMAX")
+#pragma push_macro("UNICODE")
+#pragma push_macro("STRICT")
+# ifndef NOMINMAX
+#  define NOMINMAX
+# endif
+# ifndef UNICODE
+#  define UNICODE
+# endif
+# ifndef STRICT
+#  define STRICT
+# endif
+# ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+# endif
+# include <Windows.h>
+#pragma pop_macro("STRICT")
+#pragma pop_macro("UNICODE")
+#pragma pop_macro("NOMINMAX")
+#endif
+
+#if NUDB_WIN32_FILE
+
+namespace nudb {
+
+/** A descriptor to a Win32 file.
+
+    This class provides a Win32 implementation of the @b File
+    concept.
+*/
+class win32_file
+{
+    HANDLE hf_ = INVALID_HANDLE_VALUE;
+
+public:
+    /// Constructor
+    win32_file() = default;
+
+    /// Copy constructor (disallowed)
+    win32_file(win32_file const&) = delete;
+
+    // Copy assignment (disallowed)
+    win32_file& operator=(win32_file const&) = delete;
+
+    /** Destructor.
+
+        If open, the file is closed.
+    */
+    ~win32_file();
+
+    /** Move constructor.
+
+        @note The state of the moved-from object is as if default constructed.
+    */
+    win32_file(win32_file&&);
+
+    /** Move assignment.
+
+        @note The state of the moved-from object is as if default constructed.
+    */
+    win32_file&
+    operator=(win32_file&& other);
+
+    /// Returns `true` if the file is open.
+    bool
+    is_open() const
+    {
+        return hf_ != INVALID_HANDLE_VALUE;
+    }
+
+    /// Close the file if it is open.
+    void
+    close();
+
+    /** Create a new file.
+
+        After the file is created, it is opened as if by `open(mode, path, ec)`.
+
+        @par Requirements
+
+        The file must not already exist, or else `errc::file_exists`
+        is returned.
+
+        @param mode The open mode, which must be a valid @ref file_mode.
+
+        @param path The path of the file to create.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    create(file_mode mode, path_type const& path, error_code& ec);
+
+    /** Open a file.
+
+        @par Requirements
+
+        The file must not already be open.
+
+        @param mode The open mode, which must be a valid @ref file_mode.
+
+        @param path The path of the file to open.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    open(file_mode mode, path_type const& path, error_code& ec);
+
+    /** Remove a file from the file system.
+
+        It is not an error to attempt to erase a file that does not exist.
+
+        @param path The path of the file to remove.
+
+        @param ec Set to the error, if any occurred.
+    */
+    static
+    void
+    erase(path_type const& path, error_code& ec);
+
+    /** Return the size of the file.
+
+        @par Requirements
+
+        The file must be open.
+
+        @param ec Set to the error, if any occurred.
+
+        @return The size of the file, in bytes.
+    */
+    std::uint64_t
+    size(error_code& ec) const;
+
+    /** Read data from a location in the file.
+
+        @par Requirements
+
+        The file must be open.
+
+        @param offset The position in the file to read from,
+        expressed as a byte offset from the beginning.
+
+        @param buffer The location to store the data.
+
+        @param bytes The number of bytes to read.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    read(std::uint64_t offset,
+        void* buffer, std::size_t bytes, error_code& ec);
+
+    /** Write data to a location in the file.
+
+        @par Requirements
+
+        The file must be open with a mode allowing writes.
+
+        @param offset The position in the file to write from,
+        expressed as a byte offset from the beginning.
+
+        @param buffer The data the write.
+
+        @param bytes The number of bytes to write.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    write(std::uint64_t offset,
+        void const* buffer, std::size_t bytes, error_code& ec);
+
+    /** Perform a low level file synchronization.
+
+        @par Requirements
+
+        The file must be open with a mode allowing writes.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    sync(error_code& ec);
+
+    /** Truncate the file at a specific size.
+
+        @par Requirements
+
+        The file must be open with a mode allowing writes.
+
+        @param length The new file size.
+
+        @param ec Set to the error, if any occurred.
+    */
+    void
+    trunc(std::uint64_t length, error_code& ec);
+
+private:
+    static
+    void
+    err(DWORD dwError, error_code& ec)
+    {
+        ec = error_code{static_cast<int>(dwError), system_category()};
+    }
+
+    static
+    void
+    last_err(error_code& ec)
+    {
+        err(::GetLastError(), ec);
+    }
+
+    static
+    std::pair<DWORD, DWORD>
+    flags(file_mode mode);
+};
+
+} // nudb
+
+#include <nudb/impl/win32_file.ipp>
+
+#endif
+
+#endif

data/ext/rudb/NuDB/include/nudb/xxhasher.hpp

@@ -0,0 +1,45 @@
+//
+// Copyright (c) 2015-2016 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#ifndef NUDB_XXHASHER_HPP
+#define NUDB_XXHASHER_HPP
+
+#include <nudb/detail/xxhash.hpp>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace nudb {
+
+/** A Hasher that uses xxHash.
+
+    This object meets the requirements of @b Hasher. It is
+    the default hash function unless otherwise specified.
+*/
+class xxhasher
+{
+    std::uint64_t seed_;
+
+public:
+    using result_type = std::uint64_t;
+
+    explicit
+    xxhasher(std::uint64_t seed)
+        : seed_(seed)
+    {
+    }
+
+    result_type
+    operator()(void const* data, std::size_t bytes) const noexcept
+    {
+        return detail::XXH64(data, bytes, seed_);
+    }
+};
+
+} // nudb
+
+#endif

data/ext/rudb/extconf.rb

@@ -0,0 +1,12 @@
+require "mkmf"
+
+RbConfig::CONFIG["CPP"] = "g++ -E -std=gnu++11"
+$INCFLAGS << " -I./NuDB/include"
+
+have_library("boost_thread")
+have_library("boost_system")
+
+abort "Can't find header or library of NuDB" unless have_header('nudb/nudb.hpp')
+
+create_header
+create_makefile("rudb")

data/ext/rudb/rudb.cpp

@@ -0,0 +1,234 @@
+#include RUBY_EXTCONF_H
+
+#include <ruby.h>
+#include <nudb/nudb.hpp>
+
+static VALUE mRuDB;
+static VALUE cRuDB_store;
+static VALUE cRuDB_ec;
+
+struct nudb_store_pointer {
+  nudb::store* store;
+};
+
+///
+
+// TODO pull in error_category (requires ref mark?)
+
+void ec_free(nudb::error_code* ec_pointer){
+  delete ec_pointer;
+}
+
+VALUE ec2obj(nudb::error_code* ec){
+  return Data_Wrap_Struct(cRuDB_ec, 0, ec_free, ec);
+}
+
+VALUE rudb_ec_value(VALUE _self){
+  nudb::error_code* ec_pointer;
+  Data_Get_Struct(_self, nudb::error_code , ec_pointer);
+  return INT2NUM(ec_pointer->value());
+}
+
+VALUE rudb_ec_message(VALUE _self){
+  nudb::error_code* ec_pointer;
+  Data_Get_Struct(_self, nudb::error_code , ec_pointer);
+  return rb_str_new_cstr(ec_pointer->message().c_str());
+}
+
+///
+
+VALUE rudb_create(VALUE _self, VALUE opts) {
+  VALUE dat         = rb_hash_aref(opts, ID2SYM(rb_intern("dat_path")));
+  VALUE key         = rb_hash_aref(opts, ID2SYM(rb_intern("key_path")));
+  VALUE log         = rb_hash_aref(opts, ID2SYM(rb_intern("log_path")));
+  VALUE app_num     = rb_hash_aref(opts, ID2SYM(rb_intern("app_num")));
+  VALUE salt        = rb_hash_aref(opts, ID2SYM(rb_intern("salt")));
+  VALUE key_size    = rb_hash_aref(opts, ID2SYM(rb_intern("key_size")));
+  VALUE block_size  = rb_hash_aref(opts, ID2SYM(rb_intern("block_size")));
+  VALUE load_factor = rb_hash_aref(opts, ID2SYM(rb_intern("load_factor")));
+
+  Check_Type(dat,         T_STRING);
+  Check_Type(key,         T_STRING);
+  Check_Type(log,         T_STRING);
+  Check_Type(app_num,     T_FIXNUM);
+  Check_Type(salt,        T_FIXNUM);
+  Check_Type(key_size,    T_FIXNUM);
+  Check_Type(block_size,  T_FIXNUM);
+  Check_Type(load_factor, T_FLOAT);
+
+  std::string _dat = std::string((char*)RSTRING_PTR(dat), RSTRING_LEN(dat));
+  std::string _key = std::string((char*)RSTRING_PTR(key), RSTRING_LEN(key));
+  std::string _log = std::string((char*)RSTRING_PTR(log), RSTRING_LEN(log));
+
+  std::uint64_t _app_num    = NUM2ULL(app_num);
+  std::uint64_t _salt       = NUM2ULL(salt);
+  nudb::nsize_t _key_size   = NUM2UINT(key_size);
+  nudb::nsize_t _block_size = NUM2UINT(block_size);
+  float _load_factor        = NUM2DBL(load_factor);
+
+  // TODO parameterize hasher typer
+  nudb::error_code ec;
+  nudb::create<nudb::xxhasher>(_dat, _key, _log,
+                               _app_num,
+                               _salt,
+                               _key_size,
+                               _block_size,
+                               _load_factor,
+                               ec);
+
+  return ec2obj(new nudb::error_code(ec));
+}
+
+VALUE rudb_erase_file(VALUE _self, VALUE file) {
+  Check_Type(file, T_STRING);
+  std::string fil = std::string((char*)RSTRING_PTR(file), RSTRING_LEN(file));
+
+  nudb::error_code ec;
+  nudb::erase_file(fil, ec);
+
+  return ec2obj(new nudb::error_code(ec));
+}
+
+VALUE rudb_make_salt(VALUE _self) {
+  return INT2NUM(nudb::make_salt());
+}
+
+VALUE rudb_block_size(VALUE _self, VALUE _path) {
+  Check_Type(_path, T_STRING);
+  std::string path  = std::string((char*)RSTRING_PTR(_path), RSTRING_LEN(_path));
+  return INT2NUM(nudb::block_size(path));
+}
+
+///
+
+void db_free(nudb_store_pointer* store_pointer){
+  if(store_pointer->store != NULL){
+    // FIXME nudb::store is polymorphic w/out virtual destructor
+    delete store_pointer->store;
+    store_pointer->store = NULL;
+  }
+  delete store_pointer;
+}
+
+static VALUE store_alloc(VALUE klass){
+  nudb_store_pointer* store_pointer = ALLOC(nudb_store_pointer);
+  return Data_Wrap_Struct(klass, 0, db_free, store_pointer);
+}
+
+VALUE rudb_store_init(VALUE _self){
+  nudb_store_pointer* store_pointer;
+  Data_Get_Struct(_self, nudb_store_pointer, store_pointer);
+  store_pointer->store = new nudb::store();
+  return _self;
+}
+
+VALUE rudb_store_open(VALUE _self, VALUE dat_path, VALUE key_path, VALUE log_path) {
+  Check_Type(dat_path, T_STRING);
+  Check_Type(key_path, T_STRING);
+  Check_Type(log_path, T_STRING);
+
+  nudb_store_pointer* store_pointer;
+  Data_Get_Struct(_self, nudb_store_pointer, store_pointer);
+
+  std::string dat = std::string((char*)RSTRING_PTR(dat_path),
+                                       RSTRING_LEN(dat_path));
+  std::string key = std::string((char*)RSTRING_PTR(key_path),
+                                       RSTRING_LEN(key_path));
+  std::string log = std::string((char*)RSTRING_PTR(log_path),
+                                       RSTRING_LEN(log_path));
+
+  nudb::error_code ec;
+  store_pointer->store->open(dat, key, log, ec);
+
+  return ec2obj(new nudb::error_code(ec));
+}
+
+VALUE rudb_store_insert(VALUE _self, VALUE key, VALUE value){
+  Check_Type(key,   T_STRING);
+  Check_Type(value, T_STRING);
+
+  std::string key_str   = std::string((char*)RSTRING_PTR(key),   RSTRING_LEN(key));
+  std::string value_str = std::string((char*)RSTRING_PTR(value), RSTRING_LEN(value));
+
+  nudb_store_pointer* store_pointer;
+  Data_Get_Struct(_self, nudb_store_pointer, store_pointer);
+
+  if (store_pointer->store == NULL) {
+    rb_raise(rb_eRuntimeError, "db not open");
+  }
+
+  nudb::error_code ec;
+  store_pointer->store->insert(key_str.c_str(),
+                               value_str.c_str(),
+                               value_str.size(), ec);
+
+  return ec2obj(new nudb::error_code(ec));
+}
+
+VALUE rudb_store_fetch(VALUE _self, VALUE key){
+  Check_Type(key, T_STRING);
+  std::string key_str = std::string((char*)RSTRING_PTR(key), RSTRING_LEN(key));
+
+  nudb_store_pointer* store_pointer;
+  Data_Get_Struct(_self, nudb_store_pointer, store_pointer);
+
+  if (store_pointer->store == NULL) {
+    rb_raise(rb_eRuntimeError, "db not open");
+  }
+
+  std::string result;
+  nudb::error_code ec;
+  store_pointer->store->fetch(key_str.c_str(),
+    [&](void const* buffer, std::size_t size){
+      result = std::string((char*) buffer, size);
+    }, ec);
+
+  VALUE result_obj = rb_str_new(result.c_str(),
+                                result.size());
+
+  // TODO if block given invoke w/ result_obj (only if succeeded)
+
+  VALUE ec_obj = ec2obj(new nudb::error_code(ec));
+
+  VALUE ret = rb_ary_new();
+  rb_ary_push(ret, result_obj); // TODO Qnil if not success
+  rb_ary_push(ret, ec_obj);
+
+  return ret;
+}
+
+VALUE rudb_store_close(VALUE _self){
+  nudb_store_pointer* store_pointer;
+  Data_Get_Struct(_self, nudb_store_pointer, store_pointer);
+
+  nudb::error_code ec;
+  store_pointer->store->close(ec);
+
+  return ec2obj(new nudb::error_code(ec));
+}
+
+///
+
+typedef VALUE (*METHOD)(...);
+
+extern "C"{
+  void Init_rudb(){
+      mRuDB = rb_define_module("RuDB");
+      rb_define_singleton_method(mRuDB, "create",     (METHOD)rudb_create,     1);
+      rb_define_singleton_method(mRuDB, "erase_file", (METHOD)rudb_erase_file, 1);
+      rb_define_singleton_method(mRuDB, "make_salt",  (METHOD)rudb_make_salt,  0);
+      rb_define_singleton_method(mRuDB, "block_size", (METHOD)rudb_block_size, 1);
+
+      cRuDB_store = rb_define_class_under(mRuDB, "Store", rb_cObject);
+      rb_define_alloc_func(cRuDB_store, store_alloc);
+      rb_define_method(cRuDB_store, "initialize", (METHOD)rudb_store_init, 0);
+      rb_define_method(cRuDB_store, "open",       (METHOD)rudb_store_open, 3);
+      rb_define_method(cRuDB_store, "insert",     (METHOD)rudb_store_insert, 2);
+      rb_define_method(cRuDB_store, "fetch",      (METHOD)rudb_store_fetch, 1);
+      rb_define_method(cRuDB_store, "close",      (METHOD)rudb_store_close, 0);
+
+      cRuDB_ec = rb_define_class_under(mRuDB, "ErrorCode", rb_cObject);
+      rb_define_method(cRuDB_ec, "value",    (METHOD)rudb_ec_value, 0);
+      rb_define_method(cRuDB_ec, "message",  (METHOD)rudb_ec_message, 0);
+  }
+}

data/lib/rudb/version.rb

@@ -0,0 +1,3 @@
+module RuDB
+  VERSION = '0.0.2'
+end # module RuDB

data/lib/rudb.rb

@@ -0,0 +1 @@
+require 'rudb.so'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: rrudb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Dev Null Productions
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-14 00:00:00.000000000 Z
+dependencies: []
+description: Ruby NuDB Wrapper
+email:
+- devnullproductions@gmail.com
+executables: []
+extensions:
+- ext/rudb/extconf.rb
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE.txt
+- README.md
+- examples/example.rb
+- ext/rudb/NuDB/include/nudb/CMakeLists.txt
+- ext/rudb/NuDB/include/nudb/_experimental/basic_seconds_clock.hpp
+- ext/rudb/NuDB/include/nudb/_experimental/chrono_util.hpp
+- ext/rudb/NuDB/include/nudb/_experimental/test/fail_file.hpp
+- ext/rudb/NuDB/include/nudb/_experimental/test/temp_dir.hpp
+- ext/rudb/NuDB/include/nudb/_experimental/test/test_store.hpp
+- ext/rudb/NuDB/include/nudb/_experimental/test/xor_shift_engine.hpp
+- ext/rudb/NuDB/include/nudb/_experimental/util.hpp
+- ext/rudb/NuDB/include/nudb/basic_store.hpp
+- ext/rudb/NuDB/include/nudb/concepts.hpp
+- ext/rudb/NuDB/include/nudb/context.hpp
+- ext/rudb/NuDB/include/nudb/create.hpp
+- ext/rudb/NuDB/include/nudb/detail/arena.hpp
+- ext/rudb/NuDB/include/nudb/detail/bucket.hpp
+- ext/rudb/NuDB/include/nudb/detail/buffer.hpp
+- ext/rudb/NuDB/include/nudb/detail/bulkio.hpp
+- ext/rudb/NuDB/include/nudb/detail/cache.hpp
+- ext/rudb/NuDB/include/nudb/detail/endian.hpp
+- ext/rudb/NuDB/include/nudb/detail/field.hpp
+- ext/rudb/NuDB/include/nudb/detail/format.hpp
+- ext/rudb/NuDB/include/nudb/detail/gentex.hpp
+- ext/rudb/NuDB/include/nudb/detail/mutex.hpp
+- ext/rudb/NuDB/include/nudb/detail/pool.hpp
+- ext/rudb/NuDB/include/nudb/detail/store_base.hpp
+- ext/rudb/NuDB/include/nudb/detail/stream.hpp
+- ext/rudb/NuDB/include/nudb/detail/xxhash.hpp
+- ext/rudb/NuDB/include/nudb/error.hpp
+- ext/rudb/NuDB/include/nudb/file.hpp
+- ext/rudb/NuDB/include/nudb/impl/basic_store.ipp
+- ext/rudb/NuDB/include/nudb/impl/context.ipp
+- ext/rudb/NuDB/include/nudb/impl/create.ipp
+- ext/rudb/NuDB/include/nudb/impl/error.ipp
+- ext/rudb/NuDB/include/nudb/impl/posix_file.ipp
+- ext/rudb/NuDB/include/nudb/impl/recover.ipp
+- ext/rudb/NuDB/include/nudb/impl/rekey.ipp
+- ext/rudb/NuDB/include/nudb/impl/verify.ipp
+- ext/rudb/NuDB/include/nudb/impl/visit.ipp
+- ext/rudb/NuDB/include/nudb/impl/win32_file.ipp
+- ext/rudb/NuDB/include/nudb/native_file.hpp
+- ext/rudb/NuDB/include/nudb/nudb.hpp
+- ext/rudb/NuDB/include/nudb/posix_file.hpp
+- ext/rudb/NuDB/include/nudb/progress.hpp
+- ext/rudb/NuDB/include/nudb/recover.hpp
+- ext/rudb/NuDB/include/nudb/rekey.hpp
+- ext/rudb/NuDB/include/nudb/store.hpp
+- ext/rudb/NuDB/include/nudb/type_traits.hpp
+- ext/rudb/NuDB/include/nudb/verify.hpp
+- ext/rudb/NuDB/include/nudb/version.hpp
+- ext/rudb/NuDB/include/nudb/visit.hpp
+- ext/rudb/NuDB/include/nudb/win32_file.hpp
+- ext/rudb/NuDB/include/nudb/xxhasher.hpp
+- ext/rudb/extconf.rb
+- ext/rudb/rudb.cpp
+- lib/rudb.rb
+- lib/rudb/version.rb
+homepage: https://github.com/DevNullProd/RuDB
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Wrapper around the NuDB fast key/value insert-only database.
+test_files: []