passing tests

Author: cjihrig

deps/leveldb/leveldb-rocksdb/util/build_version.cc.in

@@ -203,7 +203,8 @@ NAN_METHOD(Database::Open) {
     , 16
   );
 
-  database->blockCache = rocksdb::NewLRUCache(cacheSize).get();
+  database->blockCache = cacheSize ? rocksdb::NewLRUCache(cacheSize) :
+                                     NULL;
   database->filterPolicy = rocksdb::NewBloomFilterPolicy(10);
 
   OpenWorker* worker = new OpenWorker(

src/database.cc

@@ -84,7 +84,7 @@ class Database : public Nan::ObjectWrap {
   rocksdb::DB* db;
   uint32_t currentIteratorId;
   void(*pendingCloseWorker);
-  rocksdb::Cache* blockCache;
+  std::shared_ptr<rocksdb::Cache> blockCache;
   const rocksdb::FilterPolicy* filterPolicy;
 
   std::map< uint32_t, leveldown::Iterator * > iterators;

src/database.h

@@ -8,7 +8,16 @@
 
 #include <rocksdb/write_batch.h>
 #include <rocksdb/filter_policy.h>
+
 #include <rocksdb/utilities/leveldb_options.h>
+#include <rocksdb/cache.h>
+#include <rocksdb/comparator.h>
+#include <rocksdb/env.h>
+#include <rocksdb/options.h>
+#include <rocksdb/table.h>
+
+// #include <rocksdb/table.h>
+// #include <rocksdb/utilities/leveldb_options.h>
 
 #include "database.h"
 #include "leveldown.h"
@@ -22,7 +31,7 @@ namespace leveldown {
 OpenWorker::OpenWorker (
     Database *database
   , Nan::Callback *callback
-  , rocksdb::Cache* blockCache
+  , std::shared_ptr<rocksdb::Cache> blockCache
   , const rocksdb::FilterPolicy* filterPolicy
   , bool createIfMissing
   , bool errorIfExists
@@ -35,7 +44,10 @@ OpenWorker::OpenWorker (
 {
   rocksdb::LevelDBOptions levelOptions;
 
-  levelOptions.block_cache            = blockCache;
+  if (blockCache != NULL) {
+    levelOptions.block_cache = blockCache.get();
+  }
+
   levelOptions.filter_policy          = filterPolicy;
   levelOptions.create_if_missing      = createIfMissing;
   levelOptions.error_if_exists        = errorIfExists;
@@ -52,6 +64,8 @@ OpenWorker::OpenWorker (
 
 
 
+  options = new rocksdb::Options(rocksdb::ConvertOptions(levelOptions));
+/*
   options = new rocksdb::Options();
   options->create_if_missing = levelOptions.create_if_missing;
   options->error_if_exists = levelOptions.error_if_exists;
@@ -62,17 +76,17 @@ OpenWorker::OpenWorker (
   options->max_open_files = levelOptions.max_open_files;
   options->compression = levelOptions.compression;
 
-  // rocksdb::BlockBasedTableOptions table_options;
-  // table_options.block_cache.reset(levelOptions.block_cache);
-  // table_options.block_size = levelOptions.block_size;
-  // table_options.block_restart_interval = levelOptions.block_restart_interval;
-  // table_options.filter_policy.reset(levelOptions.filter_policy);
-  // options->table_factory.reset(rocksdb::NewBlockBasedTableFactory(levelOptions));
-
+  rocksdb::BlockBasedTableOptions table_options;
+  table_options.block_cache.reset(blockCache.get());
+  table_options.block_size = levelOptions.block_size;
+  table_options.block_restart_interval = levelOptions.block_restart_interval;
+  table_options.filter_policy.reset(levelOptions.filter_policy);
+  options->table_factory.reset(rocksdb::NewBlockBasedTableFactory(table_options));
+*/
 };
 
 OpenWorker::~OpenWorker () {
-  delete options;
+  // delete options;
 }
 
 void OpenWorker::Execute () {

src/database_async.cc

@@ -20,7 +20,7 @@ class OpenWorker : public AsyncWorker {
   OpenWorker (
       Database *database
     , Nan::Callback *callback
-    , rocksdb::Cache* blockCache
+    , std::shared_ptr<rocksdb::Cache> blockCache
     , const rocksdb::FilterPolicy* filterPolicy
     , bool createIfMissing
     , bool errorIfExists

src/database_async.h

@@ -27,7 +27,8 @@ test('test callback-less, 1-arg, destroy() throws', function (t) {
 
 test('test destroy non-existant directory', function (t) {
   leveldown.destroy('/1/2/3/4', function () {
-    t.equal(arguments.length, 0, 'no arguments returned on callback')
+    t.equal(arguments.length, 1, 'error object returned on callback')
+    t.equal(/^Error: IO error: \/1\/2\/3\/4\/LOCK: No such file or directory$/.test(arguments[0]), true)
     t.end()
   })
 })

test/destroy-test.js

@@ -31,24 +31,25 @@ test('test non-string getProperty() throws', function (t) {
 
 test('test invalid getProperty() returns empty string', function (t) {
   t.equal(db.getProperty('foo'), '', 'invalid property')
-  t.equal(db.getProperty('leveldb.foo'), '', 'invalid leveldb.* property')
+  t.equal(db.getProperty('rocksdb.foo'), '', 'invalid rocksdb.* property')
   t.end()
 })
 
-test('test invalid getProperty("leveldb.num-files-at-levelN") returns numbers', function (t) {
+test('test invalid getProperty("rocksdb.num-files-at-levelN") returns numbers', function (t) {
   for (var i = 0; i < 7; i++)
-    t.equal(db.getProperty('leveldb.num-files-at-level' + i), '0', '"leveldb.num-files-at-levelN" === "0"')
+    t.equal(db.getProperty('rocksdb.num-files-at-level' + i), '0', '"rocksdb.num-files-at-levelN" === "0"')
   t.end()
 })
 
-test('test invalid getProperty("leveldb.stats")', function (t) {
-  t.ok(db.getProperty('leveldb.stats').split('\n').length > 3, 'leveldb.stats has > 3 newlines')
+test('test invalid getProperty("rocksdb.stats")', function (t) {
+  debugger;
+  t.ok(db.getProperty('rocksdb.stats').split('\n').length > 3, 'rocksdb.stats has > 3 newlines')
   t.end()
 })
 
-test('test invalid getProperty("leveldb.sstables")', function (t) {
-  var expected = [0,1,2,3,4,5,6].map(function (l) { return '--- level ' + l + ' ---' }).join('\n') + '\n'
-  t.equal(db.getProperty('leveldb.sstables'), expected, 'leveldb.sstables')
+test('test invalid getProperty("rocksdb.sstables")', function (t) {
+  var expected = [0,1,2,3,4,5,6].map(function (l) { return '--- level ' + l + ' --- version# 1 ---' }).join('\n') + '\n'
+  t.equal(db.getProperty('rocksdb.sstables'), expected, 'rocksdb.sstables')
   t.end()
 })
 

test/getproperty-test.js

@@ -1,3 +1,5 @@
+/* Not sure if this is needed/supported with RocksDB. It looks like it might be
+   a small floated patch on leveldown.
 const test = require('tape')
     , path = require('path')
     , fs   = require('fs')
@@ -15,3 +17,4 @@ test('test port-libuv is being used', function (t) {
 
   t.end()
 })
+*/

test/port-libuv-fix-test.js

@@ -28,7 +28,7 @@ test('test callback-less, 1-arg, repair() throws', function (t) {
 test('test repair non-existent directory returns error', function (t) {
   leveldown.repair('/1/2/3/4', function (err) {
     if (process.platform !== 'win32')
-      t.ok(/no such file or directory/i.test(err), 'error on callback')
+      t.ok(/^Error: NotFound:/i.test(err), 'error on callback')
     else
       t.ok(/IO error/i.test(err), 'error on callback')
     t.end()
@@ -41,11 +41,11 @@ makeTest('test repair() compacts', function (db, t, done, location) {
     t.notOk(err, 'no error')
     var files = fs.readdirSync(location)
     t.ok(files.some(function (f) { return (/\.log$/).test(f) }), 'directory contains log file(s)')
-    t.notOk(files.some(function (f) { return (/\.ldb$/).test(f) }), 'directory does not contain ldb file(s)')
+    t.notOk(files.some(function (f) { return (/\.sst$/).test(f) }), 'directory does not contain sst file(s)')
     leveldown.repair(location, function () {
       files = fs.readdirSync(location)
       t.notOk(files.some(function (f) { return (/\.log$/).test(f) }), 'directory does not contain log file(s)')
-      t.ok(files.some(function (f) { return (/\.ldb$/).test(f) }), 'directory contains ldb file(s)')
+      t.ok(files.some(function (f) { return (/\.sst$/).test(f) }), 'directory contains sst file(s)')
       done(false)
     })
   })