@nxtedition/rocksdb 5.2.10 → 5.2.17

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [5.2.16] - 2022-04-20
+
+## [5.2.15] - 2022-04-20
+
+## [5.2.14] - 2022-04-20
+
 ## [5.2.1] - 2022-03-25
 
 ### Fixed

package/binding.cc

@@ -17,10 +17,8 @@
 namespace leveldb = rocksdb;
 
 #include <set>
-#include <optional>
 #include <memory>
 #include <string>
-#include <string_view>
 #include <vector>
 
 class NullLogger : public rocksdb::Logger {
@@ -64,7 +62,7 @@ static bool IsObject (napi_env env, napi_value value) {
   return type == napi_object;
 }
 
-static napi_value CreateError (napi_env env, const std::string_view& str) {
+static napi_value CreateError (napi_env env, const std::string& str) {
   napi_value msg;
   napi_create_string_utf8(env, str.data(), str.size(), &msg);
   napi_value error;
@@ -72,7 +70,7 @@ static napi_value CreateError (napi_env env, const std::string_view& str) {
   return error;
 }
 
-static napi_value CreateCodeError (napi_env env, const std::string_view& code, const std::string_view& msg) {
+static napi_value CreateCodeError (napi_env env, const std::string& code, const std::string& msg) {
   napi_value codeValue;
   napi_create_string_utf8(env, code.data(), code.size(), &codeValue);
   napi_value msgValue;
@@ -82,19 +80,19 @@ static napi_value CreateCodeError (napi_env env, const std::string_view& code, c
   return error;
 }
 
-static bool HasProperty (napi_env env, napi_value obj, const std::string_view& key) {
+static bool HasProperty (napi_env env, napi_value obj, const std::string& key) {
   bool has = false;
   napi_has_named_property(env, obj, key.data(), &has);
   return has;
 }
 
-static napi_value GetProperty (napi_env env, napi_value obj, const std::string_view& key) {
+static napi_value GetProperty (napi_env env, napi_value obj, const std::string& key) {
   napi_value value;
   napi_get_named_property(env, obj, key.data(), &value);
   return value;
 }
 
-static bool BooleanProperty (napi_env env, napi_value obj, const std::string_view& key,
+static bool BooleanProperty (napi_env env, napi_value obj, const std::string& key,
                              bool defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
@@ -106,12 +104,12 @@ static bool BooleanProperty (napi_env env, napi_value obj, const std::string_vie
   return defaultValue;
 }
 
-static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string_view& option) {
+static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string& option) {
   napi_value value;
   size_t size;
 
   if (napi_get_named_property(env, obj, option.data(), &value) == napi_ok &&
-    napi_get_value_string_utf8(env, value, NULL, 0, &size) == napi_ok) {
+    napi_get_value_string_utf8(env, value, nullptr, 0, &size) == napi_ok) {
     // Value is either "buffer" or "utf8" so we can tell them apart just by size
     return size == 6;
   }
@@ -119,7 +117,7 @@ static bool EncodingIsBuffer (napi_env env, napi_value obj, const std::string_vi
   return false;
 }
 
-static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string_view& key,
+static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string& key,
                                 uint32_t defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
@@ -131,7 +129,7 @@ static uint32_t Uint32Property (napi_env env, napi_value obj, const std::string_
   return defaultValue;
 }
 
-static int Int32Property (napi_env env, napi_value obj, const std::string_view& key,
+static int Int32Property (napi_env env, napi_value obj, const std::string& key,
                           int defaultValue) {
   if (HasProperty(env, obj, key.data())) {
     const auto value = GetProperty(env, obj, key.data());
@@ -143,7 +141,7 @@ static int Int32Property (napi_env env, napi_value obj, const std::string_view&
   return defaultValue;
 }
 
-static std::optional<std::string> ToString (napi_env env, napi_value from) {
+static std::string ToString (napi_env env, napi_value from, const std::string& defaultValue = "") {
   if (IsString(env, from)) {
     size_t length = 0;
     napi_get_value_string_utf8(env, from, nullptr, 0, &length);
@@ -157,14 +155,14 @@ static std::optional<std::string> ToString (napi_env env, napi_value from) {
     return std::string(buf, length);
   }
 
-  return {};
+  return defaultValue;
 }
 
-static std::string StringProperty (napi_env env, napi_value obj, const std::string_view& key) {
+static std::string StringProperty (napi_env env, napi_value obj, const std::string& key) {
   if (HasProperty(env, obj, key)) {
     napi_value value = GetProperty(env, obj, key);
     if (IsString(env, value)) {
-      return ToString(env, value).value_or(std::string());
+      return ToString(env, value);
     }
   }
 
@@ -184,13 +182,13 @@ static size_t StringOrBufferLength (napi_env env, napi_value value) {
   return size;
 }
 
-static std::optional<std::string> RangeOption (napi_env env, napi_value opts, const std::string& name) {
+static std::string* RangeOption (napi_env env, napi_value opts, const std::string& name) {
   if (HasProperty(env, opts, name)) {
     const auto value = GetProperty(env, opts, name);
-    return ToString(env, value);
+    return new std::string(ToString(env, value));
   }
 
-  return {};
+  return nullptr;
 }
 
 static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
@@ -205,7 +203,7 @@ static std::vector<std::string> KeyArray (napi_env env, napi_value arr) {
 
       if (napi_get_element(env, arr, i, &element) == napi_ok &&
           StringOrBufferLength(env, element) > 0) {
-        result.push_back(ToString(env, element).value_or(std::string()));
+        result.push_back(ToString(env, element));
       }
     }
   }
@@ -222,17 +220,6 @@ static napi_status CallFunction (napi_env env,
   return napi_call_function(env, global, callback, argc, argv, nullptr);
 }
 
-template <typename T>
-void Convert (napi_env env, const std::optional<T>& s, bool asBuffer, napi_value& result) {
-  if (!s) {
-    napi_get_undefined(env, &result);
-  } else if (asBuffer) {
-    napi_create_buffer_copy(env, s->size(), s->data(), nullptr, &result);
-  } else {
-    napi_create_string_utf8(env, s->data(), s->size(), &result);
-  }
-}
-
 template <typename T>
 void Convert (napi_env env, const T& s, bool asBuffer, napi_value& result) {
   if (asBuffer) {
@@ -407,6 +394,18 @@ struct Database {
     return db_->Write(options, batch);
   }
 
+  uint64_t ApproximateSize (const leveldb::Range* range) {
+    uint64_t size = 0;
+    db_->GetApproximateSizes(range, 1, &size);
+    return size;
+  }
+
+  void CompactRange (const leveldb::Slice* start,
+                     const leveldb::Slice* end) {
+    rocksdb::CompactRangeOptions options;
+    db_->CompactRange(options, start, end);
+  }
+
   void GetProperty (const std::string& property, std::string& value) {
     db_->GetProperty(property, &value);
   }
@@ -479,10 +478,10 @@ struct PriorityWorker : public BaseWorker {
 struct BaseIterator {
   BaseIterator(Database* database,
                const bool reverse,
-               const std::optional<std::string>& lt,
-               const std::optional<std::string>& lte,
-               const std::optional<std::string>& gt,
-               const std::optional<std::string>& gte,
+               const std::string* lt,
+               const std::string* lte,
+               const std::string* gt,
+               const std::string* gte,
                const int limit,
                const bool fillCache)
     : database_(database),
@@ -506,6 +505,11 @@ struct BaseIterator {
 
   virtual ~BaseIterator () {
     assert(!dbIterator_);
+
+    delete lt_;
+    delete lte_;
+    delete gt_;
+    delete gte_;
   }
 
   bool DidSeek () const {
@@ -648,10 +652,10 @@ private:
   leveldb::Iterator* dbIterator_;
   bool didSeek_;
   const bool reverse_;
-  const std::optional<std::string> lt_;
-  const std::optional<std::string> lte_;
-  const std::optional<std::string> gt_;
-  const std::optional<std::string> gte_;
+  const std::string* lt_;
+  const std::string* lte_;
+  const std::string* gt_;
+  const std::string* gte_;
   const int limit_;
   int count_;
 };
@@ -662,10 +666,10 @@ struct Iterator final : public BaseIterator {
             const bool keys,
             const bool values,
             const int limit,
-            const std::optional<std::string>& lt,
-            const std::optional<std::string>& lte,
-            const std::optional<std::string>& gt,
-            const std::optional<std::string>& gte,
+            const std::string* lt,
+            const std::string* lte,
+            const std::string* gt,
+            const std::string* gte,
             const bool fillCache,
             const bool keyAsBuffer,
             const bool valueAsBuffer,
@@ -857,6 +861,8 @@ struct OpenWorker final : public BaseWorker {
     tableOptions.block_size = blockSize;
     tableOptions.block_restart_interval = blockRestartInterval;
     tableOptions.filter_policy.reset(rocksdb::NewBloomFilterPolicy(10));
+    tableOptions.format_version = 5;
+    tableOptions.checksum = rocksdb::kxxHash64;
 
     options_.table_factory.reset(
       rocksdb::NewBlockBasedTableFactory(tableOptions)
@@ -876,7 +882,7 @@ NAPI_METHOD(db_open) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto location = ToString(env, argv[1]).value_or(std::string());
+  const auto location = ToString(env, argv[1]);
   const auto options = argv[2];
   const auto createIfMissing = BooleanProperty(env, options, "createIfMissing", true);
   const auto errorIfExists = BooleanProperty(env, options, "errorIfExists", false);
@@ -952,7 +958,7 @@ struct PutWorker final : public PriorityWorker {
              const std::string& key,
              const std::string& value,
              bool sync)
-    : PriorityWorker(env, database, callback, "classic_level.db.put"),
+    : PriorityWorker(env, database, callback, "rocks_level.db.put"),
       key_(key), value_(value), sync_(sync) {
   }
 
@@ -971,8 +977,8 @@ NAPI_METHOD(db_put) {
   NAPI_ARGV(5);
   NAPI_DB_CONTEXT();
 
-  const auto key = ToString(env, argv[1]).value_or(std::string());
-  const auto value = ToString(env, argv[2]).value_or(std::string());
+  const auto key = ToString(env, argv[1]);
+  const auto value = ToString(env, argv[2]);
   const auto sync = BooleanProperty(env, argv[3], "sync", false);
   const auto callback = argv[4];
 
@@ -989,7 +995,7 @@ struct GetWorker final : public PriorityWorker {
              const std::string& key,
              const bool asBuffer,
              const bool fillCache)
-    : PriorityWorker(env, database, callback, "classic_level.db.get"),
+    : PriorityWorker(env, database, callback, "rocks_level.db.get"),
       key_(key), asBuffer_(asBuffer), fillCache_(fillCache) {
   }
 
@@ -1017,7 +1023,7 @@ NAPI_METHOD(db_get) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto key = ToString(env, argv[1]);
   const auto options = argv[2];
   const auto asBuffer = EncodingIsBuffer(env, options, "valueEncoding");
   const auto fillCache = BooleanProperty(env, options, "fillCache", true);
@@ -1029,7 +1035,6 @@ NAPI_METHOD(db_get) {
   return 0;
 }
 
-
 struct GetManyWorker final : public PriorityWorker {
   GetManyWorker (napi_env env,
                  Database* database,
@@ -1062,9 +1067,9 @@ struct GetManyWorker final : public PriorityWorker {
       const auto status = database_->Get(options, key, value);
 
       if (status.ok()) {
-        cache_.push_back(std::move(value));
+        cache_.emplace_back(std::move(value));
       } else if (status.IsNotFound()) {
-        cache_.push_back({});
+        cache_.emplace_back(nullptr);
       } else {
         SetStatus(status);
         break;
@@ -1085,7 +1090,11 @@ struct GetManyWorker final : public PriorityWorker {
 
     for (size_t idx = 0; idx < size; idx++) {
       napi_value element;
-      Convert(env, cache_[idx], valueAsBuffer_, element);
+      if (cache_[idx].GetSelf() != nullptr) {
+        Convert(env, cache_[idx], valueAsBuffer_, element);
+      } else {
+        napi_get_undefined(env, &element);
+      }
       napi_set_element(env, array, static_cast<uint32_t>(idx), element);
     }
 
@@ -1098,7 +1107,7 @@ struct GetManyWorker final : public PriorityWorker {
 private:
   const std::vector<std::string> keys_;
   const bool valueAsBuffer_;
-  std::vector<std::optional<rocksdb::PinnableSlice>> cache_;
+  std::vector<rocksdb::PinnableSlice> cache_;
   const bool fillCache_;
   const leveldb::Snapshot* snapshot_;
 };
@@ -1125,7 +1134,7 @@ struct DelWorker final : public PriorityWorker {
              napi_value callback,
              const std::string& key,
              bool sync)
-    : PriorityWorker(env, database, callback, "classic_level.db.del"),
+    : PriorityWorker(env, database, callback, "rocks_level.db.del"),
       key_(key), sync_(sync) {
   }
 
@@ -1143,7 +1152,7 @@ NAPI_METHOD(db_del) {
   NAPI_ARGV(4);
   NAPI_DB_CONTEXT();
 
-  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto key = ToString(env, argv[1]);
   const auto sync = BooleanProperty(env, argv[2], "sync", false);
   const auto callback = argv[3];
 
@@ -1159,11 +1168,11 @@ struct ClearWorker final : public PriorityWorker {
                napi_value callback,
                const bool reverse,
                const int limit,
-               const std::optional<std::string>& lt,
-               const std::optional<std::string>& lte,
-               const std::optional<std::string>& gt,
-               const std::optional<std::string>& gte)
-    : PriorityWorker(env, database, callback, "classic_level.db.clear"),
+               const std::string* lt,
+               const std::string* lte,
+               const std::string* gt,
+               const std::string* gte)
+    : PriorityWorker(env, database, callback, "rocks_level.db.clear"),
       iterator_(database, reverse, lt, lte, gt, gte, limit, false) {
   }
 
@@ -1226,6 +1235,150 @@ NAPI_METHOD(db_clear) {
   return 0;
 }
 
+struct ApproximateSizeWorker final : public PriorityWorker {
+  ApproximateSizeWorker (napi_env env,
+                         Database* database,
+                         napi_value callback,
+                         const std::string& start,
+                         const std::string& end)
+    : PriorityWorker(env, database, callback, "rocks_level.db.approximate_size"),
+      start_(start), end_(end) {}
+
+  void DoExecute () override {
+    leveldb::Range range(start_, end_);
+    size_ = database_->ApproximateSize(&range);
+  }
+
+  void HandleOKCallback (napi_env env, napi_value callback) override {
+    napi_value argv[2];
+    napi_get_null(env, &argv[0]);
+    napi_create_int64(env, size_, &argv[1]);
+    CallFunction(env, callback, 2, argv);
+  }
+
+  std::string start_;
+  std::string end_;
+  uint64_t size_;
+};
+
+NAPI_METHOD(db_approximate_size) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  const auto start = ToString(env, argv[1]);
+  const auto end = ToString(env, argv[2]);
+  const auto callback = argv[3];
+
+  auto worker  = new ApproximateSizeWorker(env, database, callback, start, end);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct CompactRangeWorker final : public PriorityWorker {
+  CompactRangeWorker (napi_env env,
+                      Database* database,
+                      napi_value callback,
+                      const std::string& start,
+                      const std::string& end)
+    : PriorityWorker(env, database, callback, "rocks_level.db.compact_range"),
+      start_(start), end_(end) {}
+
+  void DoExecute () override {
+    leveldb::Slice start = start_;
+    leveldb::Slice end = end_;
+    database_->CompactRange(&start, &end);
+  }
+
+  const std::string start_;
+  const std::string end_;
+};
+
+NAPI_METHOD(db_compact_range) {
+  NAPI_ARGV(4);
+  NAPI_DB_CONTEXT();
+
+  const auto start = ToString(env, argv[1]);
+  const auto end = ToString(env, argv[2]);
+  const auto callback = argv[3];
+
+  auto worker  = new CompactRangeWorker(env, database, callback, start, end);
+  worker->Queue(env);
+
+  return 0;
+}
+
+NAPI_METHOD(db_get_property) {
+  NAPI_ARGV(2);
+  NAPI_DB_CONTEXT();
+
+  const auto property = ToString(env, argv[1]);
+
+  std::string value;
+  database->GetProperty(property, value);
+
+  napi_value result;
+  napi_create_string_utf8(env, value.data(), value.size(), &result);
+
+  return result;
+}
+
+struct DestroyWorker final : public BaseWorker {
+  DestroyWorker (napi_env env,
+                 const std::string& location,
+                 napi_value callback)
+    : BaseWorker(env, nullptr, callback, "rocks_level.destroy_db"),
+      location_(location) {}
+
+  ~DestroyWorker () {}
+
+  void DoExecute () override {
+    leveldb::Options options;
+    SetStatus(leveldb::DestroyDB(location_, options));
+  }
+
+  const std::string location_;
+};
+
+NAPI_METHOD(destroy_db) {
+  NAPI_ARGV(2);
+
+  const auto location = ToString(env, argv[0]);
+  const auto callback = argv[1];
+
+  auto worker = new DestroyWorker(env, location, callback);
+  worker->Queue(env);
+
+  return 0;
+}
+
+struct RepairWorker final : public BaseWorker {
+  RepairWorker (napi_env env,
+                const std::string& location,
+                napi_value callback)
+    : BaseWorker(env, nullptr, callback, "rocks_level.repair_db"),
+      location_(location) {}
+
+  void DoExecute () override {
+    leveldb::Options options;
+    SetStatus(leveldb::RepairDB(location_, options));
+  }
+
+  const std::string location_;
+};
+
+NAPI_METHOD(repair_db) {
+  NAPI_ARGV(2);
+
+  const auto location = ToString(env, argv[1]);
+  const auto callback = argv[1];
+
+  auto worker = new RepairWorker(env, location, callback);
+  worker->Queue(env);
+
+  return 0;
+}
+
 static void FinalizeIterator (napi_env env, void* data, void* hint) {
   if (data) {
     delete reinterpret_cast<Iterator*>(data);
@@ -1275,7 +1428,7 @@ NAPI_METHOD(iterator_seek) {
     napi_throw_error(env, nullptr, "iterator has closed");
   }
 
-  const auto target = ToString(env, argv[1]).value_or(std::string());
+  const auto target = ToString(env, argv[1]);
   iterator->first_ = true;
   iterator->Seek(target);
 
@@ -1427,7 +1580,7 @@ struct BatchWorker final : public PriorityWorker {
                leveldb::WriteBatch* batch,
                const bool sync,
                const bool hasData)
-    : PriorityWorker(env, database, callback, "classic_level.batch.do"),
+    : PriorityWorker(env, database, callback, "rocks_level.batch.do"),
       batch_(batch), hasData_(hasData) {
     options_.sync = sync;
   }
@@ -1472,7 +1625,7 @@ NAPI_METHOD(batch_do) {
 
     if (type == "del") {
       if (!HasProperty(env, element, "key")) continue;
-      const auto key = ToString(env, GetProperty(env, element, "key")).value_or(std::string());
+      const auto key = ToString(env, GetProperty(env, element, "key"));
 
       batch->Delete(key);
       if (!hasData) hasData = true;
@@ -1480,8 +1633,8 @@ NAPI_METHOD(batch_do) {
       if (!HasProperty(env, element, "key")) continue;
       if (!HasProperty(env, element, "value")) continue;
 
-      const auto key = ToString(env, GetProperty(env, element, "key")).value_or(std::string());
-      const auto value = ToString(env, GetProperty(env, element, "value")).value_or(std::string());
+      const auto key = ToString(env, GetProperty(env, element, "key"));
+      const auto value = ToString(env, GetProperty(env, element, "value"));
 
       batch->Put(key, value);
       if (!hasData) hasData = true;
@@ -1517,8 +1670,8 @@ NAPI_METHOD(batch_put) {
   NAPI_ARGV(3);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = ToString(env, argv[1]).value_or(std::string());
-  const auto value = ToString(env, argv[2]).value_or(std::string());
+  const auto key = ToString(env, argv[1]);
+  const auto value = ToString(env, argv[2]);
 
   batch->Put(key, value);
 
@@ -1529,7 +1682,7 @@ NAPI_METHOD(batch_del) {
   NAPI_ARGV(2);
   NAPI_BATCH_CONTEXT();
 
-  const auto key = ToString(env, argv[1]).value_or(std::string());
+  const auto key = ToString(env, argv[1]);
 
   batch->Delete(key);
 
@@ -1601,6 +1754,12 @@ NAPI_INIT() {
   NAPI_EXPORT_FUNCTION(db_get_many);
   NAPI_EXPORT_FUNCTION(db_del);
   NAPI_EXPORT_FUNCTION(db_clear);
+  NAPI_EXPORT_FUNCTION(db_approximate_size);
+  NAPI_EXPORT_FUNCTION(db_compact_range);
+  NAPI_EXPORT_FUNCTION(db_get_property);
+
+  NAPI_EXPORT_FUNCTION(destroy_db);
+  NAPI_EXPORT_FUNCTION(repair_db);
 
   NAPI_EXPORT_FUNCTION(iterator_init);
   NAPI_EXPORT_FUNCTION(iterator_seek);

package/binding.gyp

@@ -23,7 +23,7 @@
                 }
               }
           }, { # OS != 'win'
-              'cflags': [ '-std=c++20' ]
+              'cflags': [ '-std=c++17' ]
             , 'cflags!': [ '-fno-rtti' ]
             , 'cflags_cc!': [ '-fno-rtti' ]
             , 'cflags_cc+': [ '-frtti' ]
@@ -40,7 +40,7 @@
                 ]
                 , 'OTHER_CPLUSPLUSFLAGS': [
                     '-mmacosx-version-min=10.14'
-                  , '-std=c++20'
+                  , '-std=c++17'
                   , '-stdlib=libc++'
                   , '-arch x86_64'
                   , '-arch arm64'

package/deps/rocksdb/rocksdb/README.md

@@ -0,0 +1,32 @@
+## RocksDB: A Persistent Key-Value Store for Flash and RAM Storage
+
+[![CircleCI Status](https://circleci.com/gh/facebook/rocksdb.svg?style=svg)](https://circleci.com/gh/facebook/rocksdb)
+[![TravisCI Status](https://travis-ci.org/facebook/rocksdb.svg?branch=master)](https://travis-ci.org/facebook/rocksdb)
+[![Appveyor Build status](https://ci.appveyor.com/api/projects/status/fbgfu0so3afcno78/branch/master?svg=true)](https://ci.appveyor.com/project/Facebook/rocksdb/branch/master)
+[![PPC64le Build Status](http://140-211-168-68-openstack.osuosl.org:8080/buildStatus/icon?job=rocksdb&style=plastic)](http://140-211-168-68-openstack.osuosl.org:8080/job/rocksdb)
+
+RocksDB is developed and maintained by Facebook Database Engineering Team.
+It is built on earlier work on [LevelDB](https://github.com/google/leveldb) by Sanjay Ghemawat (sanjay@google.com)
+and Jeff Dean (jeff@google.com)
+
+This code is a library that forms the core building block for a fast
+key-value server, especially suited for storing data on flash drives.
+It has a Log-Structured-Merge-Database (LSM) design with flexible tradeoffs
+between Write-Amplification-Factor (WAF), Read-Amplification-Factor (RAF)
+and Space-Amplification-Factor (SAF). It has multi-threaded compactions,
+making it especially suitable for storing multiple terabytes of data in a
+single database.
+
+Start with example usage here: https://github.com/facebook/rocksdb/tree/master/examples
+
+See the [github wiki](https://github.com/facebook/rocksdb/wiki) for more explanation.
+
+The public interface is in `include/`.  Callers should not include or
+rely on the details of any other header files in this package.  Those
+internal APIs may be changed without warning.
+
+Design discussions are conducted in https://www.facebook.com/groups/rocksdb.dev/ and https://rocksdb.slack.com/
+
+## License
+
+RocksDB is dual-licensed under both the GPLv2 (found in the COPYING file in the root directory) and Apache 2.0 License (found in the LICENSE.Apache file in the root directory).  You may select, at your option, one of the above-listed licenses.

package/deps/rocksdb/rocksdb/hdfs/README

@@ -0,0 +1,23 @@
+This directory contains the hdfs extensions needed to make rocksdb store
+files in HDFS.
+
+It has been compiled and testing against CDH 4.4 (2.0.0+1475-1.cdh4.4.0.p0.23~precise-cdh4.4.0).
+
+The configuration assumes that packages libhdfs0, libhdfs0-dev are 
+installed which basically means that hdfs.h is in /usr/include and libhdfs in /usr/lib
+
+The env_hdfs.h file defines the rocksdb objects that are needed to talk to an
+underlying filesystem. 
+
+If you want to compile rocksdb with hdfs support, please set the following
+environment variables appropriately (also defined in setup.sh for convenience)
+   USE_HDFS=1
+   JAVA_HOME=/usr/local/jdk-7u79-64
+   LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/jdk-7u79-64/jre/lib/amd64/server:/usr/local/jdk-7u79-64/jre/lib/amd64/:./snappy/libs
+   make clean all db_bench
+
+To run dbbench,
+  set CLASSPATH to include your hadoop distribution
+  db_bench --hdfs="hdfs://hbaseudbperf001.snc1.facebook.com:9000"
+
+

package/deps/rocksdb/rocksdb/port/README

@@ -0,0 +1,10 @@
+This directory contains interfaces and implementations that isolate the
+rest of the package from platform details.
+
+Code in the rest of the package includes "port.h" from this directory.
+"port.h" in turn includes a platform specific "port_<platform>.h" file
+that provides the platform specific implementation.
+
+See port_posix.h for an example of what must be provided in a platform
+specific header file.
+