[Pkg-javascript-commits] [node-leveldown] 491/492: update rocksdb, nan at 0.6.0
Andrew Kelley
andrewrk-guest at moszumanska.debian.org
Sun Jul 6 17:14:40 UTC 2014
This is an automated email from the git hooks/post-receive script.
andrewrk-guest pushed a commit to annotated tag rocksdb-0.10.1
in repository node-leveldown.
commit dde38cf3b1c6bb194d309192b6d69a9b07445c2b
Author: Rod Vagg <rod at vagg.org>
Date: Thu Nov 21 15:50:01 2013 +1100
update rocksdb, nan at 0.6.0
---
.../db/table_properties_collector.cc | 164 +++++++++++++
.../db/table_properties_collector.h | 76 ++++++
.../db/table_properties_collector_test.cc | 266 +++++++++++++++++++++
.../include/rocksdb/table_properties.h | 90 +++++++
deps/leveldb/leveldb-rocksdb/util/build_version.cc | 9 +-
deps/leveldb/leveldb.gyp | 3 +-
package.json | 90 +++----
7 files changed, 646 insertions(+), 52 deletions(-)
diff --git a/deps/leveldb/leveldb-rocksdb/db/table_properties_collector.cc b/deps/leveldb/leveldb-rocksdb/db/table_properties_collector.cc
new file mode 100644
index 0000000..d0cd152
--- /dev/null
+++ b/deps/leveldb/leveldb-rocksdb/db/table_properties_collector.cc
@@ -0,0 +1,164 @@
+// Copyright (c) 2013, Facebook, Inc. All rights reserved.
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree. An additional grant
+// of patent rights can be found in the PATENTS file in the same directory.
+
+#include "db/table_properties_collector.h"
+
+#include "db/dbformat.h"
+#include "util/coding.h"
+
+namespace rocksdb {
+
+namespace {
+ void AppendProperty(
+ std::string& props,
+ const std::string& key,
+ const std::string& value,
+ const std::string& prop_delim,
+ const std::string& kv_delim) {
+ props.append(key);
+ props.append(kv_delim);
+ props.append(value);
+ props.append(prop_delim);
+ }
+
+ template <class TValue>
+ void AppendProperty(
+ std::string& props,
+ const std::string& key,
+ const TValue& value,
+ const std::string& prop_delim,
+ const std::string& kv_delim) {
+ AppendProperty(
+ props, key, std::to_string(value), prop_delim, kv_delim
+ );
+ }
+}
+
+std::string TableProperties::ToString(
+ const std::string& prop_delim,
+ const std::string& kv_delim) const {
+ std::string result;
+ result.reserve(1024);
+
+ // Basic Info
+ AppendProperty(
+ result, "# data blocks", num_data_blocks, prop_delim, kv_delim
+ );
+ AppendProperty(result, "# entries", num_entries, prop_delim, kv_delim);
+
+ AppendProperty(result, "raw key size", raw_key_size, prop_delim, kv_delim);
+ AppendProperty(
+ result,
+ "raw average key size",
+ num_entries != 0 ? 1.0 * raw_key_size / num_entries : 0.0,
+ prop_delim,
+ kv_delim
+ );
+ AppendProperty(
+ result, "raw value size", raw_value_size, prop_delim, kv_delim
+ );
+ AppendProperty(
+ result,
+ "raw average value size",
+ num_entries != 0 ? 1.0 * raw_value_size / num_entries : 0.0,
+ prop_delim,
+ kv_delim
+ );
+
+ AppendProperty(result, "data block size", data_size, prop_delim, kv_delim);
+ AppendProperty(result, "index block size", index_size, prop_delim, kv_delim);
+ AppendProperty(
+ result, "filter block size", filter_size, prop_delim, kv_delim
+ );
+ AppendProperty(
+ result,
+ "(estimated) table size=",
+ data_size + index_size + filter_size,
+ prop_delim,
+ kv_delim
+ );
+
+ AppendProperty(
+ result,
+ "filter policy name",
+ filter_policy_name.empty() ? std::string("N/A") : filter_policy_name,
+ prop_delim,
+ kv_delim
+ );
+
+ return result;
+}
+
+Status InternalKeyPropertiesCollector::Add(
+ const Slice& key, const Slice& value) {
+ ParsedInternalKey ikey;
+ if (!ParseInternalKey(key, &ikey)) {
+ return Status::InvalidArgument("Invalid internal key");
+ }
+
+ if (ikey.type == ValueType::kTypeDeletion) {
+ ++deleted_keys_;
+ }
+
+ return Status::OK();
+}
+
+Status InternalKeyPropertiesCollector::Finish(
+ TableProperties::UserCollectedProperties* properties) {
+ assert(properties);
+ assert(properties->find(
+ InternalKeyTablePropertiesNames::kDeletedKeys) == properties->end());
+ std::string val;
+
+ PutVarint64(&val, deleted_keys_);
+ properties->insert({ InternalKeyTablePropertiesNames::kDeletedKeys, val });
+
+ return Status::OK();
+}
+
+TableProperties::UserCollectedProperties
+InternalKeyPropertiesCollector::GetReadableProperties() const {
+ return {
+ { "kDeletedKeys", std::to_string(deleted_keys_) }
+ };
+}
+
+
+Status UserKeyTablePropertiesCollector::Add(
+ const Slice& key, const Slice& value) {
+ ParsedInternalKey ikey;
+ if (!ParseInternalKey(key, &ikey)) {
+ return Status::InvalidArgument("Invalid internal key");
+ }
+
+ return collector_->Add(ikey.user_key, value);
+}
+
+Status UserKeyTablePropertiesCollector::Finish(
+ TableProperties::UserCollectedProperties* properties) {
+ return collector_->Finish(properties);
+}
+
+TableProperties::UserCollectedProperties
+UserKeyTablePropertiesCollector::GetReadableProperties() const {
+ return collector_->GetReadableProperties();
+}
+
+
+const std::string InternalKeyTablePropertiesNames::kDeletedKeys
+ = "rocksdb.deleted.keys";
+
+uint64_t GetDeletedKeys(
+ const TableProperties::UserCollectedProperties& props) {
+ auto pos = props.find(InternalKeyTablePropertiesNames::kDeletedKeys);
+ if (pos == props.end()) {
+ return 0;
+ }
+ Slice raw = pos->second;
+ uint64_t val = 0;
+ return GetVarint64(&raw, &val) ? val : 0;
+}
+
+} // namespace rocksdb
diff --git a/deps/leveldb/leveldb-rocksdb/db/table_properties_collector.h b/deps/leveldb/leveldb-rocksdb/db/table_properties_collector.h
new file mode 100644
index 0000000..533130d
--- /dev/null
+++ b/deps/leveldb/leveldb-rocksdb/db/table_properties_collector.h
@@ -0,0 +1,76 @@
+// Copyright (c) 2013, Facebook, Inc. All rights reserved.
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree. An additional grant
+// of patent rights can be found in the PATENTS file in the same directory.
+//
+// This file defines a collection of statistics collectors.
+#pragma once
+
+#include "rocksdb/table_properties.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace rocksdb {
+
+struct InternalKeyTablePropertiesNames {
+ static const std::string kDeletedKeys;
+};
+
+// Collecting the statistics for internal keys. Visible only by internal
+// rocksdb modules.
+class InternalKeyPropertiesCollector : public TablePropertiesCollector {
+ public:
+ virtual Status Add(const Slice& key, const Slice& value) override;
+
+ virtual Status Finish(
+ TableProperties::UserCollectedProperties* properties) override;
+
+ virtual const char* Name() const override {
+ return "InternalKeyPropertiesCollector";
+ }
+
+ TableProperties::UserCollectedProperties
+ GetReadableProperties() const override;
+
+ private:
+ uint64_t deleted_keys_ = 0;
+};
+
+// When rocksdb creates a new table, it will encode all "user keys" into
+// "internal keys", which contains meta information of a given entry.
+//
+// This class extracts user key from the encoded internal key when Add() is
+// invoked.
+class UserKeyTablePropertiesCollector : public TablePropertiesCollector {
+ public:
+ explicit UserKeyTablePropertiesCollector(
+ TablePropertiesCollector* collector) :
+ UserKeyTablePropertiesCollector(
+ std::shared_ptr<TablePropertiesCollector>(collector)
+ ) {
+ }
+
+ explicit UserKeyTablePropertiesCollector(
+ std::shared_ptr<TablePropertiesCollector> collector) :
+ collector_(collector) {
+ }
+
+ virtual ~UserKeyTablePropertiesCollector() { }
+
+ virtual Status Add(const Slice& key, const Slice& value) override;
+
+ virtual Status Finish(
+ TableProperties::UserCollectedProperties* properties) override;
+
+ virtual const char* Name() const override { return collector_->Name(); }
+
+ TableProperties::UserCollectedProperties
+ GetReadableProperties() const override;
+
+ protected:
+ std::shared_ptr<TablePropertiesCollector> collector_;
+};
+
+} // namespace rocksdb
diff --git a/deps/leveldb/leveldb-rocksdb/db/table_properties_collector_test.cc b/deps/leveldb/leveldb-rocksdb/db/table_properties_collector_test.cc
new file mode 100644
index 0000000..6f405b2
--- /dev/null
+++ b/deps/leveldb/leveldb-rocksdb/db/table_properties_collector_test.cc
@@ -0,0 +1,266 @@
+// Copyright (c) 2013, Facebook, Inc. All rights reserved.
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree. An additional grant
+// of patent rights can be found in the PATENTS file in the same directory.
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "db/dbformat.h"
+#include "db/db_impl.h"
+#include "db/table_properties_collector.h"
+#include "rocksdb/table_properties.h"
+#include "rocksdb/table.h"
+#include "table/block_based_table_factory.h"
+#include "util/coding.h"
+#include "util/testharness.h"
+#include "util/testutil.h"
+
+namespace rocksdb {
+
+class TablePropertiesTest {
+ private:
+ unique_ptr<TableReader> table_reader_;
+};
+
+// TODO(kailiu) the following classes should be moved to some more general
+// places, so that other tests can also make use of them.
+// `FakeWritableFile` and `FakeRandomeAccessFile` bypass the real file system
+// and therefore enable us to quickly setup the tests.
+class FakeWritableFile : public WritableFile {
+ public:
+ ~FakeWritableFile() { }
+
+ const std::string& contents() const { return contents_; }
+
+ virtual Status Close() { return Status::OK(); }
+ virtual Status Flush() { return Status::OK(); }
+ virtual Status Sync() { return Status::OK(); }
+
+ virtual Status Append(const Slice& data) {
+ contents_.append(data.data(), data.size());
+ return Status::OK();
+ }
+
+ private:
+ std::string contents_;
+};
+
+
+class FakeRandomeAccessFile : public RandomAccessFile {
+ public:
+ explicit FakeRandomeAccessFile(const Slice& contents)
+ : contents_(contents.data(), contents.size()) {
+ }
+
+ virtual ~FakeRandomeAccessFile() { }
+
+ uint64_t Size() const { return contents_.size(); }
+
+ virtual Status Read(uint64_t offset, size_t n, Slice* result,
+ char* scratch) const {
+ if (offset > contents_.size()) {
+ return Status::InvalidArgument("invalid Read offset");
+ }
+ if (offset + n > contents_.size()) {
+ n = contents_.size() - offset;
+ }
+ memcpy(scratch, &contents_[offset], n);
+ *result = Slice(scratch, n);
+ return Status::OK();
+ }
+
+ private:
+ std::string contents_;
+};
+
+
+class DumbLogger : public Logger {
+ public:
+ virtual void Logv(const char* format, va_list ap) { }
+ virtual size_t GetLogFileSize() const { return 0; }
+};
+
+// Utilities test functions
+void MakeBuilder(
+ const Options& options,
+ std::unique_ptr<FakeWritableFile>* writable,
+ std::unique_ptr<TableBuilder>* builder) {
+ writable->reset(new FakeWritableFile);
+ builder->reset(
+ options.table_factory->GetTableBuilder(options, writable->get(),
+ options.compression));
+}
+
+void OpenTable(
+ const Options& options,
+ const std::string& contents,
+ std::unique_ptr<TableReader>* table_reader) {
+
+ std::unique_ptr<RandomAccessFile> file(new FakeRandomeAccessFile(contents));
+ auto s = options.table_factory->GetTableReader(
+ options,
+ EnvOptions(),
+ std::move(file),
+ contents.size(),
+ table_reader
+ );
+ ASSERT_OK(s);
+}
+
+// Collects keys that starts with "A" in a table.
+class RegularKeysStartWithA: public TablePropertiesCollector {
+ public:
+ const char* Name() const { return "RegularKeysStartWithA"; }
+
+ Status Finish(TableProperties::UserCollectedProperties* properties) {
+ std::string encoded;
+ PutVarint32(&encoded, count_);
+ *properties = TableProperties::UserCollectedProperties {
+ { "TablePropertiesTest", "Rocksdb" },
+ { "Count", encoded }
+ };
+ return Status::OK();
+ }
+
+ Status Add(const Slice& user_key, const Slice& value) {
+ // simply asssume all user keys are not empty.
+ if (user_key.data()[0] == 'A') {
+ ++count_;
+ }
+ return Status::OK();
+ }
+
+ virtual TableProperties::UserCollectedProperties
+ GetReadableProperties() const {
+ return {};
+ }
+
+
+ private:
+ uint32_t count_ = 0;
+};
+
+TEST(TablePropertiesTest, CustomizedTablePropertiesCollector) {
+ Options options;
+
+ // make sure the entries will be inserted with order.
+ std::map<std::string, std::string> kvs = {
+ {"About", "val5"}, // starts with 'A'
+ {"Abstract", "val2"}, // starts with 'A'
+ {"Around", "val7"}, // starts with 'A'
+ {"Beyond", "val3"},
+ {"Builder", "val1"},
+ {"Cancel", "val4"},
+ {"Find", "val6"},
+ };
+
+ // Test properties collectors with internal keys or regular keys
+ for (bool encode_as_internal : { true, false }) {
+ // -- Step 1: build table
+ auto collector = new RegularKeysStartWithA();
+ if (encode_as_internal) {
+ options.table_properties_collectors = {
+ std::make_shared<UserKeyTablePropertiesCollector>(collector)
+ };
+ } else {
+ options.table_properties_collectors.resize(1);
+ options.table_properties_collectors[0].reset(collector);
+ }
+ std::unique_ptr<TableBuilder> builder;
+ std::unique_ptr<FakeWritableFile> writable;
+ MakeBuilder(options, &writable, &builder);
+
+ for (const auto& kv : kvs) {
+ if (encode_as_internal) {
+ InternalKey ikey(kv.first, 0, ValueType::kTypeValue);
+ builder->Add(ikey.Encode(), kv.second);
+ } else {
+ builder->Add(kv.first, kv.second);
+ }
+ }
+ ASSERT_OK(builder->Finish());
+
+ // -- Step 2: Open table
+ std::unique_ptr<TableReader> table_reader;
+ OpenTable(options, writable->contents(), &table_reader);
+ const auto& properties =
+ table_reader->GetTableProperties().user_collected_properties;
+
+ ASSERT_EQ("Rocksdb", properties.at("TablePropertiesTest"));
+
+ uint32_t starts_with_A = 0;
+ Slice key(properties.at("Count"));
+ ASSERT_TRUE(GetVarint32(&key, &starts_with_A));
+ ASSERT_EQ(3u, starts_with_A);
+ }
+}
+
+TEST(TablePropertiesTest, InternalKeyPropertiesCollector) {
+ InternalKey keys[] = {
+ InternalKey("A", 0, ValueType::kTypeValue),
+ InternalKey("B", 0, ValueType::kTypeValue),
+ InternalKey("C", 0, ValueType::kTypeValue),
+ InternalKey("W", 0, ValueType::kTypeDeletion),
+ InternalKey("X", 0, ValueType::kTypeDeletion),
+ InternalKey("Y", 0, ValueType::kTypeDeletion),
+ InternalKey("Z", 0, ValueType::kTypeDeletion),
+ };
+
+ for (bool sanitized : { false, true }) {
+ std::unique_ptr<TableBuilder> builder;
+ std::unique_ptr<FakeWritableFile> writable;
+ Options options;
+ if (sanitized) {
+ options.table_properties_collectors = {
+ std::make_shared<RegularKeysStartWithA>()
+ };
+ // with sanitization, even regular properties collector will be able to
+ // handle internal keys.
+ auto comparator = options.comparator;
+ // HACK: Set options.info_log to avoid writing log in
+ // SanitizeOptions().
+ options.info_log = std::make_shared<DumbLogger>();
+ options = SanitizeOptions(
+ "db", // just a place holder
+ nullptr, // with skip internal key comparator
+ nullptr, // don't care filter policy
+ options
+ );
+ options.comparator = comparator;
+ } else {
+ options.table_properties_collectors = {
+ std::make_shared<InternalKeyPropertiesCollector>()
+ };
+ }
+
+ MakeBuilder(options, &writable, &builder);
+ for (const auto& k : keys) {
+ builder->Add(k.Encode(), "val");
+ }
+
+ ASSERT_OK(builder->Finish());
+
+ std::unique_ptr<TableReader> table_reader;
+ OpenTable(options, writable->contents(), &table_reader);
+ const auto& properties =
+ table_reader->GetTableProperties().user_collected_properties;
+
+ uint64_t deleted = GetDeletedKeys(properties);
+ ASSERT_EQ(4u, deleted);
+
+ if (sanitized) {
+ uint32_t starts_with_A = 0;
+ Slice key(properties.at("Count"));
+ ASSERT_TRUE(GetVarint32(&key, &starts_with_A));
+ ASSERT_EQ(1u, starts_with_A);
+ }
+ }
+}
+
+} // namespace rocksdb
+
+int main(int argc, char** argv) {
+ return rocksdb::test::RunAllTests();
+}
diff --git a/deps/leveldb/leveldb-rocksdb/include/rocksdb/table_properties.h b/deps/leveldb/leveldb-rocksdb/include/rocksdb/table_properties.h
new file mode 100644
index 0000000..8824ca1
--- /dev/null
+++ b/deps/leveldb/leveldb-rocksdb/include/rocksdb/table_properties.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2013, Facebook, Inc. All rights reserved.
+// This source code is licensed under the BSD-style license found in the
+// LICENSE file in the root directory of this source tree. An additional grant
+// of patent rights can be found in the PATENTS file in the same directory.
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+#include "rocksdb/status.h"
+
+namespace rocksdb {
+
+// TableProperties contains a bunch of read-only properties of its associated
+// table.
+struct TableProperties {
+ public:
+ // Other than basic table properties, each table may also have the user
+ // collected properties.
+ // The value of the user-collected properties are encoded as raw bytes --
+ // users have to interprete these values by themselves.
+ typedef
+ std::unordered_map<std::string, std::string>
+ UserCollectedProperties;
+
+ // the total size of all data blocks.
+ uint64_t data_size = 0;
+ // the size of index block.
+ uint64_t index_size = 0;
+ // the size of filter block.
+ uint64_t filter_size = 0;
+ // total raw key size
+ uint64_t raw_key_size = 0;
+ // total raw value size
+ uint64_t raw_value_size = 0;
+ // the number of blocks in this table
+ uint64_t num_data_blocks = 0;
+ // the number of entries in this table
+ uint64_t num_entries = 0;
+
+ // The name of the filter policy used in this table.
+ // If no filter policy is used, `filter_policy_name` will be an empty string.
+ std::string filter_policy_name;
+
+ // user collected properties
+ UserCollectedProperties user_collected_properties;
+
+ // convert this object to a human readable form
+ // @prop_delim: delimiter for each property.
+ std::string ToString(
+ const std::string& prop_delim = "; ",
+ const std::string& kv_delim = "=") const;
+};
+
+// `TablePropertiesCollector` provides the mechanism for users to collect
+// their own interested properties. This class is essentially a collection
+// of callback functions that will be invoked during table building.
+class TablePropertiesCollector {
+ public:
+ virtual ~TablePropertiesCollector() { }
+
+ // Add() will be called when a new key/value pair is inserted into the table.
+ // @params key the original key that is inserted into the table.
+ // @params value the original value that is inserted into the table.
+ virtual Status Add(const Slice& key, const Slice& value) = 0;
+
+ // Finish() will be called when a table has already been built and is ready
+ // for writing the properties block.
+ // @params properties User will add their collected statistics to
+ // `properties`.
+ virtual Status Finish(
+ TableProperties::UserCollectedProperties* properties) = 0;
+
+ // The name of the properties collector can be used for debugging purpose.
+ virtual const char* Name() const = 0;
+
+ // Return the human-readable properties, where the key is property name and
+ // the value is the human-readable form of value.
+ virtual TableProperties::UserCollectedProperties
+ GetReadableProperties() const = 0;
+};
+
+// Extra properties
+// Below is a list of non-basic properties that are collected by database
+// itself. Especially some properties regarding to the internal keys (which
+// is unknown to `table`).
+extern uint64_t GetDeletedKeys(
+ const TableProperties::UserCollectedProperties& props);
+
+} // namespace rocksdb
diff --git a/deps/leveldb/leveldb-rocksdb/util/build_version.cc b/deps/leveldb/leveldb-rocksdb/util/build_version.cc
index e7c5271..9f67b4e 100644
--- a/deps/leveldb/leveldb-rocksdb/util/build_version.cc
+++ b/deps/leveldb/leveldb-rocksdb/util/build_version.cc
@@ -1,11 +1,6 @@
#include "build_version.h"
-<<<<<<< HEAD
-const char* rocksdb_build_git_sha = "rocksdb_build_git_sha:5c24e7e3091105d34a654117a2cb6a845dc644d7";
-const char* rocksdb_build_git_datetime = "rocksdb_build_git_datetime:Tue 19 Nov 2013 14:09:46 EST";
-=======
-const char* rocksdb_build_git_sha = "rocksdb_build_git_sha:a0ce3fd00a1ae35bcbb9edc603b7398d83a8eb23";
-const char* rocksdb_build_git_datetime = "rocksdb_build_git_datetime:Sat Nov 16 21:47:00 EST 2013";
->>>>>>> added rocksdb source
+const char* rocksdb_build_git_sha = "rocksdb_build_git_sha:56589ab81f6827ff7402e31b24a6d548f29a524f";
+const char* rocksdb_build_git_datetime = "rocksdb_build_git_datetime:Thu Nov 21 15:45:16 EST 2013";
const char* rocksdb_build_compile_date = __DATE__;
const char* rocksdb_build_compile_time = __TIME__;
diff --git a/deps/leveldb/leveldb.gyp b/deps/leveldb/leveldb.gyp
index b54ce89..23f605b 100644
--- a/deps/leveldb/leveldb.gyp
+++ b/deps/leveldb/leveldb.gyp
@@ -154,7 +154,6 @@
, 'leveldb-<(ldbversion)/db/log_writer.cc'
, 'leveldb-<(ldbversion)/db/dbformat.cc'
, 'leveldb-<(ldbversion)/db/write_batch.cc'
- , 'leveldb-<(ldbversion)/db/table_stats_collector.cc'
, 'leveldb-<(ldbversion)/db/memtablelist.cc'
, 'leveldb-<(ldbversion)/db/db_impl.cc'
, 'leveldb-<(ldbversion)/db/memtable.cc'
@@ -166,6 +165,7 @@
, 'leveldb-<(ldbversion)/db/filename.cc'
, 'leveldb-<(ldbversion)/db/db_iter.cc'
, 'leveldb-<(ldbversion)/db/transaction_log_impl.cc'
+ , 'leveldb-<(ldbversion)/db/table_properties_collector.cc'
, 'leveldb-<(ldbversion)/helpers/memenv/memenv.cc'
, 'leveldb-<(ldbversion)/port/stack_trace.cc'
, 'leveldb-<(ldbversion)/table/merger.cc'
@@ -188,7 +188,6 @@
, 'leveldb-<(ldbversion)/util/statistics.cc'
, 'leveldb-<(ldbversion)/util/histogram.cc'
, 'leveldb-<(ldbversion)/util/arena_impl.cc'
- , 'leveldb-<(ldbversion)/util/ldb_tool.cc'
, 'leveldb-<(ldbversion)/util/coding.cc'
, 'leveldb-<(ldbversion)/util/perf_context.cc'
, 'leveldb-<(ldbversion)/util/hash.cc'
diff --git a/package.json b/package.json
index 0fddb57..d0f0a1a 100644
--- a/package.json
+++ b/package.json
@@ -1,45 +1,49 @@
{
- "name" : "rocksdb"
- , "description" : "A Node.js RocksDB binding, LevelDOWN-compatible (alpha release)"
- , "version" : "0.10.0"
- , "contributors" : [
- "Rod Vagg <r at va.gg> (https://github.com/rvagg)"
- , "John Chesley <john at chesl.es> (https://github.com/chesles/)"
- , "Jake Verbaten <raynos2 at gmail.com> (https://github.com/raynos)"
- , "Dominic Tarr <dominic.tarr at gmail.com> (https://github.com/dominictarr)"
- , "Max Ogden <max at maxogden.com> (https://github.com/maxogden)"
- , "Lars-Magnus Skog <lars.magnus.skog at gmail.com> (https://github.com/ralphtheninja)"
- , "David Björklund <david.bjorklund at gmail.com> (https://github.com/kesla)"
- , "Julian Gruber <julian at juliangruber.com> (https://github.com/juliangruber)"
- , "Paolo Fragomeni <paolo at async.ly> (https://github.com/hij1nx)"
- , "Anton Whalley <anton.whalley at nearform.com> (https://github.com/No9)"
- , "Matteo Collina <matteo.collina at gmail.com> (https://github.com/mcollina)"
- , "Pedro Teixeira <pedro.teixeira at gmail.com> (https://github.com/pgte)"
- , "James Halliday <mail at substack.net> (https://github.com/substack)"
- ]
- , "repository" : {
- "type" : "git"
- , "url" : "https://github.com/rvagg/node-leveldown.git"
- }
- , "homepage" : "https://github.com/rvagg/node-leveldown"
- , "keywords": [ "leveldb", "level", "rocksdb" ]
- , "main" : "index.js"
- , "dependencies" : {
- "bindings" : "~1.1.1"
- , "nan" : "~0.5.2"
- }
- , "devDependencies" : {
- "tap" : "~0.4.1"
- , "rimraf" : "~2.1.4"
- , "mkfiletree" : "~0.0.0"
- , "readfiletree" : "~0.0.0"
- , "abstract-leveldown" : "~0.11.1"
- , "monotonic-timestamp" : "~0.0.8"
- , "du" : "~0.0.1"
- }
- , "scripts" : {
- "test" : "tap test/*-test.js --stderr"
- }
- , "license" : "MIT"
- , "gypfile" : true
+ "name": "rocksdb",
+ "description": "A Node.js RocksDB binding, LevelDOWN-compatible (alpha release)",
+ "version": "0.10.0",
+ "contributors": [
+ "Rod Vagg <r at va.gg> (https://github.com/rvagg)",
+ "John Chesley <john at chesl.es> (https://github.com/chesles/)",
+ "Jake Verbaten <raynos2 at gmail.com> (https://github.com/raynos)",
+ "Dominic Tarr <dominic.tarr at gmail.com> (https://github.com/dominictarr)",
+ "Max Ogden <max at maxogden.com> (https://github.com/maxogden)",
+ "Lars-Magnus Skog <lars.magnus.skog at gmail.com> (https://github.com/ralphtheninja)",
+ "David Björklund <david.bjorklund at gmail.com> (https://github.com/kesla)",
+ "Julian Gruber <julian at juliangruber.com> (https://github.com/juliangruber)",
+ "Paolo Fragomeni <paolo at async.ly> (https://github.com/hij1nx)",
+ "Anton Whalley <anton.whalley at nearform.com> (https://github.com/No9)",
+ "Matteo Collina <matteo.collina at gmail.com> (https://github.com/mcollina)",
+ "Pedro Teixeira <pedro.teixeira at gmail.com> (https://github.com/pgte)",
+ "James Halliday <mail at substack.net> (https://github.com/substack)"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/rvagg/node-leveldown.git"
+ },
+ "homepage": "https://github.com/rvagg/node-leveldown",
+ "keywords": [
+ "leveldb",
+ "level",
+ "rocksdb"
+ ],
+ "main": "index.js",
+ "dependencies": {
+ "bindings": "~1.1.1",
+ "nan": "~0.6.0"
+ },
+ "devDependencies": {
+ "tap": "~0.4.1",
+ "rimraf": "~2.1.4",
+ "mkfiletree": "~0.0.0",
+ "readfiletree": "~0.0.0",
+ "abstract-leveldown": "~0.11.1",
+ "monotonic-timestamp": "~0.0.8",
+ "du": "~0.0.1"
+ },
+ "scripts": {
+ "test": "tap test/*-test.js --stderr"
+ },
+ "license": "MIT",
+ "gypfile": true
}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-javascript/node-leveldown.git
More information about the Pkg-javascript-commits
mailing list