From 4a568f09726c197cc9f2dad2f22ada618fc60c8a Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Wed, 25 Jul 2018 16:03:00 -0400 Subject: [PATCH 01/12] Implement new TxDatastore and Txn interfaces --- datastore.go | 182 +++++++++++++++++++++++++++------------------------ 1 file changed, 96 insertions(+), 86 deletions(-) diff --git a/datastore.go b/datastore.go index 3ad870f..1b71b45 100644 --- a/datastore.go +++ b/datastore.go @@ -18,6 +18,10 @@ type Datastore struct { gcDiscardRatio float64 } +type txn struct { + txn *badger.Txn +} + // Options are the badger datastore options, reexported here for convenience. type Options struct { gcDiscardRatio float64 @@ -68,24 +72,91 @@ func NewDatastore(path string, options *Options) (*Datastore, error) { }, nil } -func (d *Datastore) Put(key ds.Key, value []byte) error { - txn := d.DB.NewTransaction(true) - defer txn.Discard() +func (d *Datastore) NewTransaction(readOnly bool) ds.Txn { + return &txn{d.DB.NewTransaction(!readOnly)} +} + +func (d *Datastore) Put(key ds.Key, value interface{}) error { + txn := d.NewTransaction(false) + defer txn.Rollback() + + if err := txn.Put(key, value); err != nil { + return err + } + + txn.Commit() + return nil +} + +func (d *Datastore) Get(key ds.Key) (value interface{}, err error) { + txn := d.NewTransaction(true) + defer txn.Rollback() + + return txn.Get(key) +} - err := txn.Set(key.Bytes(), value) +func (d *Datastore) Has(key ds.Key) (bool, error) { + txn := d.NewTransaction(true) + defer txn.Rollback() + + return txn.Has(key) +} + +func (d *Datastore) Delete(key ds.Key) error { + txn := d.NewTransaction(false) + defer txn.Rollback() + + err := txn.Delete(key) if err != nil { return err } - //TODO: Setting callback may potentially make this faster - return txn.Commit(nil) + return txn.Commit() +} + +func (d *Datastore) Query(q dsq.Query) (dsq.Results, error) { + txn := d.NewTransaction(true) + defer txn.Rollback() + + return txn.Query(q) +} + +// DiskUsage implements the PersistentDatastore interface. +// It returns the sum of lsm and value log files sizes in bytes. +func (d *Datastore) DiskUsage() (uint64, error) { + lsm, vlog := d.DB.Size() + return uint64(lsm + vlog), nil } -func (d *Datastore) Get(key ds.Key) (value []byte, err error) { - txn := d.DB.NewTransaction(false) - defer txn.Discard() +func (d *Datastore) Close() error { + return d.DB.Close() +} + +func (d *Datastore) IsThreadSafe() {} + +func (d *Datastore) Batch() (ds.Batch, error) { + return d.NewTransaction(false), nil +} + +func (d *Datastore) CollectGarbage() error { + err := d.DB.RunValueLogGC(d.gcDiscardRatio) + if err == badger.ErrNoRewrite { + err = nil + } + return err +} + +func (t *txn) Put(key ds.Key, value interface{}) error { + bytes, ok := value.([]byte) + if !ok { + return ds.ErrInvalidType + } + + return t.txn.Set(key.Bytes(), bytes) +} - item, err := txn.Get(key.Bytes()) +func (t *txn) Get(key ds.Key) (interface{}, error) { + item, err := t.txn.Get(key.Bytes()) if err == badger.ErrKeyNotFound { err = ds.ErrNotFound } @@ -103,42 +174,28 @@ func (d *Datastore) Get(key ds.Key) (value []byte, err error) { return out, nil } -func (d *Datastore) Has(key ds.Key) (bool, error) { - txn := d.DB.NewTransaction(false) - defer txn.Discard() - _, err := txn.Get(key.Bytes()) - if err == badger.ErrKeyNotFound { - return false, nil - } - if err != nil { - return false, err - } +func (t *txn) Has(key ds.Key) (bool, error) { + _, err := t.txn.Get(key.Bytes()) - return true, nil -} - -func (d *Datastore) Delete(key ds.Key) error { - txn := d.DB.NewTransaction(true) - defer txn.Discard() - err := txn.Delete(key.Bytes()) - if err != nil { - return err + if err == nil { + return true, nil + } else if err == badger.ErrKeyNotFound { + return false, nil } - //TODO: callback may potentially make this faster - return txn.Commit(nil) + return false, err } -func (d *Datastore) Query(q dsq.Query) (dsq.Results, error) { - return d.QueryNew(q) +func (t *txn) Delete(key ds.Key) error { + return t.txn.Delete(key.Bytes()) } -func (d *Datastore) QueryNew(q dsq.Query) (dsq.Results, error) { +func (t *txn) Query(q dsq.Query) (dsq.Results, error) { prefix := []byte(q.Prefix) opt := badger.DefaultIteratorOptions opt.PrefetchValues = !q.KeysOnly - txn := d.DB.NewTransaction(false) + txn := t.txn it := txn.NewIterator(opt) it.Seek([]byte(q.Prefix)) @@ -151,7 +208,6 @@ func (d *Datastore) QueryNew(q dsq.Query) (dsq.Results, error) { qrb := dsq.NewResultBuilder(q) qrb.Process.Go(func(worker goprocess.Process) { - defer txn.Discard() defer it.Close() for sent := 0; it.ValidForPrefix(prefix); sent++ { @@ -204,56 +260,10 @@ func (d *Datastore) QueryNew(q dsq.Query) (dsq.Results, error) { return qr, nil } -// DiskUsage implements the PersistentDatastore interface. -// It returns the sum of lsm and value log files sizes in bytes. -func (d *Datastore) DiskUsage() (uint64, error) { - lsm, vlog := d.DB.Size() - return uint64(lsm + vlog), nil -} - -func (d *Datastore) Close() error { - return d.DB.Close() +func (t *txn) Commit() error { + return t.txn.Commit(nil) } -func (d *Datastore) IsThreadSafe() {} - -type badgerBatch struct { - db *badger.DB - txn *badger.Txn -} - -func (d *Datastore) Batch() (ds.Batch, error) { - return &badgerBatch{ - db: d.DB, - txn: d.DB.NewTransaction(true), - }, nil -} - -func (b *badgerBatch) Put(key ds.Key, value []byte) error { - err := b.txn.Set(key.Bytes(), value) - if err != nil { - b.txn.Discard() - } - return err -} - -func (b *badgerBatch) Delete(key ds.Key) error { - err := b.txn.Delete(key.Bytes()) - if err != nil { - b.txn.Discard() - } - return err -} - -func (b *badgerBatch) Commit() error { - //TODO: Setting callback may potentially make this faster - return b.txn.Commit(nil) -} - -func (d *Datastore) CollectGarbage() error { - err := d.DB.RunValueLogGC(d.gcDiscardRatio) - if err == badger.ErrNoRewrite { - err = nil - } - return err +func (t *txn) Rollback() { + t.txn.Discard() } From e31253fa3e9f505db5c345bb4a27d788aac4702e Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Wed, 25 Jul 2018 16:34:30 -0400 Subject: [PATCH 02/12] Report Put errors, add TTL support --- datastore.go | 44 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/datastore.go b/datastore.go index 1b71b45..e63c687 100644 --- a/datastore.go +++ b/datastore.go @@ -3,6 +3,7 @@ package badger import ( "fmt" "strings" + "time" osh "github.com/Kubuxu/go-os-helper" badger "github.com/dgraph-io/badger" @@ -84,8 +85,29 @@ func (d *Datastore) Put(key ds.Key, value interface{}) error { return err } - txn.Commit() - return nil + return txn.Commit() +} + +func (d *datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { + txn := d.NewTransaction(false).(*txn) + defer txn.Rollback() + + if err := txn.PutWithTTL(key, value, ttl); err != nil { + return err + } + + return txn.Commit() +} + +func (d *datastore) SetTTL(key ds.Key, ttl time.Duration) error { + txn := d.NewTransaction(false).(*txn) + defer txn.Rollback() + + if err := txn.SetTTL(key, ttl); err != nil { + return err + } + + return txn.Commit() } func (d *Datastore) Get(key ds.Key) (value interface{}, err error) { @@ -155,6 +177,24 @@ func (t *txn) Put(key ds.Key, value interface{}) error { return t.txn.Set(key.Bytes(), bytes) } +func (t *txn) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { + bytes, ok := value.([]byte) + if !ok { + return ds.ErrInvalidType + } + + return t.txn.SetWithTTL(key.Bytes(), bytes, ttl) +} + +func (t *txn) SetTTL(key ds.Key, ttl time.Duration) error { + data, err := t.Get(key) + if err != nil { + return err + } + + return t.PutWithTTL(key, data, ttl) +} + func (t *txn) Get(key ds.Key) (interface{}, error) { item, err := t.txn.Get(key.Bytes()) if err == badger.ErrKeyNotFound { From 631f3891f8af2d73c0cbc7eeb13eb894aa3796f7 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Thu, 26 Jul 2018 10:59:54 -0400 Subject: [PATCH 03/12] Add basic transactional tests --- ds_test.go | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) diff --git a/ds_test.go b/ds_test.go index 0eb400b..1528fe8 100644 --- a/ds_test.go +++ b/ds_test.go @@ -520,3 +520,99 @@ func TestDiskUsage(t *testing.T) { } d.Close() } + +func TestTxnRollback(t *testing.T) { + d, err := NewDatastore("/tmp/testing_badger_du", nil) + defer os.RemoveAll("/tmp/testing_badger_du") + if err != nil { + t.Fatal(err) + } + + txn := d.NewTransaction(false) + key := ds.NewKey("/test/thing") + if err := txn.Put(key, []byte{1, 2, 3}); err != nil { + t.Fatal(err) + } + txn.Rollback() + has, err := d.Has(key) + if err != nil { + t.Fatal(err) + } + if has { + t.Fatal("key written in aborted transaction still exists") + } + + d.Close() +} + +func TestTxnCommit(t *testing.T) { + d, err := NewDatastore("/tmp/testing_badger_du", nil) + defer os.RemoveAll("/tmp/testing_badger_du") + if err != nil { + t.Fatal(err) + } + + txn := d.NewTransaction(false) + key := ds.NewKey("/test/thing") + if err := txn.Put(key, []byte{1, 2, 3}); err != nil { + t.Fatal(err) + } + txn.Commit() + has, err := d.Has(key) + if err != nil { + t.Fatal(err) + } + if !has { + t.Fatal("key written in committed transaction does not exist") + } + + d.Close() +} + +func TestTxnBatch(t *testing.T) { + d, err := NewDatastore("/tmp/testing_badger_du", nil) + defer os.RemoveAll("/tmp/testing_badger_du") + if err != nil { + t.Fatal(err) + } + + txn := d.NewTransaction(false) + + data := make(map[ds.Key][]byte) + for i := 0; i < 10; i++ { + key := ds.NewKey(fmt.Sprintf("/test/%d", i)) + bytes := make([]byte, 16) + _, err := rand.Read(bytes) + if err != nil { + t.Fatal(err) + } + data[key] = bytes + + err = txn.Put(key, bytes) + if err != nil { + t.Fatal(err) + } + } + err = txn.Commit() + if err != nil { + t.Fatal(err) + } + + for key, bytes := range data { + retrieved, err := d.Get(key) + if err != nil { + t.Fatal(err) + } + rbytes := retrieved.([]byte) + if len(rbytes) != len(bytes) { + t.Fatal("bytes stored different length from bytes generated") + } + for i, b := range rbytes { + if bytes[i] != b { + t.Fatal("bytes stored different content from bytes generated") + } + } + } + + d.Close() +} From 135828164ffb0c860d5a7641a29f415b69c426b4 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Thu, 26 Jul 2018 14:06:49 -0400 Subject: [PATCH 04/12] TTL test, simplify Has impl --- datastore.go | 4 ++-- ds_test.go | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+), 2 deletions(-) diff --git a/datastore.go b/datastore.go index e63c687..7c9e407 100644 --- a/datastore.go +++ b/datastore.go @@ -215,11 +215,11 @@ func (t *txn) Get(key ds.Key) (interface{}, error) { } func (t *txn) Has(key ds.Key) (bool, error) { - _, err := t.txn.Get(key.Bytes()) + _, err := t.Get(key) if err == nil { return true, nil - } else if err == badger.ErrKeyNotFound { + } else if err == ds.ErrNotFound { return false, nil } diff --git a/ds_test.go b/ds_test.go index 1528fe8..ffb74ca 100644 --- a/ds_test.go +++ b/ds_test.go @@ -8,6 +8,7 @@ import ( "os" "sort" "testing" + "time" ds "github.com/ipfs/go-datastore" dsq "github.com/ipfs/go-datastore/query" @@ -616,3 +617,59 @@ func TestTxnBatch(t *testing.T) { d.Close() } + +func TestTTL(t *testing.T) { + d, err := NewDatastore("/tmp/testing_badger_du", nil) + defer os.RemoveAll("/tmp/testing_badger_du") + if err != nil { + t.Fatal(err) + } + + txn := d.NewTransaction(false) + + data := make(map[ds.Key][]byte) + for i := 0; i < 10; i++ { + key := ds.NewKey(fmt.Sprintf("/test/%d", i)) + bytes := make([]byte, 16) + _, err := rand.Read(bytes) + if err != nil { + t.Fatal(err) + } + data[key] = bytes + } + + // write data + for key, bytes := range data { + err = txn.(ds.TTLDatastore).PutWithTTL(key, bytes, time.Second) + if err != nil { + t.Fatal(err) + } + } + err = txn.Commit() + if err != nil { + t.Fatal(err) + } + + txn = d.NewTransaction(true) + for key := range data { + _, err := txn.Get(key) + if err != nil { + t.Fatal(err) + } + } + txn.Rollback() + + time.Sleep(time.Second) + + for key := range data { + has, err := d.Has(key) + if err != nil { + t.Fatal(err) + } + if has { + t.Fatal("record with ttl did not expire") + } + } + + d.Close() +} From 2937ef9f5544e871372e14a7fa213b4d143d6546 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 7 Aug 2018 15:10:47 -0400 Subject: [PATCH 05/12] Refactor Rollback -> Discard --- datastore.go | 16 ++++++++-------- ds_test.go | 6 +++--- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/datastore.go b/datastore.go index 7c9e407..27b713c 100644 --- a/datastore.go +++ b/datastore.go @@ -79,7 +79,7 @@ func (d *Datastore) NewTransaction(readOnly bool) ds.Txn { func (d *Datastore) Put(key ds.Key, value interface{}) error { txn := d.NewTransaction(false) - defer txn.Rollback() + defer txn.Discard() if err := txn.Put(key, value); err != nil { return err @@ -90,7 +90,7 @@ func (d *Datastore) Put(key ds.Key, value interface{}) error { func (d *datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { txn := d.NewTransaction(false).(*txn) - defer txn.Rollback() + defer txn.Discard() if err := txn.PutWithTTL(key, value, ttl); err != nil { return err @@ -101,7 +101,7 @@ func (d *datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) func (d *datastore) SetTTL(key ds.Key, ttl time.Duration) error { txn := d.NewTransaction(false).(*txn) - defer txn.Rollback() + defer txn.Discard() if err := txn.SetTTL(key, ttl); err != nil { return err @@ -112,21 +112,21 @@ func (d *datastore) SetTTL(key ds.Key, ttl time.Duration) error { func (d *Datastore) Get(key ds.Key) (value interface{}, err error) { txn := d.NewTransaction(true) - defer txn.Rollback() + defer txn.Discard() return txn.Get(key) } func (d *Datastore) Has(key ds.Key) (bool, error) { txn := d.NewTransaction(true) - defer txn.Rollback() + defer txn.Discard() return txn.Has(key) } func (d *Datastore) Delete(key ds.Key) error { txn := d.NewTransaction(false) - defer txn.Rollback() + defer txn.Discard() err := txn.Delete(key) if err != nil { @@ -138,7 +138,7 @@ func (d *Datastore) Delete(key ds.Key) error { func (d *Datastore) Query(q dsq.Query) (dsq.Results, error) { txn := d.NewTransaction(true) - defer txn.Rollback() + defer txn.Discard() return txn.Query(q) } @@ -304,6 +304,6 @@ func (t *txn) Commit() error { return t.txn.Commit(nil) } -func (t *txn) Rollback() { +func (t *txn) Discard() { t.txn.Discard() } diff --git a/ds_test.go b/ds_test.go index ffb74ca..02ab3ad 100644 --- a/ds_test.go +++ b/ds_test.go @@ -522,7 +522,7 @@ func TestDiskUsage(t *testing.T) { d.Close() } -func TestTxnRollback(t *testing.T) { +func TestTxnDiscard(t *testing.T) { d, err := NewDatastore("/tmp/testing_badger_du", nil) defer os.RemoveAll("/tmp/testing_badger_du") if err != nil { @@ -534,7 +534,7 @@ func TestTxnRollback(t *testing.T) { if err := txn.Put(key, []byte{1, 2, 3}); err != nil { t.Fatal(err) } - txn.Rollback() + txn.Discard() has, err := d.Has(key) if err != nil { t.Fatal(err) @@ -657,7 +657,7 @@ func TestTTL(t *testing.T) { t.Fatal(err) } } - txn.Rollback() + txn.Discard() time.Sleep(time.Second) From 91fba9d861c2917bf9fd6ef6bf638a85aeb368c2 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 7 Aug 2018 15:21:11 -0400 Subject: [PATCH 06/12] datastore -> Datastore --- datastore.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/datastore.go b/datastore.go index 27b713c..085d265 100644 --- a/datastore.go +++ b/datastore.go @@ -88,7 +88,7 @@ func (d *Datastore) Put(key ds.Key, value interface{}) error { return txn.Commit() } -func (d *datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { +func (d *Datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { txn := d.NewTransaction(false).(*txn) defer txn.Discard() @@ -99,7 +99,7 @@ func (d *datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) return txn.Commit() } -func (d *datastore) SetTTL(key ds.Key, ttl time.Duration) error { +func (d *Datastore) SetTTL(key ds.Key, ttl time.Duration) error { txn := d.NewTransaction(false).(*txn) defer txn.Discard() From 123518a46aa33bd9d0fd39baba6405b176221454 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 7 Aug 2018 15:29:41 -0400 Subject: [PATCH 07/12] Add docstring for txn --- datastore.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/datastore.go b/datastore.go index 085d265..33e36a8 100644 --- a/datastore.go +++ b/datastore.go @@ -19,6 +19,8 @@ type Datastore struct { gcDiscardRatio float64 } +// Implements the datastore.Txn interface, enabling transaction support for +// the badger Datastore. type txn struct { txn *badger.Txn } @@ -73,6 +75,9 @@ func NewDatastore(path string, options *Options) (*Datastore, error) { }, nil } +// NewTransaction starts a new transaction. The resulting transaction object +// can be mutated without incurring changes to the underlying Datastore until +// the transaction is Committed. func (d *Datastore) NewTransaction(readOnly bool) ds.Txn { return &txn{d.DB.NewTransaction(!readOnly)} } From dad8d7f83d5f2e9cf37cf421f1b02c4a2d39b94b Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 14 Aug 2018 17:56:58 -0400 Subject: [PATCH 08/12] gx publish 1.5.0 --- .gx/lastpubver | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gx/lastpubver b/.gx/lastpubver index d07ed80..d81a2cd 100644 --- a/.gx/lastpubver +++ b/.gx/lastpubver @@ -1 +1 @@ -1.5.0: QmciWFTxK1t1PNyPdoTsv8wtj3DWim2qRFjaUEcFWCnV8D +1.5.0: QmcmFp6p2z7Cu8H7f9VV6LM9sWpUtAFTAdnP3qCjeWJg1R From fa87afedbdfa619fd04c6741f0256ed4c5d7515a Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 14 Aug 2018 18:21:25 -0400 Subject: [PATCH 09/12] Rebase to master --- datastore.go | 26 ++++++++------------------ ds_test.go | 5 ++--- 2 files changed, 10 insertions(+), 21 deletions(-) diff --git a/datastore.go b/datastore.go index 33e36a8..3555da4 100644 --- a/datastore.go +++ b/datastore.go @@ -82,7 +82,7 @@ func (d *Datastore) NewTransaction(readOnly bool) ds.Txn { return &txn{d.DB.NewTransaction(!readOnly)} } -func (d *Datastore) Put(key ds.Key, value interface{}) error { +func (d *Datastore) Put(key ds.Key, value []byte) error { txn := d.NewTransaction(false) defer txn.Discard() @@ -93,7 +93,7 @@ func (d *Datastore) Put(key ds.Key, value interface{}) error { return txn.Commit() } -func (d *Datastore) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { +func (d *Datastore) PutWithTTL(key ds.Key, value []byte, ttl time.Duration) error { txn := d.NewTransaction(false).(*txn) defer txn.Discard() @@ -115,7 +115,7 @@ func (d *Datastore) SetTTL(key ds.Key, ttl time.Duration) error { return txn.Commit() } -func (d *Datastore) Get(key ds.Key) (value interface{}, err error) { +func (d *Datastore) Get(key ds.Key) (value []byte, err error) { txn := d.NewTransaction(true) defer txn.Discard() @@ -173,22 +173,12 @@ func (d *Datastore) CollectGarbage() error { return err } -func (t *txn) Put(key ds.Key, value interface{}) error { - bytes, ok := value.([]byte) - if !ok { - return ds.ErrInvalidType - } - - return t.txn.Set(key.Bytes(), bytes) +func (t *txn) Put(key ds.Key, value []byte) error { + return t.txn.Set(key.Bytes(), value) } -func (t *txn) PutWithTTL(key ds.Key, value interface{}, ttl time.Duration) error { - bytes, ok := value.([]byte) - if !ok { - return ds.ErrInvalidType - } - - return t.txn.SetWithTTL(key.Bytes(), bytes, ttl) +func (t *txn) PutWithTTL(key ds.Key, value []byte, ttl time.Duration) error { + return t.txn.SetWithTTL(key.Bytes(), value, ttl) } func (t *txn) SetTTL(key ds.Key, ttl time.Duration) error { @@ -200,7 +190,7 @@ func (t *txn) SetTTL(key ds.Key, ttl time.Duration) error { return t.PutWithTTL(key, data, ttl) } -func (t *txn) Get(key ds.Key) (interface{}, error) { +func (t *txn) Get(key ds.Key) ([]byte, error) { item, err := t.txn.Get(key.Bytes()) if err == badger.ErrKeyNotFound { err = ds.ErrNotFound diff --git a/ds_test.go b/ds_test.go index 02ab3ad..f78db82 100644 --- a/ds_test.go +++ b/ds_test.go @@ -604,11 +604,10 @@ func TestTxnBatch(t *testing.T) { if err != nil { t.Fatal(err) } - rbytes := retrieved.([]byte) - if len(rbytes) != len(bytes) { + if len(retrieved) != len(bytes) { t.Fatal("bytes stored different length from bytes generated") } - for i, b := range rbytes { + for i, b := range retrieved { if bytes[i] != b { t.Fatal("bytes stored different content from bytes generated") } From ec079965b78f430c8809ac950b9359ffdc0000d5 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 14 Aug 2018 18:21:58 -0400 Subject: [PATCH 10/12] gx publish 1.6.0 --- .gx/lastpubver | 2 +- package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gx/lastpubver b/.gx/lastpubver index d81a2cd..f885f0c 100644 --- a/.gx/lastpubver +++ b/.gx/lastpubver @@ -1 +1 @@ -1.5.0: QmcmFp6p2z7Cu8H7f9VV6LM9sWpUtAFTAdnP3qCjeWJg1R +1.6.0: QmVp1pKb7TS279XwqVEbzrfgFusBgUppSz42hmygwwt42M diff --git a/package.json b/package.json index e1e1f45..97787d5 100644 --- a/package.json +++ b/package.json @@ -37,6 +37,6 @@ "license": "", "name": "go-ds-badger", "releaseCmd": "git commit -a -m \"gx publish $VERSION\"", - "version": "1.5.0" + "version": "1.6.0" } From 954437217e11f4a568928592812eab4208477f66 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 14 Aug 2018 18:36:06 -0400 Subject: [PATCH 11/12] Bump go-datastore requirement --- package.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index 97787d5..08dc0b3 100644 --- a/package.json +++ b/package.json @@ -15,9 +15,9 @@ }, { "author": "jbenet", - "hash": "QmVG5gxteQNEMhrS8prJSmU2C9rebtFuTd3SYZ5kE3YZ5k", + "hash": "QmSpg1CvpXQQow5ernt1gNBXaXV6yxyNqi7XoeerWfzB5w", "name": "go-datastore", - "version": "3.0.0" + "version": "3.1.0" }, { "author": "dgraph-io", From fffc073ddcce48f4a7647a011c157116534c56c7 Mon Sep 17 00:00:00 2001 From: Cole Brown Date: Tue, 14 Aug 2018 18:36:22 -0400 Subject: [PATCH 12/12] gx publish 1.6.1 --- .gx/lastpubver | 2 +- package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gx/lastpubver b/.gx/lastpubver index f885f0c..f3a4c6b 100644 --- a/.gx/lastpubver +++ b/.gx/lastpubver @@ -1 +1 @@ -1.6.0: QmVp1pKb7TS279XwqVEbzrfgFusBgUppSz42hmygwwt42M +1.6.1: QmUCfrikzKVGAfpE31RPwPd32fu1DYxSG7HTGCadba5Wza diff --git a/package.json b/package.json index 08dc0b3..f6eaa23 100644 --- a/package.json +++ b/package.json @@ -37,6 +37,6 @@ "license": "", "name": "go-ds-badger", "releaseCmd": "git commit -a -m \"gx publish $VERSION\"", - "version": "1.6.0" + "version": "1.6.1" }