Merge remote-tracking branch 'upstream/master' into reference

.github/ISSUE_TEMPLATE/config.yml

+blank_issues_enabled: false
+contact_links:
+ - name: Getting Help on IPFS
+   url: https://ipfs.io/help
+   about: All information about how and where to get help on IPFS.
+ - name: IPFS Official Forum
+   url: https://discuss.ipfs.io
+   about: Please post general questions, support requests, and discussions here.

.github/ISSUE_TEMPLATE/open_an_issue.md

+---
+name: Open an issue
+about: Only for actionable issues relevant to this repository.
+title: ''
+labels: need/triage
+assignees: ''
+
+---
+<!--
+Hello! To ensure this issue is correctly addressed as soon as possible by the IPFS team, please try to make sure:
+
+- This issue is relevant to this repository's topic or codebase.
+
+- A clear description is provided. It should includes as much relevant information as possible and clear scope for the issue to be actionable.
+
+FOR GENERAL DISCUSSION, HELP OR QUESTIONS, please see the options at https://ipfs.io/help or head directly to https://discuss.ipfs.io.
+
+(you can delete this section after reading)
+-->

.github/config.yml

+# Configuration for welcome - https://github.com/behaviorbot/welcome
+
+# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome
+# Comment to be posted to on first time issues
+newIssueWelcomeComment: >
+  Thank you for submitting your first issue to this repository! A maintainer
+  will be here shortly to triage and review.
+
+  In the meantime, please double-check that you have provided all the
+  necessary information to make this process easy! Any information that can
+  help save additional round trips is useful! We currently aim to give
+  initial feedback within **two business days**. If this does not happen, feel
+  free to leave a comment.
+
+  Please keep an eye on how this issue will be labeled, as labels give an
+  overview of priorities, assignments and additional actions requested by the
+  maintainers:
+
+    - "Priority" labels will show how urgent this is for the team.
+    - "Status" labels will show if this is ready to be worked on, blocked, or in progress.
+    - "Need" labels will indicate if additional input or analysis is required.
+
+  Finally, remember to use https://discuss.ipfs.io if you just need general
+  support.
+
+# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
+# Comment to be posted to on PRs from first time contributors in your repository
+newPRWelcomeComment: >
+  Thank you for submitting this PR!
+
+  A maintainer will be here shortly to review it.
+
+  We are super grateful, but we are also overloaded! Help us by making sure
+  that:
+
+    * The context for this PR is clear, with relevant discussion, decisions
+      and stakeholders linked/mentioned.
+
+    * Your contribution itself is clear (code comments, self-review for the
+      rest) and in its best form. Follow the [code contribution
+      guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#code-contribution-guidelines)
+      if they apply.
+
+  Getting other community members to do a review would be great help too on
+  complex PRs (you can ask in the chats/forums). If you are unsure about
+  something, just leave us a comment.
+
+  Next steps:
+
+    * A maintainer will triage and assign priority to this PR, commenting on
+      any missing things and potentially assigning a reviewer for high
+      priority items.
+
+    * The PR gets reviews, discussed and approvals as needed.
+
+    * The PR is merged by maintainers when it has been approved and comments addressed.
+
+  We currently aim to provide initial feedback/triaging within **two business
+  days**. Please keep an eye on any labelling actions, as these will indicate
+  priorities and status of your contribution.
+
+  We are very grateful for your contribution!
+
+
+# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
+# Comment to be posted to on pull requests merged by a first time user
+# Currently disabled
+#firstPRMergeComment: ""

.gitignore

+*.swp

.gx/lastpubver

+1.3.0: QmbgYmpUkuCDnXi4hci3Jt797iVXbpuBKRTCqGz57h48Sk

.travis.yml

+os:
+  - linux
+
+language: go
+
+go:
+  - 1.12.x
+
+env:
+  global:
+    - GOTFLAGS="-race -cpu=5"
+  matrix:
+    - BUILD_DEPTYPE=gomod
+
+
+# disable travis install
+install:
+  - true
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+
+cache:
+  directories:
+    - $GOPATH/pkg/mod
+    - $HOME/.cache/go-build
+
+notifications:
+  email: false

LICENSE

+The MIT License
+
+Copyright (c) 2016 Jeromy Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

 # go-ds-leveldb
 
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/)
+[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![GoDoc](https://godoc.org/github.com/ipfs/go-ds-leveldb?status.svg)](https://godoc.org/github.com/ipfs/go-ds-leveldb)
+[![Build Status](https://travis-ci.org/ipfs/go-ds-leveldb.svg?branch=master)](https://travis-ci.org/ipfs/go-ds-leveldb)
+
+> A go-datastore implementation using LevelDB
+
+`go-ds-leveldb` implements the [go-datastore](https://github.com/ipfs/go-datastore) interface using a LevelDB backend.
+
+## Lead Maintainer
+
+[Steven Allen](https://github.com/Stebalien)
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Contribute](#contribute)
+- [License](#license)
+
+## Install
+
+This module can be installed like a regular go module:
+
+```
+go get github.com/ipfs/go-ds-leveldb
+```
+
+It uses [Gx](https://github.com/whyrusleeping/gx) to manage dependencies. You can use `make deps` to rewrite imports to the gx-specified versions.
+
+## Usage
+
+```
+import "github.com/ipfs/go-ds-leveldb"
+```
+
+Check the [GoDoc documentation](https://godoc.org/github.com/ipfs/go-ds-leveldb)
+
+
+## Contribute
+
+PRs accepted.
+
+Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+MIT © Protocol Labs, Inc.

datastore.go

+package leveldb
+
+import (
+	"os"
+	"path/filepath"
+	"sync"
+
+	ds "github.com/ipfs/go-datastore"
+	dsq "github.com/ipfs/go-datastore/query"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/errors"
+	"github.com/syndtr/goleveldb/leveldb/iterator"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+type Datastore struct {
+	*accessor
+	DB   *leveldb.DB
+	path string
+}
+
+var _ ds.Datastore = (*Datastore)(nil)
+var _ ds.TxnDatastore = (*Datastore)(nil)
+
+// Options is an alias of syndtr/goleveldb/opt.Options which might be extended
+// in the future.
+type Options opt.Options
+
+// NewDatastore returns a new datastore backed by leveldb
+//
+// for path == "", an in memory backend will be chosen
+func NewDatastore(path string, opts *Options) (*Datastore, error) {
+	var nopts opt.Options
+	if opts != nil {
+		nopts = opt.Options(*opts)
+	}
+
+	var err error
+	var db *leveldb.DB
+
+	if path == "" {
+		db, err = leveldb.Open(storage.NewMemStorage(), &nopts)
+	} else {
+		db, err = leveldb.OpenFile(path, &nopts)
+		if errors.IsCorrupted(err) && !nopts.GetReadOnly() {
+			db, err = leveldb.RecoverFile(path, &nopts)
+		}
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	ds := Datastore{
+		accessor: &accessor{ldb: db, syncWrites: true, closeLk: new(sync.RWMutex)},
+		DB:       db,
+		path:     path,
+	}
+	return &ds, nil
+}
+
+// An extraction of the common interface between LevelDB Transactions and the DB itself.
+//
+// It allows to plug in either inside the `accessor`.
+type levelDbOps interface {
+	Put(key, value []byte, wo *opt.WriteOptions) error
+	Get(key []byte, ro *opt.ReadOptions) (value []byte, err error)
+	Has(key []byte, ro *opt.ReadOptions) (ret bool, err error)
+	Delete(key []byte, wo *opt.WriteOptions) error
+	NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Iterator
+}
+
+// Datastore operations using either the DB or a transaction as the backend.
+type accessor struct {
+	ldb        levelDbOps
+	syncWrites bool
+	closeLk    *sync.RWMutex
+}
+
+func (a *accessor) Put(key ds.Key, value []byte) (err error) {
+	a.closeLk.RLock()
+	defer a.closeLk.RUnlock()
+	return a.ldb.Put(key.Bytes(), value, &opt.WriteOptions{Sync: a.syncWrites})
+}
+
+func (a *accessor) Sync(prefix ds.Key) error {
+	return nil
+}
+
+func (a *accessor) Get(key ds.Key) (value []byte, err error) {
+	a.closeLk.RLock()
+	defer a.closeLk.RUnlock()
+	val, err := a.ldb.Get(key.Bytes(), nil)
+	if err != nil {
+		if err == leveldb.ErrNotFound {
+			return nil, ds.ErrNotFound
+		}
+		return nil, err
+	}
+	return val, nil
+}
+
+func (a *accessor) Has(key ds.Key) (exists bool, err error) {
+	a.closeLk.RLock()
+	defer a.closeLk.RUnlock()
+	return a.ldb.Has(key.Bytes(), nil)
+}
+
+func (a *accessor) GetSize(key ds.Key) (size int, err error) {
+	return ds.GetBackedSize(a, key)
+}
+
+func (a *accessor) Delete(key ds.Key) (err error) {
+	a.closeLk.RLock()
+	defer a.closeLk.RUnlock()
+	return a.ldb.Delete(key.Bytes(), &opt.WriteOptions{Sync: a.syncWrites})
+}
+
+func (a *accessor) Query(q dsq.Query) (dsq.Results, error) {
+	a.closeLk.RLock()
+	defer a.closeLk.RUnlock()
+	var rnge *util.Range
+
+	// make a copy of the query for the fallback naive query implementation.
+	// don't modify the original so res.Query() returns the correct results.
+	qNaive := q
+	prefix := ds.NewKey(q.Prefix).String()
+	if prefix != "/" {
+		rnge = util.BytesPrefix([]byte(prefix + "/"))
+		qNaive.Prefix = ""
+	}
+	i := a.ldb.NewIterator(rnge, nil)
+	next := i.Next
+	if len(q.Orders) > 0 {
+		switch q.Orders[0].(type) {
+		case dsq.OrderByKey, *dsq.OrderByKey:
+			qNaive.Orders = nil
+		case dsq.OrderByKeyDescending, *dsq.OrderByKeyDescending:
+			next = func() bool {
+				next = i.Prev
+				return i.Last()
+			}
+			qNaive.Orders = nil
+		default:
+		}
+	}
+	r := dsq.ResultsFromIterator(q, dsq.Iterator{
+		Next: func() (dsq.Result, bool) {
+			a.closeLk.RLock()
+			defer a.closeLk.RUnlock()
+			if !next() {
+				return dsq.Result{}, false
+			}
+			k := string(i.Key())
+			e := dsq.Entry{Key: k, Size: len(i.Value())}
+
+			if !q.KeysOnly {
+				buf := make([]byte, len(i.Value()))
+				copy(buf, i.Value())
+				e.Value = buf
+			}
+			return dsq.Result{Entry: e}, true
+		},
+		Close: func() error {
+			a.closeLk.RLock()
+			defer a.closeLk.RUnlock()
+			i.Release()
+			return nil
+		},
+	})
+	return dsq.NaiveQueryApply(qNaive, r), nil
+}
+
+// DiskUsage returns the current disk size used by this levelDB.
+// For in-mem datastores, it will return 0.
+func (d *Datastore) DiskUsage() (uint64, error) {
+	d.closeLk.RLock()
+	defer d.closeLk.RUnlock()
+	if d.path == "" { // in-mem
+		return 0, nil
+	}
+
+	var du uint64
+
+	err := filepath.Walk(d.path, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		du += uint64(info.Size())
+		return nil
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	return du, nil
+}
+
+// LevelDB needs to be closed.
+func (d *Datastore) Close() (err error) {
+	d.closeLk.Lock()
+	defer d.closeLk.Unlock()
+	return d.DB.Close()
+}
+
+type leveldbBatch struct {
+	b          *leveldb.Batch
+	db         *leveldb.DB
+	closeLk    *sync.RWMutex
+	syncWrites bool
+}
+
+func (d *Datastore) Batch() (ds.Batch, error) {
+	return &leveldbBatch{
+		b:          new(leveldb.Batch),
+		db:         d.DB,
+		closeLk:    d.closeLk,
+		syncWrites: d.syncWrites,
+	}, nil
+}
+
+func (b *leveldbBatch) Put(key ds.Key, value []byte) error {
+	b.b.Put(key.Bytes(), value)
+	return nil
+}
+
+func (b *leveldbBatch) Commit() error {
+	b.closeLk.RLock()
+	defer b.closeLk.RUnlock()
+	return b.db.Write(b.b, &opt.WriteOptions{Sync: b.syncWrites})
+}
+
+func (b *leveldbBatch) Delete(key ds.Key) error {
+	b.b.Delete(key.Bytes())
+	return nil
+}
+
+// A leveldb transaction embedding the accessor backed by the transaction.
+type transaction struct {
+	*accessor
+	tx *leveldb.Transaction
+}
+
+func (t *transaction) Commit() error {
+	t.closeLk.RLock()
+	defer t.closeLk.RUnlock()
+	return t.tx.Commit()
+}
+
+func (t *transaction) Discard() {
+	t.closeLk.RLock()
+	defer t.closeLk.RUnlock()
+	t.tx.Discard()
+}
+
+func (d *Datastore) NewTransaction(readOnly bool) (ds.Txn, error) {
+	d.closeLk.RLock()
+	defer d.closeLk.RUnlock()
+	tx, err := d.DB.OpenTransaction()
+	if err != nil {
+		return nil, err
+	}
+	accessor := &accessor{ldb: tx, syncWrites: false, closeLk: d.closeLk}
+	return &transaction{accessor, tx}, nil
+}

ds_test.go

+package leveldb
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"sort"
+	"testing"
+
+	ds "github.com/ipfs/go-datastore"
+	dsq "github.com/ipfs/go-datastore/query"
+	dstest "github.com/ipfs/go-datastore/test"
+)
+
+var testcases = map[string]string{
+	"/a":     "a",
+	"/a/b":   "ab",
+	"/a/b/c": "abc",
+	"/a/b/d": "a/b/d",
+	"/a/c":   "ac",
+	"/a/d":   "ad",
+	"/e":     "e",
+	"/f":     "f",
+}
+
+// returns datastore, and a function to call on exit.
+// (this garbage collects). So:
+//
+//  d, close := newDS(t)
+//  defer close()
+func newDS(t *testing.T) (*Datastore, func()) {
+	path, err := ioutil.TempDir("", "testing_leveldb_")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	d, err := NewDatastore(path, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d, func() {
+		os.RemoveAll(path)
+		d.Close()
+	}
+}
+
+// newDSMem returns an in-memory datastore.
+func newDSMem(t *testing.T) *Datastore {
+	d, err := NewDatastore("", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return d
+}
+
+func addTestCases(t *testing.T, d *Datastore, testcases map[string]string) {
+	for k, v := range testcases {
+		dsk := ds.NewKey(k)
+		if err := d.Put(dsk, []byte(v)); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	for k, v := range testcases {
+		dsk := ds.NewKey(k)
+		v2, err := d.Get(dsk)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(v2) != v {
+			t.Errorf("%s values differ: %s != %s", k, v, v2)
+		}
+	}
+
+}
+
+func testQuery(t *testing.T, d *Datastore) {
+	addTestCases(t, d, testcases)
+
+	rs, err := d.Query(dsq.Query{Prefix: "/a/"})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectMatches(t, []string{
+		"/a/b",
+		"/a/b/c",
+		"/a/b/d",
+		"/a/c",
+		"/a/d",
+	}, rs)
+
+	// test offset and limit
+
+	rs, err = d.Query(dsq.Query{Prefix: "/a/", Offset: 2, Limit: 2})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectMatches(t, []string{
+		"/a/b/d",
+		"/a/c",
+	}, rs)
+
+	// test order
+
+	rs, err = d.Query(dsq.Query{Orders: []dsq.Order{dsq.OrderByKey{}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	keys := make([]string, 0, len(testcases))
+	for k := range testcases {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	expectOrderedMatches(t, keys, rs)
+
+	rs, err = d.Query(dsq.Query{Orders: []dsq.Order{dsq.OrderByKeyDescending{}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// reverse
+	for i, j := 0, len(keys)-1; i < j; i, j = i+1, j-1 {
+		keys[i], keys[j] = keys[j], keys[i]
+	}
+
+	expectOrderedMatches(t, keys, rs)
+}
+
+func TestQuery(t *testing.T) {
+	d, close := newDS(t)
+	defer close()
+	testQuery(t, d)
+}
+func TestQueryMem(t *testing.T) {
+	d := newDSMem(t)
+	testQuery(t, d)
+}
+
+func TestQueryRespectsProcess(t *testing.T) {
+	d, close := newDS(t)
+	defer close()
+	addTestCases(t, d, testcases)
+}
+
+func TestCloseRace(t *testing.T) {
+	d, close := newDS(t)
+	for n := 0; n < 100; n++ {
+		d.Put(ds.NewKey(fmt.Sprintf("%d", n)), []byte(fmt.Sprintf("test%d", n)))
+	}
+
+	tx, _ := d.NewTransaction(false)
+	tx.Put(ds.NewKey("txnversion"), []byte("bump"))
+
+	closeCh := make(chan interface{})
+
+	go func() {
+		close()
+		closeCh <- nil
+	}()
+	for k := range testcases {
+		tx.Get(ds.NewKey(k))
+	}
+	tx.Commit()
+	<-closeCh
+}
+
+func TestCloseSafety(t *testing.T) {
+	d, close := newDS(t)
+	addTestCases(t, d, testcases)
+
+	tx, _ := d.NewTransaction(false)
+	err := tx.Put(ds.NewKey("test"), []byte("test"))
+	if err != nil {
+		t.Error("Failed to put in a txn.")
+	}
+	close()
+	err = tx.Commit()
+	if err == nil {
+		t.Error("committing after close should fail.")
+	}
+}
+
+func TestQueryRespectsProcessMem(t *testing.T) {
+	d := newDSMem(t)
+	addTestCases(t, d, testcases)
+}
+
+func expectMatches(t *testing.T, expect []string, actualR dsq.Results) {
+	t.Helper()
+	actual, err := actualR.Rest()
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(actual) != len(expect) {
+		t.Error("not enough", expect, actual)
+	}
+	for _, k := range expect {
+		found := false
+		for _, e := range actual {
+			if e.Key == k {
+				found = true
+			}
+		}
+		if !found {
+			t.Error(k, "not found")
+		}
+	}
+}
+
+func expectOrderedMatches(t *testing.T, expect []string, actualR dsq.Results) {
+	t.Helper()
+	actual, err := actualR.Rest()
+	if err != nil {
+		t.Error(err)
+	}
+
+	if len(actual) != len(expect) {
+		t.Error("not enough", expect, actual)
+	}
+	for i := range expect {
+		if expect[i] != actual[i].Key {
+			t.Errorf("expected %q, got %q", expect[i], actual[i].Key)
+		}
+	}
+}
+
+func testBatching(t *testing.T, d *Datastore) {
+	b, err := d.Batch()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for k, v := range testcases {
+		err := b.Put(ds.NewKey(k), []byte(v))
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	err = b.Commit()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for k, v := range testcases {
+		val, err := d.Get(ds.NewKey(k))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if v != string(val) {
+			t.Fatal("got wrong data!")
+		}
+	}
+}
+
+func TestBatching(t *testing.T) {
+	d, done := newDS(t)
+	defer done()
+	testBatching(t, d)
+}
+
+func TestBatchingMem(t *testing.T) {
+	d := newDSMem(t)
+	testBatching(t, d)
+}
+
+func TestDiskUsage(t *testing.T) {
+	d, done := newDS(t)
+	addTestCases(t, d, testcases)
+	du, err := d.DiskUsage()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if du == 0 {
+		t.Fatal("expected some disk usage")
+	}
+
+	k := ds.NewKey("more")
+	err = d.Put(k, []byte("value"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	du2, err := d.DiskUsage()
+	if du2 <= du {
+		t.Fatal("size should have increased")
+	}
+
+	done()
+
+	// This should fail
+	_, err = d.DiskUsage()
+	if err == nil {
+		t.Fatal("DiskUsage should fail when we cannot walk path")
+	}
+}
+
+func TestDiskUsageInMem(t *testing.T) {
+	d := newDSMem(t)
+	du, _ := d.DiskUsage()
+	if du != 0 {
+		t.Fatal("inmem dbs have 0 disk usage")
+	}
+}
+
+func TestTransactionCommit(t *testing.T) {
+	key := ds.NewKey("/test/key1")
+
+	d, done := newDS(t)
+	defer done()
+
+	txn, err := d.NewTransaction(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer txn.Discard()
+
+	if err := txn.Put(key, []byte("hello")); err != nil {
+		t.Fatal(err)
+	}
+	if val, err := d.Get(key); err != ds.ErrNotFound {
+		t.Fatalf("expected ErrNotFound, got err: %v, value: %v", err, val)
+	}
+	if err := txn.Commit(); err != nil {
+		t.Fatal(err)
+	}
+	if val, err := d.Get(key); err != nil || !bytes.Equal(val, []byte("hello")) {
+		t.Fatalf("expected entry present after commit, got err: %v, value: %v", err, val)
+	}
+}
+
+func TestTransactionDiscard(t *testing.T) {
+	key := ds.NewKey("/test/key1")
+
+	d, done := newDS(t)
+	defer done()
+
+	txn, err := d.NewTransaction(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer txn.Discard()
+
+	if err := txn.Put(key, []byte("hello")); err != nil {
+		t.Fatal(err)
+	}
+	if val, err := d.Get(key); err != ds.ErrNotFound {
+		t.Fatalf("expected ErrNotFound, got err: %v, value: %v", err, val)
+	}
+	if txn.Discard(); err != nil {
+		t.Fatal(err)
+	}
+	if val, err := d.Get(key); err != ds.ErrNotFound {
+		t.Fatalf("expected ErrNotFound, got err: %v, value: %v", err, val)
+	}
+}
+
+func TestTransactionManyOperations(t *testing.T) {
+	keys := []ds.Key{ds.NewKey("/test/key1"), ds.NewKey("/test/key2"), ds.NewKey("/test/key3"), ds.NewKey("/test/key4"), ds.NewKey("/test/key5")}
+
+	d, done := newDS(t)
+	defer done()
+
+	txn, err := d.NewTransaction(false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer txn.Discard()
+
+	// Insert all entries.
+	for i := 0; i < 5; i++ {
+		if err := txn.Put(keys[i], []byte(fmt.Sprintf("hello%d", i))); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// Remove the third entry.
+	if err := txn.Delete(keys[2]); err != nil {
+		t.Fatal(err)
+	}
+
+	// Check existences.
+	if has, err := txn.Has(keys[1]); err != nil || !has {
+		t.Fatalf("expected key[1] to be present, err: %v, has: %v", err, has)
+	}
+	if has, err := txn.Has(keys[2]); err != nil || has {
+		t.Fatalf("expected key[2] to be absent, err: %v, has: %v", err, has)
+	}
+
+	var res dsq.Results
+	if res, err = txn.Query(dsq.Query{Prefix: "/test"}); err != nil {
+		t.Fatalf("query failed, err: %v", err)
+	}
+	if entries, err := res.Rest(); err != nil || len(entries) != 4 {
+		t.Fatalf("query failed or contained unexpected number of entries, err: %v, results: %v", err, entries)
+	}
+
+	txn.Discard()
+}
+
+func TestSuite(t *testing.T) {
+	d := newDSMem(t)
+	defer d.Close()
+	dstest.SubtestAll(t, d)
+}

go.mod

+module github.com/ipfs/go-ds-leveldb
+
+require (
+	github.com/ipfs/go-datastore v0.4.1
+	github.com/syndtr/goleveldb v1.0.0
+)
+
+go 1.12

go.sum

+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/ipfs/go-datastore v0.4.1 h1:W4ZfzyhNi3xmuU5dQhjfuRn/wFuqEE1KnOmmQiOevEY=
+github.com/ipfs/go-datastore v0.4.1/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
+github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw=
+github.com/jbenet/goprocess v0.0.0-20160826012719-b497e2f366b8 h1:bspPhN+oKYFk5fcGNuQzp6IGzYQSenLEgH3s6jkXrWw=
+github.com/jbenet/goprocess v0.0.0-20160826012719-b497e2f366b8/go.mod h1:Ly/wlsjFq/qrU3Rar62tu1gASgGw6chQbSh/XgIIXCY=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
+github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=