vagrant-bosh 0.0.1

data/go/src/boshprovisioner/index/file_index.go

@@ -0,0 +1,289 @@
+package index
+
+import (
+	"encoding/json"
+	"reflect"
+
+	bosherr "bosh/errors"
+	boshsys "bosh/system"
+)
+
+type FileIndex struct {
+	path string
+	fs   boshsys.FileSystem
+}
+
+type indexEntry struct {
+	Key   map[string]interface{}
+	Value json.RawMessage
+}
+
+func NewFileIndex(path string, fs boshsys.FileSystem) FileIndex {
+	return FileIndex{path: path, fs: fs}
+}
+
+func (ri FileIndex) List(entries interface{}) error {
+	rawEntries, err := ri.readRawEntries()
+	if err != nil {
+		return err
+	}
+
+	var rawEntryValues []json.RawMessage
+
+	for _, rawEntry := range rawEntries {
+		rawEntryValues = append(rawEntryValues, rawEntry.Value)
+	}
+
+	// todo avoid serializing already collected entries
+	rawEntryValuesBytes, err := json.Marshal(rawEntryValues)
+	if err != nil {
+		return err
+	}
+
+	err = json.Unmarshal(rawEntryValuesBytes, entries)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (ri FileIndex) ListKeys(keys interface{}) error {
+	rawEntries, err := ri.readRawEntries()
+	if err != nil {
+		return err
+	}
+
+	keysElem := reflect.ValueOf(keys).Elem()
+
+	for _, rawEntry := range rawEntries {
+		key, err := ri.mapToStructFromSlice(rawEntry.Key, keys)
+		if err != nil {
+			return err
+		}
+
+		keysElem.Set(reflect.Append(keysElem, key))
+	}
+
+	return nil
+}
+
+func (ri FileIndex) Find(key interface{}, entry interface{}) error {
+	rawEntries, err := ri.readRawEntries()
+	if err != nil {
+		return err
+	}
+
+	rawKey, err := ri.structToMap(key)
+	if err != nil {
+		return err
+	}
+
+	for _, rawEntry := range rawEntries {
+		if reflect.DeepEqual(rawEntry.Key, rawKey) {
+			err := json.Unmarshal(rawEntry.Value, entry)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		}
+	}
+
+	return ErrNotFound
+}
+
+func (ri FileIndex) Save(key interface{}, entry interface{}) error {
+	rawEntries, err := ri.readRawEntries()
+	if err != nil {
+		return err
+	}
+
+	rawKey, err := ri.structToMap(key)
+	if err != nil {
+		return err
+	}
+
+	rawValue, err := json.Marshal(entry)
+	if err != nil {
+		return err
+	}
+
+	foundI := -1
+
+	for i, rawEntry := range rawEntries {
+		if reflect.DeepEqual(rawEntry.Key, rawKey) {
+			foundI = i
+			break
+		}
+	}
+
+	if foundI >= 0 {
+		rawEntries[foundI].Value = rawValue
+	} else {
+		rawEntries = append(rawEntries, indexEntry{
+			Key:   rawKey,
+			Value: rawValue,
+		})
+	}
+
+	err = ri.writeRawEntries(rawEntries)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (ri FileIndex) Remove(key interface{}) error {
+	rawEntries, err := ri.readRawEntries()
+	if err != nil {
+		return err
+	}
+
+	rawKey, err := ri.structToMap(key)
+	if err != nil {
+		return err
+	}
+
+	for i, rawEntry := range rawEntries {
+		if reflect.DeepEqual(rawEntry.Key, rawKey) {
+			rawEntries = append(rawEntries[:i], rawEntries[i+1:]...)
+			break
+		}
+	}
+
+	err = ri.writeRawEntries(rawEntries)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (ri FileIndex) readRawEntries() ([]indexEntry, error) {
+	var entries []indexEntry
+
+	if ri.fs.FileExists(ri.path) {
+		bytes, err := ri.fs.ReadFile(ri.path)
+		if err != nil {
+			return entries, bosherr.WrapError(err, "Reading index file %s", ri.path)
+		}
+
+		err = json.Unmarshal(bytes, &entries)
+		if err != nil {
+			return entries, bosherr.WrapError(err, "Unmarshalling index entries")
+		}
+	}
+
+	return entries, nil
+}
+
+func (ri FileIndex) writeRawEntries(entries []indexEntry) error {
+	bytes, err := json.Marshal(entries)
+	if err != nil {
+		return bosherr.WrapError(err, "Marshalling index entries")
+	}
+
+	err = ri.fs.WriteFile(ri.path, bytes)
+	if err != nil {
+		return bosherr.WrapError(err, "Writing index file %s", ri.path)
+	}
+
+	return nil
+}
+
+// structToMap extracts fields from a struct and populates a map
+func (ri FileIndex) structToMap(s interface{}) (map[string]interface{}, error) {
+	res := map[string]interface{}{}
+	st := reflect.TypeOf(s)
+	stv := reflect.ValueOf(s)
+
+	if stv.Kind() != reflect.Struct {
+		return res, bosherr.New(
+			"Must be reflect.Struct: %#v (%#v)", stv, ri.kindToStr(stv.Kind()))
+	}
+
+	for i := 0; i < st.NumField(); i++ {
+		res[st.Field(i).Name] = stv.Field(i).Interface()
+	}
+
+	return res, nil
+}
+
+// mapToStruct returns new struct value with data from a map
+func (ri FileIndex) mapToStruct(m map[string]interface{}, t interface{}) (reflect.Value, error) {
+	return ri.mapToNewStruct(m, reflect.ValueOf(t).Elem().Type())
+}
+
+// mapToStructFromSlice returns new struct value with data from a map
+func (ri FileIndex) mapToStructFromSlice(m map[string]interface{}, t interface{}) (reflect.Value, error) {
+	slice := reflect.ValueOf(t).Elem()
+
+	if slice.Kind() != reflect.Slice {
+		return reflect.Value{}, bosherr.New(
+			"Must be reflect.Slice: %#v (%#v)",
+			slice, ri.kindToStr(slice.Kind()),
+		)
+	}
+
+	return ri.mapToNewStruct(m, slice.Type().Elem())
+}
+
+// mapToNewStruct returns new struct of type t with data from a map
+func (ri FileIndex) mapToNewStruct(m map[string]interface{}, t reflect.Type) (reflect.Value, error) {
+	if t.Kind() != reflect.Struct {
+		return reflect.Value{}, bosherr.New(
+			"Must be reflect.Struct: %#v (%#v)",
+			t, ri.kindToStr(t.Kind()),
+		)
+	}
+
+	newStruct := reflect.New(t).Elem()
+
+	for k, v := range m {
+		f := newStruct.FieldByName(k)
+		if f.IsValid() && f.CanSet() {
+			// todo float64 -> int
+			// todo pointer values
+			// todo slices
+			f.Set(reflect.ValueOf(v))
+		}
+	}
+
+	return newStruct, nil
+}
+
+var kindToStrMap = map[reflect.Kind]string{
+	reflect.Invalid:       "Invalid",
+	reflect.Bool:          "Bool",
+	reflect.Int:           "Int",
+	reflect.Int8:          "Int8",
+	reflect.Int16:         "Int16",
+	reflect.Int32:         "Int32",
+	reflect.Int64:         "Int64",
+	reflect.Uint:          "Uint",
+	reflect.Uint8:         "Uint8",
+	reflect.Uint16:        "Uint16",
+	reflect.Uint32:        "Uint32",
+	reflect.Uint64:        "Uint64",
+	reflect.Uintptr:       "Uintptr",
+	reflect.Float32:       "Float32",
+	reflect.Float64:       "Float64",
+	reflect.Complex64:     "Complex64",
+	reflect.Complex128:    "Complex128",
+	reflect.Array:         "Array",
+	reflect.Chan:          "Chan",
+	reflect.Func:          "Func",
+	reflect.Interface:     "Interface",
+	reflect.Map:           "Map",
+	reflect.Ptr:           "Ptr",
+	reflect.Slice:         "Slice",
+	reflect.String:        "String",
+	reflect.Struct:        "Struct",
+	reflect.UnsafePointer: "UnsafePointer",
+}
+
+func (ri FileIndex) kindToStr(k reflect.Kind) string {
+	return kindToStrMap[k]
+}

data/go/src/boshprovisioner/index/file_index_test.go

@@ -0,0 +1,296 @@
+package index_test
+
+import (
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "boshprovisioner/index"
+)
+
+type Key struct {
+	Key string
+}
+
+type Value struct {
+	Name  string
+	Count float64
+}
+
+type ArrayValue struct{ Names []string }
+
+type StructValue struct{ Name Name }
+
+type Name struct {
+	First string
+	Last  string
+}
+
+var _ = Describe("FileIndex", func() {
+	var (
+		index FileIndex
+	)
+
+	BeforeEach(func() {
+		logger := boshlog.NewLogger(boshlog.LevelNone)
+		fs := boshsys.NewOsFileSystem(logger)
+
+		file, err := fs.TempFile("file-index")
+		Expect(err).ToNot(HaveOccurred())
+
+		err = fs.RemoveAll(file.Name())
+		Expect(err).ToNot(HaveOccurred())
+
+		index = NewFileIndex(file.Name(), fs)
+	})
+
+	Describe("Save/List", func() {
+		It("returns list of saved items", func() {
+			k1 := Key{Key: "key-1"}
+			v1 := Value{Name: "value-1", Count: 1}
+			err := index.Save(k1, v1)
+			Expect(err).ToNot(HaveOccurred())
+
+			k2 := Key{Key: "key-2"}
+			v2 := Value{Name: "value-2", Count: 2}
+			err = index.Save(k2, v2)
+			Expect(err).ToNot(HaveOccurred())
+
+			var values []Value
+
+			err = index.List(&values)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(values).To(Equal([]Value{v1, v2}))
+		})
+
+		Describe("array values", func() {
+			It("returns list of saved items that have nil, 0, 1, and more items in an array", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := ArrayValue{Names: []string{"name-1-1", "name-1-2"}} // multiple
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				k2 := Key{Key: "key-2"}
+				v2 := ArrayValue{Names: []string{"name-2-1"}} // single
+				err = index.Save(k2, v2)
+				Expect(err).ToNot(HaveOccurred())
+
+				k3 := Key{Key: "key-3"}
+				v3 := ArrayValue{Names: []string{}} // empty slice
+				err = index.Save(k3, v3)
+				Expect(err).ToNot(HaveOccurred())
+
+				k4 := Key{Key: "key-4"}
+				v4 := ArrayValue{} // nil
+				err = index.Save(k4, v4)
+				Expect(err).ToNot(HaveOccurred())
+
+				var values []ArrayValue
+
+				err = index.List(&values)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(values).To(Equal([]ArrayValue{v1, v2, v3, v4}))
+			})
+		})
+
+		Describe("struct values", func() {
+			It("returns list of saved items that have nil or more item", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := StructValue{Name: Name{First: "first-name-1", Last: "last-name-1"}} // struct
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				k2 := Key{Key: "key-2"}
+				v2 := StructValue{Name: Name{First: "first-name-1"}} // struct incomplete
+				err = index.Save(k2, v2)
+				Expect(err).ToNot(HaveOccurred())
+
+				k3 := Key{Key: "key-3"}
+				v3 := StructValue{} // zero value
+				err = index.Save(k3, v3)
+				Expect(err).ToNot(HaveOccurred())
+
+				var values []StructValue
+
+				err = index.List(&values)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(values).To(Equal([]StructValue{v1, v2, v3}))
+			})
+		})
+	})
+
+	Describe("Save/ListKeys", func() {
+		It("returns list of saved keys", func() {
+			k1 := Key{Key: "key-1"}
+			v1 := Value{Name: "value-1", Count: 1}
+			err := index.Save(k1, v1)
+			Expect(err).ToNot(HaveOccurred())
+
+			k2 := Key{Key: "key-2"}
+			v2 := Value{Name: "value-2", Count: 2}
+			err = index.Save(k2, v2)
+			Expect(err).ToNot(HaveOccurred())
+
+			var keys []Key
+
+			err = index.ListKeys(&keys)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(keys).To(Equal([]Key{k1, k2}))
+		})
+	})
+
+	Describe("Save/Find", func() {
+		It("returns true if item is found by key", func() {
+			k1 := Key{Key: "key-1"}
+			v1 := Value{Name: "value-1", Count: 1}
+			err := index.Save(k1, v1)
+			Expect(err).ToNot(HaveOccurred())
+
+			var value Value
+
+			err = index.Find(k1, &value)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(err).ToNot(Equal(ErrNotFound))
+
+			Expect(value).To(Equal(v1))
+		})
+
+		It("returns false if item is not found by key", func() {
+			k1 := Key{Key: "key-1"}
+			v1 := Value{Name: "value-1", Count: 1}
+			err := index.Save(k1, v1)
+			Expect(err).ToNot(HaveOccurred())
+
+			var value Value
+
+			err = index.Find(Key{Key: "key-2"}, &value)
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(Equal(ErrNotFound))
+
+			Expect(value).To(Equal(Value{}))
+		})
+
+		Describe("array values", func() {
+			It("returns true and correctly deserializes item with nil", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := ArrayValue{} // nil
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				var value ArrayValue
+
+				err = index.Find(k1, &value)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(err).ToNot(Equal(ErrNotFound))
+
+				Expect(value).To(Equal(v1))
+			})
+
+			It("returns true and correctly deserializes item with empty slice", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := ArrayValue{Names: []string{}} // empty slice
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				var value ArrayValue
+
+				err = index.Find(k1, &value)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(err).ToNot(Equal(ErrNotFound))
+
+				Expect(value).To(Equal(v1))
+			})
+
+			It("returns true and correctly deserializes item with multiple items", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := ArrayValue{Names: []string{"name-1-1", "name-1-2"}} // multiple
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				var value ArrayValue
+
+				err = index.Find(k1, &value)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(err).ToNot(Equal(ErrNotFound))
+
+				Expect(value).To(Equal(v1))
+			})
+		})
+
+		Describe("struct values", func() {
+			It("returns true and correctly deserializes item with zero value", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := StructValue{} // zero value
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				var value StructValue
+
+				err = index.Find(k1, &value)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(err).ToNot(Equal(ErrNotFound))
+
+				Expect(value).To(Equal(v1))
+			})
+
+			It("returns true and correctly deserializes item with filled struct", func() {
+				k1 := Key{Key: "key-1"}
+				v1 := StructValue{Name: Name{First: "first-name-1", Last: "last-name-1"}} // struct
+				err := index.Save(k1, v1)
+				Expect(err).ToNot(HaveOccurred())
+
+				var value StructValue
+
+				err = index.Find(k1, &value)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(err).ToNot(Equal(ErrNotFound))
+
+				Expect(value).To(Equal(v1))
+			})
+		})
+	})
+
+	Describe("Save/Remove", func() {
+		var (
+			k1 Key
+			v1 Value
+		)
+
+		BeforeEach(func() {
+			k1 = Key{Key: "key-1"}
+			v1 = Value{Name: "value-1", Count: 1}
+			err := index.Save(k1, v1)
+			Expect(err).ToNot(HaveOccurred())
+		})
+
+		It("removes matching value if found", func() {
+			k2 := Key{Key: "key-2"}
+			v2 := Value{Name: "value-2", Count: 2}
+			err := index.Save(k2, v2)
+			Expect(err).ToNot(HaveOccurred())
+
+			err = index.Remove(k1)
+			Expect(err).ToNot(HaveOccurred())
+
+			var values []Value
+
+			err = index.List(&values)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(values).To(Equal([]Value{v2}))
+		})
+
+		It("does not remove non-matching value if not found", func() {
+			k2 := Key{Key: "key-2"}
+
+			err := index.Remove(k2)
+			Expect(err).ToNot(HaveOccurred())
+
+			var values []Value
+
+			err = index.List(&values)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(values).To(Equal([]Value{v1}))
+		})
+	})
+})

data/go/src/boshprovisioner/index/index_interface.go

@@ -0,0 +1,18 @@
+package index
+
+import (
+	"errors"
+)
+
+var (
+	ErrNotFound = errors.New("Record is not found")
+)
+
+type Index interface {
+	ListKeys(interface{}) error
+	List(interface{}) error
+
+	Find(interface{}, interface{}) error
+	Save(interface{}, interface{}) error
+	Remove(interface{}) error
+}

data/go/src/boshprovisioner/index/index_suite_test.go

@@ -0,0 +1,13 @@
+package index_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"testing"
+)
+
+func TestIndex(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Index Suite")
+}