vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/eventlog/log.go

@@ -1,72 +0,0 @@
-package eventlog
-
-import (
-	"encoding/json"
-	"io"
-	"os"
-
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-)
-
-const logLogTag = "Log"
-
-type Log struct {
-	writer io.Writer
-	logger boshlog.Logger
-}
-
-type logEntry struct {
-	Time int64 `json:"time"`
-
-	Stage string   `json:"stage"`
-	Task  string   `json:"task"`
-	Tags  []string `json:"tags"`
-
-	Total int `json:"total"`
-	Index int `json:"index"`
-
-	State    string `json:"state"`
-	Progress int    `json:"progress"`
-
-	// Might contain error key
-	Data map[string]interface{} `json:"data,omitempty"`
-}
-
-func NewLog(logger boshlog.Logger) Log {
-	return Log{
-		writer: os.Stdout,
-		logger: logger,
-	}
-}
-
-func (l Log) BeginStage(name string, total int) *Stage {
-	return &Stage{
-		log:   l,
-		name:  name,
-		total: total,
-	}
-}
-
-func (l Log) writeLogEntryNoErr(entry logEntry) {
-	err := l.writeLogEntry(entry)
-	if err != nil {
-		l.logger.Error(logLogTag, "Failed writing log entry %s", err.Error())
-	}
-}
-
-func (l Log) writeLogEntry(entry logEntry) error {
-	bytes, err := json.Marshal(entry)
-	if err != nil {
-		return bosherr.WrapError(err, "Marshalling log entry")
-	}
-
-	bytes = append(bytes, []byte("\n")...)
-
-	_, err = l.writer.Write(bytes)
-	if err != nil {
-		return bosherr.WrapError(err, "Writing log entry")
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/eventlog/stage.go

@@ -1,39 +0,0 @@
-package eventlog
-
-import (
-	"sync"
-)
-
-type Stage struct {
-	log Log
-
-	name string
-
-	total         int
-	currTaskIndex int
-
-	indexLock sync.Mutex
-}
-
-func (s *Stage) BeginTask(name string) Task {
-	s.indexLock.Lock()
-
-	index := s.currTaskIndex
-	s.currTaskIndex++
-
-	s.indexLock.Unlock()
-
-	task := Task{
-		log: s.log,
-
-		stageName: s.name,
-		name:      name,
-
-		total: s.total,
-		index: index,
-	}
-
-	task.Start()
-
-	return task
-}

data/go/src/boshprovisioner/eventlog/task.go

@@ -1,58 +0,0 @@
-package eventlog
-
-import (
-	"time"
-)
-
-type Task struct {
-	log Log
-
-	stageName string
-	name      string
-
-	total int
-	index int
-}
-
-func (t Task) Start() {
-	entry := logEntry{
-		Time: time.Now().Unix(),
-
-		Stage: t.stageName,
-		Task:  t.name,
-
-		Total: t.total,
-		Index: t.index,
-
-		State:    "started",
-		Progress: 0,
-	}
-
-	t.log.writeLogEntryNoErr(entry)
-}
-
-func (t Task) End(err error) error {
-	entry := logEntry{
-		Time: time.Now().Unix(),
-
-		Stage: t.stageName,
-		Task:  t.name,
-
-		Total: t.total,
-		Index: t.index,
-
-		State:    "finished",
-		Progress: 100,
-	}
-
-	if err != nil {
-		entry.State = "failed"
-		entry.Data = map[string]interface{}{
-			"error": err.Error(),
-		}
-	}
-
-	t.log.writeLogEntryNoErr(entry)
-
-	return err
-}

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

@@ -1,289 +0,0 @@
-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]
-}