leveldb/testutil/storage.go - third_party/goleveldb - Git at Google

 // Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
 // All rights reserved.
 //
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package testutil

 import (
 	"bytes"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"

 	. "github.com/onsi/gomega"

 	"github.com/syndtr/goleveldb/leveldb/storage"
 	"github.com/syndtr/goleveldb/leveldb/util"
 )

 var (
 	storageMu     sync.Mutex
 	storageUseFS  bool = true
 	storageKeepFS bool = false
 	storageNum    int
 )

 type StorageMode int

 const (
 	ModeOpen StorageMode = 1 << iota
 	ModeCreate
 	ModeRemove
 	ModeRead
 	ModeWrite
 	ModeSync
 	ModeClose
 )

 const (
 	modeOpen = iota
 	modeCreate
 	modeRemove
 	modeRead
 	modeWrite
 	modeSync
 	modeClose

 	modeCount
 )

 const (
 	typeManifest = iota
 	typeJournal
 	typeTable
 	typeTemp

 	typeCount
 )

 const flattenCount = modeCount * typeCount

 func flattenType(m StorageMode, t storage.FileType) int {
 	var x int
 	switch m {
 	case ModeOpen:
 		x = modeOpen
 	case ModeCreate:
 		x = modeCreate
 	case ModeRemove:
 		x = modeRemove
 	case ModeRead:
 		x = modeRead
 	case ModeWrite:
 		x = modeWrite
 	case ModeSync:
 		x = modeSync
 	case ModeClose:
 		x = modeClose
 	default:
 		panic("invalid storage mode")
 	}
 	x *= typeCount
 	switch t {
 	case storage.TypeManifest:
 		return x + typeManifest
 	case storage.TypeJournal:
 		return x + typeJournal
 	case storage.TypeTable:
 		return x + typeTable
 	case storage.TypeTemp:
 		return x + typeTemp
 	default:
 		panic("invalid file type")
 	}
 }

 func listFlattenType(m StorageMode, t storage.FileType) []int {
 	ret := make([]int, 0, flattenCount)
 	add := func(x int) {
 		x *= typeCount
 		switch {
 		case t&storage.TypeManifest != 0:
 			ret = append(ret, x+typeManifest)
 		case t&storage.TypeJournal != 0:
 			ret = append(ret, x+typeJournal)
 		case t&storage.TypeTable != 0:
 			ret = append(ret, x+typeTable)
 		case t&storage.TypeTemp != 0:
 			ret = append(ret, x+typeTemp)
 		}
 	}
 	switch {
 	case m&ModeOpen != 0:
 		add(modeOpen)
 	case m&ModeCreate != 0:
 		add(modeCreate)
 	case m&ModeRemove != 0:
 		add(modeRemove)
 	case m&ModeRead != 0:
 		add(modeRead)
 	case m&ModeWrite != 0:
 		add(modeWrite)
 	case m&ModeSync != 0:
 		add(modeSync)
 	case m&ModeClose != 0:
 		add(modeClose)
 	}
 	return ret
 }

 func packFile(num uint64, t storage.FileType) uint64 {
 	if num>>(64-typeCount) != 0 {
 		panic("overflow")
 	}
 	return num<<typeCount | uint64(t)
 }

 func unpackFile(x uint64) (uint64, storage.FileType) {
 	return x >> typeCount, storage.FileType(x) & storage.TypeAll
 }

 type emulatedError struct {
 	err error
 }

 func (err emulatedError) Error() string {
 	return fmt.Sprintf("emulated storage error: %v", err.err)
 }

 type storageLock struct {
 	s *Storage
 	r util.Releaser
 }

 func (l storageLock) Release() {
 	l.r.Release()
 	l.s.logI("storage lock released")
 }

 type reader struct {
 	f *file
 	storage.Reader
 }

 func (r *reader) Read(p []byte) (n int, err error) {
 	err = r.f.s.emulateError(ModeRead, r.f.Type())
 	if err == nil {
 		r.f.s.stall(ModeRead, r.f.Type())
 		n, err = r.Reader.Read(p)
 	}
 	r.f.s.count(ModeRead, r.f.Type(), n)
 	if err != nil && err != io.EOF {
 		r.f.s.logI("read error, num=%d type=%v n=%d err=%v", r.f.Num(), r.f.Type(), n, err)
 	}
 	return
 }

 func (r *reader) ReadAt(p []byte, off int64) (n int, err error) {
 	err = r.f.s.emulateError(ModeRead, r.f.Type())
 	if err == nil {
 		r.f.s.stall(ModeRead, r.f.Type())
 		n, err = r.Reader.ReadAt(p, off)
 	}
 	r.f.s.count(ModeRead, r.f.Type(), n)
 	if err != nil && err != io.EOF {
 		r.f.s.logI("readAt error, num=%d type=%v offset=%d n=%d err=%v", r.f.Num(), r.f.Type(), off, n, err)
 	}
 	return
 }

 func (r *reader) Close() (err error) {
 	return r.f.doClose(r.Reader)
 }

 type writer struct {
 	f *file
 	storage.Writer
 }

 func (w *writer) Write(p []byte) (n int, err error) {
 	err = w.f.s.emulateError(ModeWrite, w.f.Type())
 	if err == nil {
 		w.f.s.stall(ModeWrite, w.f.Type())
 		n, err = w.Writer.Write(p)
 	}
 	w.f.s.count(ModeWrite, w.f.Type(), n)
 	if err != nil && err != io.EOF {
 		w.f.s.logI("write error, num=%d type=%v n=%d err=%v", w.f.Num(), w.f.Type(), n, err)
 	}
 	return
 }

 func (w *writer) Sync() (err error) {
 	err = w.f.s.emulateError(ModeSync, w.f.Type())
 	if err == nil {
 		w.f.s.stall(ModeSync, w.f.Type())
 		err = w.Writer.Sync()
 	}
 	w.f.s.count(ModeSync, w.f.Type(), 0)
 	if err != nil {
 		w.f.s.logI("sync error, num=%d type=%v err=%v", w.f.Num(), w.f.Type(), err)
 	}
 	return
 }

 func (w *writer) Close() (err error) {
 	return w.f.doClose(w.Writer)
 }

 type file struct {
 	s *Storage
 	storage.File
 }

 func (f *file) pack() uint64 {
 	return packFile(f.Num(), f.Type())
 }

 func (f *file) assertOpen() {
 	ExpectWithOffset(2, f.s.opens).NotTo(HaveKey(f.pack()), "File open, num=%d type=%v writer=%v", f.Num(), f.Type(), f.s.opens[f.pack()])
 }

 func (f *file) doClose(closer io.Closer) (err error) {
 	err = f.s.emulateError(ModeClose, f.Type())
 	if err == nil {
 		f.s.stall(ModeClose, f.Type())
 	}
 	f.s.mu.Lock()
 	defer f.s.mu.Unlock()
 	if err == nil {
 		ExpectWithOffset(2, f.s.opens).To(HaveKey(f.pack()), "File closed, num=%d type=%v", f.Num(), f.Type())
 		err = closer.Close()
 	}
 	f.s.countNB(ModeClose, f.Type(), 0)
 	writer := f.s.opens[f.pack()]
 	if err != nil {
 		f.s.logISkip(1, "file close failed, num=%d type=%v writer=%v err=%v", f.Num(), f.Type(), writer, err)
 	} else {
 		f.s.logISkip(1, "file closed, num=%d type=%v writer=%v", f.Num(), f.Type(), writer)
 		delete(f.s.opens, f.pack())
 	}
 	return
 }

 func (f *file) Open() (r storage.Reader, err error) {
 	err = f.s.emulateError(ModeOpen, f.Type())
 	if err == nil {
 		f.s.stall(ModeOpen, f.Type())
 	}
 	f.s.mu.Lock()
 	defer f.s.mu.Unlock()
 	if err == nil {
 		f.assertOpen()
 		f.s.countNB(ModeOpen, f.Type(), 0)
 		r, err = f.File.Open()
 	}
 	if err != nil {
 		f.s.logI("file open failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
 	} else {
 		f.s.logI("file opened, num=%d type=%v", f.Num(), f.Type())
 		f.s.opens[f.pack()] = false
 		r = &reader{f, r}
 	}
 	return
 }

 func (f *file) Create() (w storage.Writer, err error) {
 	err = f.s.emulateError(ModeCreate, f.Type())
 	if err == nil {
 		f.s.stall(ModeCreate, f.Type())
 	}
 	f.s.mu.Lock()
 	defer f.s.mu.Unlock()
 	if err == nil {
 		f.assertOpen()
 		f.s.countNB(ModeCreate, f.Type(), 0)
 		w, err = f.File.Create()
 	}
 	if err != nil {
 		f.s.logI("file create failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
 	} else {
 		f.s.logI("file created, num=%d type=%v", f.Num(), f.Type())
 		f.s.opens[f.pack()] = true
 		w = &writer{f, w}
 	}
 	return
 }

 func (f *file) Remove() (err error) {
 	err = f.s.emulateError(ModeRemove, f.Type())
 	if err == nil {
 		f.s.stall(ModeRemove, f.Type())
 	}
 	f.s.mu.Lock()
 	defer f.s.mu.Unlock()
 	if err == nil {
 		f.assertOpen()
 		f.s.countNB(ModeRemove, f.Type(), 0)
 		err = f.File.Remove()
 	}
 	if err != nil {
 		f.s.logI("file remove failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
 	} else {
 		f.s.logI("file removed, num=%d type=%v", f.Num(), f.Type())
 	}
 	return
 }

 type Storage struct {
 	storage.Storage
 	closeFn func() error

 	lmu sync.Mutex
 	lb  bytes.Buffer

 	mu sync.Mutex
 	// Open files, true=writer, false=reader
 	opens         map[uint64]bool
 	counters      [flattenCount]int
 	bytesCounter  [flattenCount]int64
 	emulatedError [flattenCount]error
 	stallCond     sync.Cond
 	stalled       [flattenCount]bool
 }

 func (s *Storage) log(skip int, str string) {
 	s.lmu.Lock()
 	defer s.lmu.Unlock()
 	_, file, line, ok := runtime.Caller(skip + 2)
 	if ok {
 		// Truncate file name at last file name separator.
 		if index := strings.LastIndex(file, "/"); index >= 0 {
 			file = file[index+1:]
 		} else if index = strings.LastIndex(file, "\\"); index >= 0 {
 			file = file[index+1:]
 		}
 	} else {
 		file = "???"
 		line = 1
 	}
 	fmt.Fprintf(&s.lb, "%s:%d: ", file, line)
 	lines := strings.Split(str, "\n")
 	if l := len(lines); l > 1 && lines[l-1] == "" {
 		lines = lines[:l-1]
 	}
 	for i, line := range lines {
 		if i > 0 {
 			s.lb.WriteString("\n\t")
 		}
 		s.lb.WriteString(line)
 	}
 	s.lb.WriteByte('\n')
 }

 func (s *Storage) logISkip(skip int, format string, args ...interface{}) {
 	pc, _, _, ok := runtime.Caller(skip + 1)
 	if ok {
 		if f := runtime.FuncForPC(pc); f != nil {
 			fname := f.Name()
 			if index := strings.LastIndex(fname, "."); index >= 0 {
 				fname = fname[index+1:]
 			}
 			format = fname + ": " + format
 		}
 	}
 	s.log(skip+1, fmt.Sprintf(format, args...))
 }

 func (s *Storage) logI(format string, args ...interface{}) {
 	s.logISkip(1, format, args...)
 }

 func (s *Storage) Log(str string) {
 	s.log(1, "Log: "+str)
 	s.Storage.Log(str)
 }

 func (s *Storage) Lock() (r util.Releaser, err error) {
 	r, err = s.Storage.Lock()
 	if err != nil {
 		s.logI("storage locking failed, err=%v", err)
 	} else {
 		s.logI("storage locked")
 		r = storageLock{s, r}
 	}
 	return
 }

 func (s *Storage) GetFile(num uint64, t storage.FileType) storage.File {
 	return &file{s, s.Storage.GetFile(num, t)}
 }

 func (s *Storage) GetFiles(t storage.FileType) (files []storage.File, err error) {
 	rfiles, err := s.Storage.GetFiles(t)
 	if err != nil {
 		s.logI("get files failed, err=%v", err)
 		return
 	}
 	files = make([]storage.File, len(rfiles))
 	for i, f := range rfiles {
 		files[i] = &file{s, f}
 	}
 	s.logI("get files, type=0x%x count=%d", int(t), len(files))
 	return
 }

 func (s *Storage) GetManifest() (f storage.File, err error) {
 	manifest, err := s.Storage.GetManifest()
 	if err != nil {
 		if !os.IsNotExist(err) {
 			s.logI("get manifest failed, err=%v", err)
 		}
 		return
 	}
 	s.logI("get manifest, num=%d", manifest.Num())
 	return &file{s, manifest}, nil
 }

 func (s *Storage) SetManifest(f storage.File) error {
 	f_, ok := f.(*file)
 	ExpectWithOffset(1, ok).To(BeTrue())
 	ExpectWithOffset(1, f_.Type()).To(Equal(storage.TypeManifest))
 	err := s.Storage.SetManifest(f_.File)
 	if err != nil {
 		s.logI("set manifest failed, err=%v", err)
 	} else {
 		s.logI("set manifest, num=%d", f_.Num())
 	}
 	return err
 }

 func (s *Storage) openFiles() string {
 	out := "Open files:"
 	for x, writer := range s.opens {
 		num, t := unpackFile(x)
 		out += fmt.Sprintf("\n · num=%d type=%v writer=%v", num, t, writer)
 	}
 	return out
 }

 func (s *Storage) Close() error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	ExpectWithOffset(1, s.opens).To(BeEmpty(), s.openFiles())
 	err := s.Storage.Close()
 	if err != nil {
 		s.logI("storage closing failed, err=%v", err)
 	} else {
 		s.logI("storage closed")
 	}
 	if s.closeFn != nil {
 		if err1 := s.closeFn(); err1 != nil {
 			s.logI("close func error, err=%v", err1)
 		}
 	}
 	return err
 }

 func (s *Storage) countNB(m StorageMode, t storage.FileType, n int) {
 	s.counters[flattenType(m, t)]++
 	s.bytesCounter[flattenType(m, t)] += int64(n)
 }

 func (s *Storage) count(m StorageMode, t storage.FileType, n int) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	s.countNB(m, t, n)
 }

 func (s *Storage) ResetCounter(m StorageMode, t storage.FileType) {
 	for _, x := range listFlattenType(m, t) {
 		s.counters[x] = 0
 		s.bytesCounter[x] = 0
 	}
 }

 func (s *Storage) Counter(m StorageMode, t storage.FileType) (count int, bytes int64) {
 	for _, x := range listFlattenType(m, t) {
 		count += s.counters[x]
 		bytes += s.bytesCounter[x]
 	}
 	return
 }

 func (s *Storage) emulateError(m StorageMode, t storage.FileType) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	err := s.emulatedError[flattenType(m, t)]
 	if err != nil {
 		return emulatedError{err}
 	}
 	return nil
 }

 func (s *Storage) EmulateError(m StorageMode, t storage.FileType, err error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	for _, x := range listFlattenType(m, t) {
 		s.emulatedError[x] = err
 	}
 }

 func (s *Storage) stall(m StorageMode, t storage.FileType) {
 	x := flattenType(m, t)
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	for s.stalled[x] {
 		s.stallCond.Wait()
 	}
 }

 func (s *Storage) Stall(m StorageMode, t storage.FileType) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	for _, x := range listFlattenType(m, t) {
 		s.stalled[x] = true
 	}
 }

 func (s *Storage) Release(m StorageMode, t storage.FileType) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	for _, x := range listFlattenType(m, t) {
 		s.stalled[x] = false
 	}
 	s.stallCond.Broadcast()
 }

 func NewStorage() *Storage {
 	var stor storage.Storage
 	var closeFn func() error
 	if storageUseFS {
 		for {
 			storageMu.Lock()
 			num := storageNum
 			storageNum++
 			storageMu.Unlock()
 			path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
 			if _, err := os.Stat(path); os.IsNotExist(err) {
 				stor, err = storage.OpenFile(path)
 				ExpectWithOffset(1, err).NotTo(HaveOccurred(), "creating storage at %s", path)
 				closeFn = func() error {
 					if storageKeepFS {
 						return nil
 					}
 					return os.RemoveAll(path)
 				}
 				break
 			}
 		}
 	} else {
 		stor = storage.NewMemStorage()
 	}
 	s := &Storage{
 		Storage: stor,
 		closeFn: closeFn,
 		opens:   make(map[uint64]bool),
 	}
 	s.stallCond.L = &s.mu
 	return s
 }
	// Copyright (c) 2014, Suryandaru Triandana <syndtr@gmail.com>
	// All rights reserved.
	//
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package testutil

	import (
	"bytes"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"sync"

	. "github.com/onsi/gomega"

	"github.com/syndtr/goleveldb/leveldb/storage"
	"github.com/syndtr/goleveldb/leveldb/util"
	)

	var (
	storageMu sync.Mutex
	storageUseFS bool = true
	storageKeepFS bool = false
	storageNum int
	)

	type StorageMode int

	const (
	ModeOpen StorageMode = 1 << iota
	ModeCreate
	ModeRemove
	ModeRead
	ModeWrite
	ModeSync
	ModeClose
	)

	const (
	modeOpen = iota
	modeCreate
	modeRemove
	modeRead
	modeWrite
	modeSync
	modeClose

	modeCount
	)

	const (
	typeManifest = iota
	typeJournal
	typeTable
	typeTemp

	typeCount
	)

	const flattenCount = modeCount * typeCount

	func flattenType(m StorageMode, t storage.FileType) int {
	var x int
	switch m {
	case ModeOpen:
	x = modeOpen
	case ModeCreate:
	x = modeCreate
	case ModeRemove:
	x = modeRemove
	case ModeRead:
	x = modeRead
	case ModeWrite:
	x = modeWrite
	case ModeSync:
	x = modeSync
	case ModeClose:
	x = modeClose
	default:
	panic("invalid storage mode")
	}
	x *= typeCount
	switch t {
	case storage.TypeManifest:
	return x + typeManifest
	case storage.TypeJournal:
	return x + typeJournal
	case storage.TypeTable:
	return x + typeTable
	case storage.TypeTemp:
	return x + typeTemp
	default:
	panic("invalid file type")
	}
	}

	func listFlattenType(m StorageMode, t storage.FileType) []int {
	ret := make([]int, 0, flattenCount)
	add := func(x int) {
	x *= typeCount
	switch {
	case t&storage.TypeManifest != 0:
	ret = append(ret, x+typeManifest)
	case t&storage.TypeJournal != 0:
	ret = append(ret, x+typeJournal)
	case t&storage.TypeTable != 0:
	ret = append(ret, x+typeTable)
	case t&storage.TypeTemp != 0:
	ret = append(ret, x+typeTemp)
	}
	}
	switch {
	case m&ModeOpen != 0:
	add(modeOpen)
	case m&ModeCreate != 0:
	add(modeCreate)
	case m&ModeRemove != 0:
	add(modeRemove)
	case m&ModeRead != 0:
	add(modeRead)
	case m&ModeWrite != 0:
	add(modeWrite)
	case m&ModeSync != 0:
	add(modeSync)
	case m&ModeClose != 0:
	add(modeClose)
	}
	return ret
	}

	func packFile(num uint64, t storage.FileType) uint64 {
	if num>>(64-typeCount) != 0 {
	panic("overflow")
	}
	return num<<typeCount \| uint64(t)
	}

	func unpackFile(x uint64) (uint64, storage.FileType) {
	return x >> typeCount, storage.FileType(x) & storage.TypeAll
	}

	type emulatedError struct {
	err error
	}

	func (err emulatedError) Error() string {
	return fmt.Sprintf("emulated storage error: %v", err.err)
	}

	type storageLock struct {
	s *Storage
	r util.Releaser
	}

	func (l storageLock) Release() {
	l.r.Release()
	l.s.logI("storage lock released")
	}

	type reader struct {
	f *file
	storage.Reader
	}

	func (r *reader) Read(p []byte) (n int, err error) {
	err = r.f.s.emulateError(ModeRead, r.f.Type())
	if err == nil {
	r.f.s.stall(ModeRead, r.f.Type())
	n, err = r.Reader.Read(p)
	}
	r.f.s.count(ModeRead, r.f.Type(), n)
	if err != nil && err != io.EOF {
	r.f.s.logI("read error, num=%d type=%v n=%d err=%v", r.f.Num(), r.f.Type(), n, err)
	}
	return
	}

	func (r *reader) ReadAt(p []byte, off int64) (n int, err error) {
	err = r.f.s.emulateError(ModeRead, r.f.Type())
	if err == nil {
	r.f.s.stall(ModeRead, r.f.Type())
	n, err = r.Reader.ReadAt(p, off)
	}
	r.f.s.count(ModeRead, r.f.Type(), n)
	if err != nil && err != io.EOF {
	r.f.s.logI("readAt error, num=%d type=%v offset=%d n=%d err=%v", r.f.Num(), r.f.Type(), off, n, err)
	}
	return
	}

	func (r *reader) Close() (err error) {
	return r.f.doClose(r.Reader)
	}

	type writer struct {
	f *file
	storage.Writer
	}

	func (w *writer) Write(p []byte) (n int, err error) {
	err = w.f.s.emulateError(ModeWrite, w.f.Type())
	if err == nil {
	w.f.s.stall(ModeWrite, w.f.Type())
	n, err = w.Writer.Write(p)
	}
	w.f.s.count(ModeWrite, w.f.Type(), n)
	if err != nil && err != io.EOF {
	w.f.s.logI("write error, num=%d type=%v n=%d err=%v", w.f.Num(), w.f.Type(), n, err)
	}
	return
	}

	func (w *writer) Sync() (err error) {
	err = w.f.s.emulateError(ModeSync, w.f.Type())
	if err == nil {
	w.f.s.stall(ModeSync, w.f.Type())
	err = w.Writer.Sync()
	}
	w.f.s.count(ModeSync, w.f.Type(), 0)
	if err != nil {
	w.f.s.logI("sync error, num=%d type=%v err=%v", w.f.Num(), w.f.Type(), err)
	}
	return
	}

	func (w *writer) Close() (err error) {
	return w.f.doClose(w.Writer)
	}

	type file struct {
	s *Storage
	storage.File
	}

	func (f *file) pack() uint64 {
	return packFile(f.Num(), f.Type())
	}

	func (f *file) assertOpen() {
	ExpectWithOffset(2, f.s.opens).NotTo(HaveKey(f.pack()), "File open, num=%d type=%v writer=%v", f.Num(), f.Type(), f.s.opens[f.pack()])
	}

	func (f *file) doClose(closer io.Closer) (err error) {
	err = f.s.emulateError(ModeClose, f.Type())
	if err == nil {
	f.s.stall(ModeClose, f.Type())
	}
	f.s.mu.Lock()
	defer f.s.mu.Unlock()
	if err == nil {
	ExpectWithOffset(2, f.s.opens).To(HaveKey(f.pack()), "File closed, num=%d type=%v", f.Num(), f.Type())
	err = closer.Close()
	}
	f.s.countNB(ModeClose, f.Type(), 0)
	writer := f.s.opens[f.pack()]
	if err != nil {
	f.s.logISkip(1, "file close failed, num=%d type=%v writer=%v err=%v", f.Num(), f.Type(), writer, err)
	} else {
	f.s.logISkip(1, "file closed, num=%d type=%v writer=%v", f.Num(), f.Type(), writer)
	delete(f.s.opens, f.pack())
	}
	return
	}

	func (f *file) Open() (r storage.Reader, err error) {
	err = f.s.emulateError(ModeOpen, f.Type())
	if err == nil {
	f.s.stall(ModeOpen, f.Type())
	}
	f.s.mu.Lock()
	defer f.s.mu.Unlock()
	if err == nil {
	f.assertOpen()
	f.s.countNB(ModeOpen, f.Type(), 0)
	r, err = f.File.Open()
	}
	if err != nil {
	f.s.logI("file open failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
	} else {
	f.s.logI("file opened, num=%d type=%v", f.Num(), f.Type())
	f.s.opens[f.pack()] = false
	r = &reader{f, r}
	}
	return
	}

	func (f *file) Create() (w storage.Writer, err error) {
	err = f.s.emulateError(ModeCreate, f.Type())
	if err == nil {
	f.s.stall(ModeCreate, f.Type())
	}
	f.s.mu.Lock()
	defer f.s.mu.Unlock()
	if err == nil {
	f.assertOpen()
	f.s.countNB(ModeCreate, f.Type(), 0)
	w, err = f.File.Create()
	}
	if err != nil {
	f.s.logI("file create failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
	} else {
	f.s.logI("file created, num=%d type=%v", f.Num(), f.Type())
	f.s.opens[f.pack()] = true
	w = &writer{f, w}
	}
	return
	}

	func (f *file) Remove() (err error) {
	err = f.s.emulateError(ModeRemove, f.Type())
	if err == nil {
	f.s.stall(ModeRemove, f.Type())
	}
	f.s.mu.Lock()
	defer f.s.mu.Unlock()
	if err == nil {
	f.assertOpen()
	f.s.countNB(ModeRemove, f.Type(), 0)
	err = f.File.Remove()
	}
	if err != nil {
	f.s.logI("file remove failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
	} else {
	f.s.logI("file removed, num=%d type=%v", f.Num(), f.Type())
	}
	return
	}

	type Storage struct {
	storage.Storage
	closeFn func() error

	lmu sync.Mutex
	lb bytes.Buffer

	mu sync.Mutex
	// Open files, true=writer, false=reader
	opens map[uint64]bool
	counters [flattenCount]int
	bytesCounter [flattenCount]int64
	emulatedError [flattenCount]error
	stallCond sync.Cond
	stalled [flattenCount]bool
	}

	func (s *Storage) log(skip int, str string) {
	s.lmu.Lock()
	defer s.lmu.Unlock()
	_, file, line, ok := runtime.Caller(skip + 2)
	if ok {
	// Truncate file name at last file name separator.
	if index := strings.LastIndex(file, "/"); index >= 0 {
	file = file[index+1:]
	} else if index = strings.LastIndex(file, "\\"); index >= 0 {
	file = file[index+1:]
	}
	} else {
	file = "???"
	line = 1
	}
	fmt.Fprintf(&s.lb, "%s:%d: ", file, line)
	lines := strings.Split(str, "\n")
	if l := len(lines); l > 1 && lines[l-1] == "" {
	lines = lines[:l-1]
	}
	for i, line := range lines {
	if i > 0 {
	s.lb.WriteString("\n\t")
	}
	s.lb.WriteString(line)
	}
	s.lb.WriteByte('\n')
	}

	func (s *Storage) logISkip(skip int, format string, args ...interface{}) {
	pc, _, _, ok := runtime.Caller(skip + 1)
	if ok {
	if f := runtime.FuncForPC(pc); f != nil {
	fname := f.Name()
	if index := strings.LastIndex(fname, "."); index >= 0 {
	fname = fname[index+1:]
	}
	format = fname + ": " + format
	}
	}
	s.log(skip+1, fmt.Sprintf(format, args...))
	}

	func (s *Storage) logI(format string, args ...interface{}) {
	s.logISkip(1, format, args...)
	}

	func (s *Storage) Log(str string) {
	s.log(1, "Log: "+str)
	s.Storage.Log(str)
	}

	func (s *Storage) Lock() (r util.Releaser, err error) {
	r, err = s.Storage.Lock()
	if err != nil {
	s.logI("storage locking failed, err=%v", err)
	} else {
	s.logI("storage locked")
	r = storageLock{s, r}
	}
	return
	}

	func (s *Storage) GetFile(num uint64, t storage.FileType) storage.File {
	return &file{s, s.Storage.GetFile(num, t)}
	}

	func (s *Storage) GetFiles(t storage.FileType) (files []storage.File, err error) {
	rfiles, err := s.Storage.GetFiles(t)
	if err != nil {
	s.logI("get files failed, err=%v", err)
	return
	}
	files = make([]storage.File, len(rfiles))
	for i, f := range rfiles {
	files[i] = &file{s, f}
	}
	s.logI("get files, type=0x%x count=%d", int(t), len(files))
	return
	}

	func (s *Storage) GetManifest() (f storage.File, err error) {
	manifest, err := s.Storage.GetManifest()
	if err != nil {
	if !os.IsNotExist(err) {
	s.logI("get manifest failed, err=%v", err)
	}
	return
	}
	s.logI("get manifest, num=%d", manifest.Num())
	return &file{s, manifest}, nil
	}

	func (s *Storage) SetManifest(f storage.File) error {
	f_, ok := f.(*file)
	ExpectWithOffset(1, ok).To(BeTrue())
	ExpectWithOffset(1, f_.Type()).To(Equal(storage.TypeManifest))
	err := s.Storage.SetManifest(f_.File)
	if err != nil {
	s.logI("set manifest failed, err=%v", err)
	} else {
	s.logI("set manifest, num=%d", f_.Num())
	}
	return err
	}

	func (s *Storage) openFiles() string {
	out := "Open files:"
	for x, writer := range s.opens {
	num, t := unpackFile(x)
	out += fmt.Sprintf("\n · num=%d type=%v writer=%v", num, t, writer)
	}
	return out
	}

	func (s *Storage) Close() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	ExpectWithOffset(1, s.opens).To(BeEmpty(), s.openFiles())
	err := s.Storage.Close()
	if err != nil {
	s.logI("storage closing failed, err=%v", err)
	} else {
	s.logI("storage closed")
	}
	if s.closeFn != nil {
	if err1 := s.closeFn(); err1 != nil {
	s.logI("close func error, err=%v", err1)
	}
	}
	return err
	}

	func (s *Storage) countNB(m StorageMode, t storage.FileType, n int) {
	s.counters[flattenType(m, t)]++
	s.bytesCounter[flattenType(m, t)] += int64(n)
	}

	func (s *Storage) count(m StorageMode, t storage.FileType, n int) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.countNB(m, t, n)
	}

	func (s *Storage) ResetCounter(m StorageMode, t storage.FileType) {
	for _, x := range listFlattenType(m, t) {
	s.counters[x] = 0
	s.bytesCounter[x] = 0
	}
	}

	func (s *Storage) Counter(m StorageMode, t storage.FileType) (count int, bytes int64) {
	for _, x := range listFlattenType(m, t) {
	count += s.counters[x]
	bytes += s.bytesCounter[x]
	}
	return
	}

	func (s *Storage) emulateError(m StorageMode, t storage.FileType) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	err := s.emulatedError[flattenType(m, t)]
	if err != nil {
	return emulatedError{err}
	}
	return nil
	}

	func (s *Storage) EmulateError(m StorageMode, t storage.FileType, err error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	for _, x := range listFlattenType(m, t) {
	s.emulatedError[x] = err
	}
	}

	func (s *Storage) stall(m StorageMode, t storage.FileType) {
	x := flattenType(m, t)
	s.mu.Lock()
	defer s.mu.Unlock()
	for s.stalled[x] {
	s.stallCond.Wait()
	}
	}

	func (s *Storage) Stall(m StorageMode, t storage.FileType) {
	s.mu.Lock()
	defer s.mu.Unlock()
	for _, x := range listFlattenType(m, t) {
	s.stalled[x] = true
	}
	}

	func (s *Storage) Release(m StorageMode, t storage.FileType) {
	s.mu.Lock()
	defer s.mu.Unlock()
	for _, x := range listFlattenType(m, t) {
	s.stalled[x] = false
	}
	s.stallCond.Broadcast()
	}

	func NewStorage() *Storage {
	var stor storage.Storage
	var closeFn func() error
	if storageUseFS {
	for {
	storageMu.Lock()
	num := storageNum
	storageNum++
	storageMu.Unlock()
	path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
	if _, err := os.Stat(path); os.IsNotExist(err) {
	stor, err = storage.OpenFile(path)
	ExpectWithOffset(1, err).NotTo(HaveOccurred(), "creating storage at %s", path)
	closeFn = func() error {
	if storageKeepFS {
	return nil
	}
	return os.RemoveAll(path)
	}
	break
	}
	}
	} else {
	stor = storage.NewMemStorage()
	}
	s := &Storage{
	Storage: stor,
	closeFn: closeFn,
	opens: make(map[uint64]bool),
	}
	s.stallCond.L = &s.mu
	return s
	}