Switch from Godep to go vendoring

vendor/github.com/blevesearch/bleve/index/store/inmem/iterator.go

@@ -0,0 +1,70 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+//  except in compliance with the License. You may obtain a copy of the License at
+//    http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software distributed under the
+//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+//  either express or implied. See the License for the specific language governing permissions
+//  and limitations under the License.
+
+package inmem
+
+import (
+	"github.com/ryszard/goskiplist/skiplist"
+)
+
+type Iterator struct {
+	store    *Store
+	iterator skiplist.Iterator
+	valid    bool
+}
+
+func newIterator(store *Store) *Iterator {
+	rv := Iterator{
+		store:    store,
+		iterator: store.list.Iterator(),
+	}
+	return &rv
+}
+
+func (i *Iterator) SeekFirst() {
+	i.Seek([]byte{0})
+}
+
+func (i *Iterator) Seek(k []byte) {
+	i.valid = i.iterator.Seek(string(k))
+}
+
+func (i *Iterator) Next() {
+	i.valid = i.iterator.Next()
+}
+
+func (i *Iterator) Current() ([]byte, []byte, bool) {
+	if i.valid {
+		return []byte(i.Key()), []byte(i.Value()), true
+	}
+	return nil, nil, false
+}
+
+func (i *Iterator) Key() []byte {
+	if i.valid {
+		return []byte(i.iterator.Key().(string))
+	}
+	return nil
+}
+
+func (i *Iterator) Value() []byte {
+	if i.valid {
+		return []byte(i.iterator.Value().(string))
+	}
+	return nil
+}
+
+func (i *Iterator) Valid() bool {
+	return i.valid
+}
+
+func (i *Iterator) Close() error {
+	i.iterator.Close()
+	return nil
+}

vendor/github.com/blevesearch/bleve/index/store/inmem/reader.go

@@ -0,0 +1,40 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+//  except in compliance with the License. You may obtain a copy of the License at
+//    http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software distributed under the
+//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+//  either express or implied. See the License for the specific language governing permissions
+//  and limitations under the License.
+
+package inmem
+
+import (
+	"github.com/blevesearch/bleve/index/store"
+)
+
+type Reader struct {
+	store *Store
+}
+
+func newReader(store *Store) (*Reader, error) {
+	return &Reader{
+		store: store,
+	}, nil
+}
+
+func (r *Reader) BytesSafeAfterClose() bool {
+	return false
+}
+
+func (r *Reader) Get(key []byte) ([]byte, error) {
+	return r.store.get(key)
+}
+
+func (r *Reader) Iterator(key []byte) store.KVIterator {
+	return r.store.iterator(key)
+}
+
+func (r *Reader) Close() error {
+	return nil
+}

vendor/github.com/blevesearch/bleve/index/store/inmem/store.go

@@ -0,0 +1,106 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+//  except in compliance with the License. You may obtain a copy of the License at
+//    http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software distributed under the
+//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+//  either express or implied. See the License for the specific language governing permissions
+//  and limitations under the License.
+
+package inmem
+
+import (
+	"sync"
+
+	"github.com/blevesearch/bleve/index/store"
+	"github.com/blevesearch/bleve/registry"
+	"github.com/ryszard/goskiplist/skiplist"
+)
+
+const Name = "mem"
+
+type Store struct {
+	list   *skiplist.SkipList
+	writer sync.Mutex
+	mo     store.MergeOperator
+}
+
+func New() (*Store, error) {
+	rv := Store{
+		list: skiplist.NewStringMap(),
+	}
+
+	return &rv, nil
+}
+
+func MustOpen() *Store {
+	rv := Store{
+		list: skiplist.NewStringMap(),
+	}
+
+	return &rv
+}
+
+func (i *Store) Open() error {
+	return nil
+}
+
+func (i *Store) SetMergeOperator(mo store.MergeOperator) {
+	i.mo = mo
+}
+
+func (i *Store) get(key []byte) ([]byte, error) {
+	val, ok := i.list.Get(string(key))
+	if ok {
+		return []byte(val.(string)), nil
+	}
+	return nil, nil
+}
+
+func (i *Store) set(key, val []byte) error {
+	i.writer.Lock()
+	defer i.writer.Unlock()
+	return i.setlocked(key, val)
+}
+
+func (i *Store) setlocked(key, val []byte) error {
+	i.list.Set(string(key), string(val))
+	return nil
+}
+
+func (i *Store) delete(key []byte) error {
+	i.writer.Lock()
+	defer i.writer.Unlock()
+	return i.deletelocked(key)
+}
+
+func (i *Store) deletelocked(key []byte) error {
+	i.list.Delete(string(key))
+	return nil
+}
+
+func (i *Store) Close() error {
+	return nil
+}
+
+func (i *Store) iterator(key []byte) store.KVIterator {
+	rv := newIterator(i)
+	rv.Seek(key)
+	return rv
+}
+
+func (i *Store) Reader() (store.KVReader, error) {
+	return newReader(i)
+}
+
+func (i *Store) Writer() (store.KVWriter, error) {
+	return newWriter(i)
+}
+
+func StoreConstructor(config map[string]interface{}) (store.KVStore, error) {
+	return New()
+}
+
+func init() {
+	registry.RegisterKVStore(Name, StoreConstructor)
+}

vendor/github.com/blevesearch/bleve/index/store/inmem/store_test.go

@@ -0,0 +1,254 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+//  except in compliance with the License. You may obtain a copy of the License at
+//    http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software distributed under the
+//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+//  either express or implied. See the License for the specific language governing permissions
+//  and limitations under the License.
+
+package inmem
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/blevesearch/bleve/index/store"
+)
+
+func TestStore(t *testing.T) {
+	s, err := New()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		err := s.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	CommonTestKVStore(t, s)
+}
+
+func CommonTestKVStore(t *testing.T, s store.KVStore) {
+
+	writer, err := s.Writer()
+	if err != nil {
+		t.Error(err)
+	}
+	err = writer.Set([]byte("a"), []byte("val-a"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Set([]byte("z"), []byte("val-z"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Delete([]byte("z"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	batch := writer.NewBatch()
+	batch.Set([]byte("b"), []byte("val-b"))
+	batch.Set([]byte("c"), []byte("val-c"))
+	batch.Set([]byte("d"), []byte("val-d"))
+	batch.Set([]byte("e"), []byte("val-e"))
+	batch.Set([]byte("f"), []byte("val-f"))
+	batch.Set([]byte("g"), []byte("val-g"))
+	batch.Set([]byte("h"), []byte("val-h"))
+	batch.Set([]byte("i"), []byte("val-i"))
+	batch.Set([]byte("j"), []byte("val-j"))
+
+	err = batch.Execute()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	reader, err := s.Reader()
+	if err != nil {
+		t.Error(err)
+	}
+	defer func() {
+		err := reader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	it := reader.Iterator([]byte("b"))
+	key, val, valid := it.Current()
+	if !valid {
+		t.Fatalf("valid false, expected true")
+	}
+	if string(key) != "b" {
+		t.Fatalf("expected key b, got %s", key)
+	}
+	if string(val) != "val-b" {
+		t.Fatalf("expected value val-b, got %s", val)
+	}
+
+	it.Next()
+	key, val, valid = it.Current()
+	if !valid {
+		t.Fatalf("valid false, expected true")
+	}
+	if string(key) != "c" {
+		t.Fatalf("expected key c, got %s", key)
+	}
+	if string(val) != "val-c" {
+		t.Fatalf("expected value val-c, got %s", val)
+	}
+
+	it.Seek([]byte("i"))
+	key, val, valid = it.Current()
+	if !valid {
+		t.Fatalf("valid false, expected true")
+	}
+	if string(key) != "i" {
+		t.Fatalf("expected key i, got %s", key)
+	}
+	if string(val) != "val-i" {
+		t.Fatalf("expected value val-i, got %s", val)
+	}
+
+	err = it.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func CommonTestReaderIsolation(t *testing.T, s store.KVStore) {
+	// insert a kv pair
+	writer, err := s.Writer()
+	if err != nil {
+		t.Error(err)
+	}
+	err = writer.Set([]byte("a"), []byte("val-a"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// create an isolated reader
+	reader, err := s.Reader()
+	if err != nil {
+		t.Error(err)
+	}
+	defer func() {
+		err := reader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	// verify that we see the value already inserted
+	val, err := reader.Get([]byte("a"))
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(val, []byte("val-a")) {
+		t.Errorf("expected val-a, got nil")
+	}
+
+	// verify that an iterator sees it
+	count := 0
+	it := reader.Iterator([]byte{0})
+	defer func() {
+		err := it.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	for it.Valid() {
+		it.Next()
+		count++
+	}
+	if count != 1 {
+		t.Errorf("expected iterator to see 1, saw %d", count)
+	}
+
+	// add something after the reader was created
+	writer, err = s.Writer()
+	if err != nil {
+		t.Error(err)
+	}
+	err = writer.Set([]byte("b"), []byte("val-b"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = writer.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// ensure that a newer reader sees it
+	newReader, err := s.Reader()
+	if err != nil {
+		t.Error(err)
+	}
+	defer func() {
+		err := newReader.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	val, err = newReader.Get([]byte("b"))
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(val, []byte("val-b")) {
+		t.Errorf("expected val-b, got nil")
+	}
+
+	// ensure that the director iterator sees it
+	count = 0
+	it = newReader.Iterator([]byte{0})
+	defer func() {
+		err := it.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	for it.Valid() {
+		it.Next()
+		count++
+	}
+	if count != 2 {
+		t.Errorf("expected iterator to see 2, saw %d", count)
+	}
+
+	// but that the isolated reader does not
+	val, err = reader.Get([]byte("b"))
+	if err != nil {
+		t.Error(err)
+	}
+	if val != nil {
+		t.Errorf("expected nil, got %v", val)
+	}
+
+	// and ensure that the iterator on the isolated reader also does not
+	count = 0
+	it = reader.Iterator([]byte{0})
+	defer func() {
+		err := it.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	for it.Valid() {
+		it.Next()
+		count++
+	}
+	if count != 1 {
+		t.Errorf("expected iterator to see 1, saw %d", count)
+	}
+
+}

vendor/github.com/blevesearch/bleve/index/store/inmem/writer.go

@@ -0,0 +1,57 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+//  except in compliance with the License. You may obtain a copy of the License at
+//    http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software distributed under the
+//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+//  either express or implied. See the License for the specific language governing permissions
+//  and limitations under the License.
+
+package inmem
+
+import (
+	"github.com/blevesearch/bleve/index/store"
+)
+
+type Writer struct {
+	store *Store
+}
+
+func newWriter(store *Store) (*Writer, error) {
+	store.writer.Lock()
+	return &Writer{
+		store: store,
+	}, nil
+}
+
+func (w *Writer) BytesSafeAfterClose() bool {
+	return false
+}
+
+func (w *Writer) Set(key, val []byte) error {
+	return w.store.setlocked(key, val)
+}
+
+func (w *Writer) Delete(key []byte) error {
+	return w.store.deletelocked(key)
+}
+
+func (w *Writer) NewBatch() store.KVBatch {
+	return store.NewEmulatedBatch(w, w.store.mo)
+}
+
+func (w *Writer) Close() error {
+	w.store.writer.Unlock()
+	return nil
+}
+
+// these two methods can safely read using the regular
+// methods without a read transaction, because we know
+// that no one else is writing but us
+func (w *Writer) Get(key []byte) ([]byte, error) {
+	return w.store.get(key)
+}
+
+func (w *Writer) Iterator(key []byte) store.KVIterator {
+	return w.store.iterator(key)
+}