Revert "Use a monitor process to handle panics and restarts (fixes #586)"

This reverts commit 10f0713257.

Conflicts:
	cmd/syncthing/monitor.go

.gitignore

@@ -4,14 +4,9 @@ syncthing.exe
 *.zip
 *.asc
 *.sublime*
-.idea/
 .jshintrc
 coverage.out
 files/pidx
 bin
 perfstats*.csv
 coverage.xml
-!gui/scripts/syncthing
-.DS_Store
-syncthing.md5
-syncthing.exe.md5

.mailmap

@@ -1 +0,0 @@
-NICKS

AUTHORS

@@ -1,39 +0,0 @@
-# This is the official list of Syncthing authors for copyright purposes.
-
-Aaron Bieber <qbit@deftly.net>
-Alexander Graf <register-github@alex-graf.de>
-Andrew Dunham <andrew@du.nham.ca>
-Audrius Butkevicius <audrius.butkevicius@gmail.com>
-Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
-Ben Schulz <ueomkail@gmail.com> <uok@users.noreply.github.com>
-Ben Sidhom <bsidhom@gmail.com>
-Brandon Philips <brandon@ifup.org>
-Brendan Long <self@brendanlong.com>
-Caleb Callaway <enlightened.despot@gmail.com>
-Cathryne Linenweaver <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
-Chris Joel <chris@scriptolo.gy>
-Daniel Martí <mvdan@mvdan.cc>
-Dennis Wilson <dw@risu.io>
-Dominik Heidler <dominik@heidler.eu>
-Emil Hessman <emil@hessman.se>
-Federico Castagnini <federico.castagnini@gmail.com>
-Felix Ableitner <me@nutomic.com>
-Felix Unterpaintner <bigbear2nd@gmail.com>
-Gilli Sigurdsson <gilli@vx.is>
-Jakob Borg <jakob@nym.se>
-James Patterson <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
-Jens Diemer <github.com@jensdiemer.de> <git@jensdiemer.de>
-Jochen Voss <voss@seehuhn.de>
-Lode Hoste <zillode@zillode.be>
-Marcin Dziadus <dziadus.marcin@gmail.com>
-Michael Tilli <pyfisch@gmail.com>
-Peter Hoeg <peter@speartail.com>
-Philippe Schommers <philippe@schommers.be>
-Phill Luby <phill.luby@newredo.com>
-Piotr Bejda <piotrb10@gmail.com>
-Ryan Sullivan <kayoticsully@gmail.com>
-Tim Abell <tim@timwise.co.uk>
-Tomas Cerveny <kozec@kozec.com>
-Tully Robinson <tully@tojr.org>
-Veeti Paananen <veeti.paananen@rojekti.fi>
-Vil Brekin <vilbrekin@gmail.com>

CONDUCT.md

@@ -1,92 +0,0 @@
-## Conduct
-
-* We are committed to providing a friendly, safe and welcoming
-  environment for all, regardless of gender, sexual orientation,
-  disability, ethnicity, religion, or similar personal characteristic.
-
-* On IRC, please avoid using overtly sexual nicknames or other nicknames
-  that might detract from a friendly, safe and welcoming environment for
-  all.
-
-* Please be kind and courteous. There's no need to be mean or rude.
-
-* Respect that people have differences of opinion and that every design
-  or implementation choice carries a trade-off and numerous costs. There
-  is seldom a right answer.
-
-* Please keep unstructured critique to a minimum. If you have solid
-  ideas you want to experiment with, make a fork and see how it works.
-
-* We will exclude you from interaction if you insult, demean or harass
-  anyone. That is not welcome behaviour. We interpret the term
-  "harassment" as including the definition in the <a
-  href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>;
-  if you have any lack of clarity about what might be included in that
-  concept, please read their definition. In particular, we don't
-  tolerate behavior that excludes people in socially marginalized
-  groups.
-
-* Private harassment is also unacceptable. No matter who you are, if you
-  feel you have been or are being harassed or made uncomfortable by a
-  community member, please contact one of the channel ops or any of the
-  Syncthing core team immediately. Whether you're a regular  contributor
-  or a newcomer, we care about making this community a safe place for
-  you and we've got your back.
-
-* Likewise any spamming, trolling, flaming, baiting or other
-  attention-stealing behaviour is not welcome.
-
-## Moderation
-
-These are the policies for upholding our community's standards of
-conduct in our communication channels, most notably in Syncthing-related
-IRC channels and on the web forum.
-
-1. Remarks that violate the Syncthing standards of conduct, including
-   hateful, hurtful, oppressive, or exclusionary remarks, are not
-   allowed. (Cursing is allowed, but never targeting another user, and
-   never in a hateful manner.)
-
-2. Remarks that moderators find inappropriate, whether listed in the
-   code of conduct or not, are also not allowed.
-
-3. Moderators will first respond to such remarks with a warning.
-
-4. If the warning is unheeded, the user will be "kicked," i.e., kicked
-   out of the communication channel to cool off.
-
-5. If the user comes back and continues to make trouble, they will be
-   banned, i.e., indefinitely excluded.
-
-6. Moderators may choose at their discretion to un-ban the user if it
-   was a first offense and they offer the offended party a genuine
-   apology.
-
-7. If a moderator bans someone and you think it was unjustified, please
-   take it up with that moderator, or with a different moderator, **in
-   private**. Complaints about bans in-channel are not allowed.
-
-8. Moderators are held to a higher standard than other community
-   members. If a moderator creates an inappropriate situation, they
-   should expect less leeway than others.
-
-In the Syncthing community we strive to go the extra step to look out
-for each other. Don't just aim to be technically unimpeachable, try to
-be your best self. In particular, avoid flirting with offensive or
-sensitive issues, particularly if they're off-topic; this all too
-often leads to unnecessary fights, hurt feelings, and damaged trust;
-worse, it can drive people away from the community entirely.
-
-And if someone takes issue with something you said or did, resist the
-urge to be defensive. Just stop doing what it was they complained about
-and apologize. Even if you feel you were misinterpreted or unfairly
-accused, chances are good there was something you could've communicated
-better — remember that it's your responsibility to make your fellow
-community members comfortable. Everyone wants to get along and we are
-all here first and foremost because we want to talk about cool
-technology. You will find that people will be eager to assume good
-intent and forgive as long as you earn their trust.
-
-*Adapted from the [Rust Code of Conduct](https://github.com/rust-lang/rust/wiki/Note-development-policy#conduct)*
-
-*Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)*

CONTRIBUTING.md

@@ -12,7 +12,7 @@ least the following:
  - What operating system, operating system version and version of
    Syncthing you are running
 
- - The same for other connected devices, where relevant
+ - The same for other connected nodes, where relevant
 
  - Screenshot if the issue concerns something visible in the GUI
 
@@ -31,77 +31,24 @@ latest info on Transifex.
 
 ## Contributing Code
 
-Every contribution is welcome. If you want to contribute but are unsure
-where to start, any open issues are fair game! Be prepared for a
-[certain amount of review](https://discourse.syncthing.net/t/733); it's
-all in the name of quality. :) Following the points below will make this
-a smoother process.
-
-Individuals making significant and valuable contributions are given
-commit-access to the project. If you make a significant contribution and
-are not considered for commit-access, please contact any of the
-Syncthing core team members.
-
-All nontrivial contributions should go through the pull request
-mechanism for internal review. Determining what is "nontrivial" is left
-at the discretion of the contributor.
-
-### Authorship
-
-All code authors are listed in the AUTHORS file. Commits must be made
-with the same name and email as listed in the AUTHORS file. To
-accomplish this, ensure that your git configuration is set correctly
-prior to making your first commit;
-
-    $ git config --global user.name "Jane Doe"
-    $ git config --global user.email janedoe@example.com
-
-You must be reachable on the given email address. If you do not wish to
-use your real name for whatever reason, using a nickname or pseudonym is
-perfectly acceptable.
-
-### Core Team
-
-The Syncthing core team currently consists of the following members;
-
- - Jakob Borg (@calmh)
- - Audrius Butkevicius (@AudriusButkevicius)
-
-## Coding Style
-
-- Follow the conventions laid out in [Effective Go](https://golang.org/doc/effective_go.html)
-  as much as makes sense.
-
-- All text files use Unix line endings.
-
-- Each commit should be `go fmt` clean.
-
-- The commit message subject should be a single short sentence
-  describing the change, starting with a capital letter.
-
-- Commits that resolve an existing issue must include the issue number
-  as `(fixes #123)` at the end of the commit message subject.
-
-- Imports are grouped per `goimports` standard; that is, standard
-  library first, then third party libraries after a blank line.
-
-- A contribution solving a single issue or introducing a single new
-  feature should probably be a single commit based on the current
-  `master` branch. You may be asked to "rebase" or "squash" your pull
-  request to make sure this is the case, especially if there have been
-  amendments during review.
+Please do contribute! If you want to contribute but are unsure where to
+start, the [Contributions Needed
+topic](http://discourse.syncthing.net/t/49) lists areas in need of
+attention. In general, any open issues are fair game! Be prepared for a
+[certain amount of
+review](https://discourse.syncthing.net/t/733); it's all in the name of
+quality. :)
 
 ## Licensing
 
-All contributions are made under the same GPL license as the rest of the
-project, except documentation, user interface text and translation
-strings which are licensed under the Creative Commons Attribution 4.0
-International License. You retain the copyright to code you have
-written.
+All contributions are made under the same MIT License as the rest of the
+project, except documentation which is licensed under the Creative
+Commons Attribution 4.0 International License. You retain the copyright
+to code you have written.
 
 When accepting your first contribution, the maintainer of the project
-will ensure that you are added to the AUTHORS file. You are welcome to
-add yourself as a separate commit in your first pull request.
+will ensure that you are added to the CONTRIBUTORS file. You are welcome
+to add yourself as a separate commit in your first pull request.
 
 ## Building
 
@@ -131,10 +78,16 @@ signed by GPG key BCE524C7.
 
 Yes please!
 
+## Style
+
+ - `go fmt`
+
+ - Unix line breaks
+
 ## Documentation
 
 [Over here!](http://discourse.syncthing.net/category/documentation)
 
 ## License
 
-GPLv3
+MIT

CONTRIBUTORS

@@ -0,0 +1,16 @@
+Aaron Bieber <qbit@deftly.net>
+Alexander Graf <register-github@alex-graf.de>
+Andrew Dunham <andrew@du.nham.ca>
+Audrius Butkevicius <audrius.butkevicius@gmail.com>
+Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
+Ben Sidhom <bsidhom@gmail.com>
+Brandon Philips <brandon@ifup.org>
+Gilli Sigurdsson <gilli@vx.is>
+James Patterson <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
+Jens Diemer <github.com@jensdiemer.de> <git@jensdiemer.de>
+Marcin Dziadus <dziadus.marcin@gmail.com>
+Michael Tilli <pyfisch@gmail.com>
+Philippe Schommers <philippe@schommers.be>
+Ryan Sullivan <kayoticsully@gmail.com>
+Tully Robinson <tully@tojr.org>
+Veeti Paananen <veeti.paananen@rojekti.fi>

Godeps/Godeps.json

@@ -1,29 +1,47 @@
 {
 	"ImportPath": "github.com/syncthing/syncthing",
-	"GoVersion": "go1.4",
+	"GoVersion": "go1.3.1",
 	"Packages": [
 		"./cmd/..."
 	],
 	"Deps": [
 		{
-			"ImportPath": "github.com/AudriusButkevicius/lfu-go",
-			"Rev": "164bcecceb92fd6037f4d18a8d97b495ec6ef669"
+			"ImportPath": "bitbucket.org/kardianos/osext",
+			"Comment": "null-13",
+			"Rev": "5d3ddcf53a508cc2f7404eaebf546ef2cb5cdb6e"
+		},
+		{
+			"ImportPath": "code.google.com/p/go.crypto/bcrypt",
+			"Comment": "null-216",
+			"Rev": "41cd4647fccc72b0b79ef1bd1fe6735e718257cd"
+		},
+		{
+			"ImportPath": "code.google.com/p/go.crypto/blowfish",
+			"Comment": "null-216",
+			"Rev": "41cd4647fccc72b0b79ef1bd1fe6735e718257cd"
+		},
+		{
+			"ImportPath": "code.google.com/p/go.text/transform",
+			"Comment": "null-90",
+			"Rev": "d65bffbc88a153d23a6d2a864531e6e7c2cde59b"
+		},
+		{
+			"ImportPath": "code.google.com/p/go.text/unicode/norm",
+			"Comment": "null-90",
+			"Rev": "d65bffbc88a153d23a6d2a864531e6e7c2cde59b"
+		},
+		{
+			"ImportPath": "code.google.com/p/snappy-go/snappy",
+			"Comment": "null-15",
+			"Rev": "12e4b4183793ac4b061921e7980845e750679fd0"
 		},
 		{
 			"ImportPath": "github.com/bkaradzic/go-lz4",
-			"Rev": "93a831dcee242be64a9cc9803dda84af25932de7"
-		},
-		{
-			"ImportPath": "github.com/calmh/logger",
-			"Rev": "f50d32b313bec2933a3e1049f7416a29f3413d29"
-		},
-		{
-			"ImportPath": "github.com/calmh/osext",
-			"Rev": "9bf61584e5f1f172e8766ddc9022d9c401faaa5e"
+			"Rev": "77e2ba877bde9da31213bec75dbbe197fa507c21"
 		},
 		{
 			"ImportPath": "github.com/calmh/xdr",
-			"Rev": "214788d8fedfc310c18eca9ed12be408a5054cd5"
+			"Rev": "a597b63b87d6140f79084c8aab214b4d533833a1"
 		},
 		{
 			"ImportPath": "github.com/juju/ratelimit",
@@ -31,11 +49,7 @@
 		},
 		{
 			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "63c9e642efad852f49e20a6f90194cae112fd2ac"
-		},
-		{
-			"ImportPath": "github.com/syndtr/gosnappy/snappy",
-			"Rev": "ce8acff4829e0c2458a67ead32390ac0a381c862"
+			"Rev": "2b99e8d4757bf06eeab1b0485d80b8ae1c088874"
 		},
 		{
 			"ImportPath": "github.com/vitrun/qart/coding",
@@ -48,22 +62,6 @@
 		{
 			"ImportPath": "github.com/vitrun/qart/qr",
 			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/bcrypt",
-			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/blowfish",
-			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
-		},
-		{
-			"ImportPath": "golang.org/x/text/transform",
-			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
-		},
-		{
-			"ImportPath": "golang.org/x/text/unicode/norm",
-			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
 		}
 	]
 }

Godeps/_workspace/src/bitbucket.org/kardianos/osext/osext_procfs.go

@@ -2,13 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build linux netbsd openbsd solaris
+// +build linux netbsd openbsd
 
 package osext
 
 import (
 	"errors"
-	"fmt"
 	"os"
 	"runtime"
 )
@@ -21,8 +20,6 @@ func executable() (string, error) {
 		return os.Readlink("/proc/curproc/exe")
 	case "openbsd":
 		return os.Readlink("/proc/curproc/file")
-	case "solaris":
-		return os.Readlink(fmt.Sprintf("/proc/%d/path/a.out", os.Getpid()))
 	}
 	return "", errors.New("ExecPath not implemented for " + runtime.GOOS)
 }

Godeps/_workspace/src/code.google.com/p/go.crypto/bcrypt/bcrypt.go

@@ -8,11 +8,11 @@ package bcrypt
 
 // The code is a port of Provos and Mazières's C implementation.
 import (
+	"code.google.com/p/go.crypto/blowfish"
 	"crypto/rand"
 	"crypto/subtle"
 	"errors"
 	"fmt"
-	"golang.org/x/crypto/blowfish"
 	"io"
 	"strconv"
 )

Godeps/_workspace/src/code.google.com/p/go.text/transform/examples_test.go

@@ -8,8 +8,8 @@ import (
 	"fmt"
 	"unicode"
 
-	"golang.org/x/text/transform"
-	"golang.org/x/text/unicode/norm"
+	"code.google.com/p/go.text/transform"
+	"code.google.com/p/go.text/unicode/norm"
 )
 
 func ExampleRemoveFunc() {

Godeps/_workspace/src/code.google.com/p/go.text/transform/transform.go

@@ -55,17 +55,10 @@ type Transformer interface {
 	// either error may be returned. Other than the error conditions listed
 	// here, implementations are free to report other errors that arise.
 	Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error)
-
-	// Reset resets the state and allows a Transformer to be reused.
-	Reset()
 }
 
-// NopResetter can be embedded by implementations of Transformer to add a nop
-// Reset method.
-type NopResetter struct{}
-
-// Reset implements the Reset method of the Transformer interface.
-func (NopResetter) Reset() {}
+// TODO: Do we require that a Transformer be reusable if it returns a nil error
+// or do we always require a reset after use?  Is Reset mandatory or optional?
 
 // Reader wraps another io.Reader by transforming the bytes read.
 type Reader struct {
@@ -91,9 +84,8 @@ type Reader struct {
 const defaultBufSize = 4096
 
 // NewReader returns a new Reader that wraps r by transforming the bytes read
-// via t. It calls Reset on t.
+// via t.
 func NewReader(r io.Reader, t Transformer) *Reader {
-	t.Reset()
 	return &Reader{
 		r:   r,
 		t:   t,
@@ -178,9 +170,8 @@ type Writer struct {
 }
 
 // NewWriter returns a new Writer that wraps w by transforming the bytes written
-// via t. It calls Reset on t.
+// via t.
 func NewWriter(w io.Writer, t Transformer) *Writer {
-	t.Reset()
 	return &Writer{
 		w:   w,
 		t:   t,
@@ -256,7 +247,7 @@ func (w *Writer) Close() error {
 	return nil
 }
 
-type nop struct{ NopResetter }
+type nop struct{}
 
 func (nop) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := copy(dst, src)
@@ -266,7 +257,7 @@ func (nop) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	return n, n, err
 }
 
-type discard struct{ NopResetter }
+type discard struct{}
 
 func (discard) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	return 0, len(src), nil
@@ -336,16 +327,6 @@ func Chain(t ...Transformer) Transformer {
 	return c
 }
 
-// Reset resets the state of Chain. It calls Reset on all the Transformers.
-func (c *chain) Reset() {
-	for i, l := range c.link {
-		if l.t != nil {
-			l.t.Reset()
-		}
-		c.link[i].p, c.link[i].n = 0, 0
-	}
-}
-
 // Transform applies the transformers of c in sequence.
 func (c *chain) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	// Set up src and dst in the chain.
@@ -444,8 +425,6 @@ func RemoveFunc(f func(r rune) bool) Transformer {
 
 type removeF func(r rune) bool
 
-func (removeF) Reset() {}
-
 // Transform implements the Transformer interface.
 func (t removeF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	for r, sz := rune(0), 0; len(src) > 0; src = src[sz:] {
@@ -457,7 +436,7 @@ func (t removeF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err err
 
 			if sz == 1 {
 				// Invalid rune.
-				if !atEOF && !utf8.FullRune(src) {
+				if !atEOF && !utf8.FullRune(src[nSrc:]) {
 					err = ErrShortSrc
 					break
 				}
@@ -506,14 +485,12 @@ func grow(b []byte, n int) []byte {
 const initialBufSize = 128
 
 // String returns a string with the result of converting s[:n] using t, where
-// n <= len(s). If err == nil, n will be len(s). It calls Reset on t.
+// n <= len(s). If err == nil, n will be len(s).
 func String(t Transformer, s string) (result string, n int, err error) {
 	if s == "" {
 		return "", 0, nil
 	}
 
-	t.Reset()
-
 	// Allocate only once. Note that both dst and src escape when passed to
 	// Transform.
 	buf := [2 * initialBufSize]byte{}
@@ -594,9 +571,8 @@ func String(t Transformer, s string) (result string, n int, err error) {
 }
 
 // Bytes returns a new byte slice with the result of converting b[:n] using t,
-// where n <= len(b). If err == nil, n will be len(b). It calls Reset on t.
+// where n <= len(b). If err == nil, n will be len(b).
 func Bytes(t Transformer, b []byte) (result []byte, n int, err error) {
-	t.Reset()
 	dst := make([]byte, len(b))
 	pDst, pSrc := 0, 0
 	for {

Godeps/_workspace/src/code.google.com/p/go.text/transform/transform_test.go

@@ -16,7 +16,7 @@ import (
 	"unicode/utf8"
 )
 
-type lowerCaseASCII struct{ NopResetter }
+type lowerCaseASCII struct{}
 
 func (lowerCaseASCII) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := len(src)
@@ -34,7 +34,7 @@ func (lowerCaseASCII) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, er
 
 var errYouMentionedX = errors.New("you mentioned X")
 
-type dontMentionX struct{ NopResetter }
+type dontMentionX struct{}
 
 func (dontMentionX) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := len(src)
@@ -52,7 +52,7 @@ func (dontMentionX) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err
 
 // doublerAtEOF is a strange Transformer that transforms "this" to "tthhiiss",
 // but only if atEOF is true.
-type doublerAtEOF struct{ NopResetter }
+type doublerAtEOF struct{}
 
 func (doublerAtEOF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	if !atEOF {
@@ -71,7 +71,7 @@ func (doublerAtEOF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err
 // rleDecode and rleEncode implement a toy run-length encoding: "aabbbbbbbbbb"
 // is encoded as "2a10b". The decoding is assumed to not contain any numbers.
 
-type rleDecode struct{ NopResetter }
+type rleDecode struct{}
 
 func (rleDecode) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 loop:
@@ -104,8 +104,6 @@ loop:
 }
 
 type rleEncode struct {
-	NopResetter
-
 	// allowStutter means that "xxxxxxxx" can be encoded as "5x3x"
 	// instead of always as "8x".
 	allowStutter bool
@@ -138,10 +136,6 @@ func (e rleEncode) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err e
 // trickler consumes all input bytes, but writes a single byte at a time to dst.
 type trickler []byte
 
-func (t *trickler) Reset() {
-	*t = nil
-}
-
 func (t *trickler) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	*t = append(*t, src...)
 	if len(*t) == 0 {
@@ -163,9 +157,6 @@ func (t *trickler) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err e
 // to have some tolerance as long as progress can be detected.
 type delayedTrickler []byte
 
-func (t *delayedTrickler) Reset() {
-	*t = nil
-}
 func (t *delayedTrickler) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	if len(*t) > 0 && len(dst) > 0 {
 		dst[0] = (*t)[0]
@@ -456,6 +447,7 @@ var testCases = []testCase{
 
 func TestReader(t *testing.T) {
 	for _, tc := range testCases {
+		reset(tc.t)
 		r := NewReader(strings.NewReader(tc.src), tc.t)
 		// Differently sized dst and src buffers are not part of the
 		// exported API. We override them manually.
@@ -469,6 +461,13 @@ func TestReader(t *testing.T) {
 	}
 }
 
+func reset(t Transformer) {
+	var dst [128]byte
+	for err := ErrShortDst; err != nil; {
+		_, _, err = t.Transform(dst[:], nil, true)
+	}
+}
+
 func TestWriter(t *testing.T) {
 	tests := append(testCases, chainTests()...)
 	for _, tc := range tests {
@@ -478,6 +477,7 @@ func TestWriter(t *testing.T) {
 		}
 		for _, sz := range sizes {
 			bb := &bytes.Buffer{}
+			reset(tc.t)
 			w := NewWriter(bb, tc.t)
 			// Differently sized dst and src buffers are not part of the
 			// exported API. We override them manually.
@@ -735,7 +735,7 @@ func chainTests() []testCase {
 }
 
 func doTransform(tc testCase) (res string, iter int, err error) {
-	tc.t.Reset()
+	reset(tc.t)
 	dst := make([]byte, tc.dstSize)
 	out, in := make([]byte, 0, 2*len(tc.src)), []byte(tc.src)
 	for {
@@ -884,14 +884,6 @@ func TestRemoveFunc(t *testing.T) {
 			wantIter: 2,
 		},
 
-		{
-			// Test a long buffer greater than the internal buffer size
-			src:      "hello\xcc\xcc\xccworld",
-			srcSize:  13,
-			wantStr:  "hello\uFFFD\uFFFD\uFFFDworld",
-			wantIter: 1,
-		},
-
 		{
 			src:     "\u2345",
 			dstSize: 2,
@@ -955,6 +947,7 @@ func testString(t *testing.T, f func(Transformer, string) (string, int, error))
 			// that depend on a specific buffer size being set.
 			continue
 		}
+		reset(tt.t)
 		if tt.wantErr == ErrShortDst || tt.wantErr == ErrShortSrc {
 			// The result string will be different.
 			continue

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/Makefile

@@ -5,6 +5,9 @@
 maketables: maketables.go triegen.go
 	go build $^
 
+maketesttables: maketesttables.go triegen.go
+	go build $^
+
 normregtest: normregtest.go
 	go build $^
 
@@ -12,6 +15,10 @@ tables:	maketables
 	./maketables > tables.go
 	gofmt -w tables.go
 
+trietesttables: maketesttables
+	./maketesttables > triedata_test.go
+	gofmt -w triedata_test.go
+
 # Downloads from www.unicode.org, so not part
 # of standard test scripts.
 test: testtables regtest

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/example_iter_test.go

@@ -9,7 +9,7 @@ import (
 	"fmt"
 	"unicode/utf8"
 
-	"golang.org/x/text/unicode/norm"
+	"code.google.com/p/go.text/unicode/norm"
 )
 
 // EqualSimple uses a norm.Iter to compare two non-normalized

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/forminfo.go

@@ -201,17 +201,17 @@ func lookupInfoNFKC(b input, i int) Properties {
 // Properties returns properties for the first rune in s.
 func (f Form) Properties(s []byte) Properties {
 	if f == NFC || f == NFD {
-		return compInfo(nfcData.lookup(s))
+		return compInfo(nfcTrie.lookup(s))
 	}
-	return compInfo(nfkcData.lookup(s))
+	return compInfo(nfkcTrie.lookup(s))
 }
 
 // PropertiesString returns properties for the first rune in s.
 func (f Form) PropertiesString(s string) Properties {
 	if f == NFC || f == NFD {
-		return compInfo(nfcData.lookupString(s))
+		return compInfo(nfcTrie.lookupString(s))
 	}
-	return compInfo(nfkcData.lookupString(s))
+	return compInfo(nfkcTrie.lookupString(s))
 }
 
 // compInfo converts the information contained in v and sz

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/input.go

@@ -77,16 +77,16 @@ func (in *input) copySlice(buf []byte, b, e int) int {
 
 func (in *input) charinfoNFC(p int) (uint16, int) {
 	if in.bytes == nil {
-		return nfcData.lookupString(in.str[p:])
+		return nfcTrie.lookupString(in.str[p:])
 	}
-	return nfcData.lookup(in.bytes[p:])
+	return nfcTrie.lookup(in.bytes[p:])
 }
 
 func (in *input) charinfoNFKC(p int) (uint16, int) {
 	if in.bytes == nil {
-		return nfkcData.lookupString(in.str[p:])
+		return nfkcTrie.lookupString(in.str[p:])
 	}
-	return nfkcData.lookup(in.bytes[p:])
+	return nfkcTrie.lookup(in.bytes[p:])
 }
 
 func (in *input) hangul(p int) (r rune) {

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/iter.go

@@ -9,8 +9,6 @@ import (
 	"unicode/utf8"
 )
 
-// MaxSegmentSize is the maximum size of a byte buffer needed to consider any
-// sequence of starter and non-starter runes for the purpose of normalization.
 const MaxSegmentSize = maxByteBufferSize
 
 // An Iter iterates over a string or byte slice, while normalizing it

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/maketables.go

@@ -24,8 +24,7 @@ import (
 	"strings"
 	"unicode"
 
-	"golang.org/x/text/internal/triegen"
-	"golang.org/x/text/internal/ucd"
+	"code.google.com/p/go.text/internal/ucd"
 )
 
 func main() {
@@ -715,14 +714,13 @@ func printCharInfoTables() int {
 
 	varnames := []string{"nfc", "nfkc"}
 	for i := 0; i < FNumberOfFormTypes; i++ {
-		trie := triegen.NewTrie(varnames[i])
-
+		trie := newNode()
 		for r, c := range chars {
 			f := c.forms[i]
 			d := f.expandedDecomp
 			if len(d) != 0 {
 				_, key := mkstr(c.codePoint, &f)
-				trie.Insert(rune(r), uint64(positionMap[key]))
+				trie.insert(rune(r), positionMap[key])
 				if c.ccc != ccc(d[0]) {
 					// We assume the lead ccc of a decomposition !=0 in this case.
 					if ccc(d[0]) == 0 {
@@ -732,16 +730,12 @@ func printCharInfoTables() int {
 			} else if c.nLeadingNonStarters > 0 && len(f.expandedDecomp) == 0 && c.ccc == 0 && !f.combinesBackward {
 				// Handle cases where it can't be detected that the nLead should be equal
 				// to nTrail.
-				trie.Insert(c.codePoint, uint64(positionMap[nLeadStr]))
+				trie.insert(c.codePoint, positionMap[nLeadStr])
 			} else if v := makeEntry(&f, &c)<<8 | uint16(c.ccc); v != 0 {
-				trie.Insert(c.codePoint, uint64(0x8000|v))
+				trie.insert(c.codePoint, 0x8000|v)
 			}
 		}
-		sz, err := trie.Gen(os.Stdout, triegen.Compact(&normCompacter{name: varnames[i]}))
-		if err != nil {
-			logger.Fatal(err)
-		}
-		size += sz
+		size += trie.printTables(varnames[i])
 	}
 	return size
 }

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/maketesttables.go

@@ -0,0 +1,45 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Generate test data for trie code.
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	printTestTables()
+}
+
+// We take the smallest, largest and an arbitrary value for each
+// of the UTF-8 sequence lengths.
+var testRunes = []rune{
+	0x01, 0x0C, 0x7F, // 1-byte sequences
+	0x80, 0x100, 0x7FF, // 2-byte sequences
+	0x800, 0x999, 0xFFFF, // 3-byte sequences
+	0x10000, 0x10101, 0x10FFFF, // 4-byte sequences
+	0x200, 0x201, 0x202, 0x210, 0x215, // five entries in one sparse block
+}
+
+const fileHeader = `// Generated by running
+//	maketesttables
+// DO NOT EDIT
+
+package norm
+
+`
+
+func printTestTables() {
+	fmt.Print(fileHeader)
+	fmt.Printf("var testRunes = %#v\n\n", testRunes)
+	t := newNode()
+	for i, r := range testRunes {
+		t.insert(r, uint16(i))
+	}
+	t.printTables("testdata")
+}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/normregtest.go

@@ -23,7 +23,7 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	"golang.org/x/text/unicode/norm"
+	"code.google.com/p/go.text/unicode/norm"
 )
 
 func main() {

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/transform.go

@@ -7,16 +7,13 @@ package norm
 import (
 	"unicode/utf8"
 
-	"golang.org/x/text/transform"
+	"code.google.com/p/go.text/transform"
 )
 
-// Reset implements the Reset method of the transform.Transformer interface.
-func (Form) Reset() {}
-
-// Transform implements the Transform method of the transform.Transformer
-// interface. It may need to write segments of up to MaxSegmentSize at once.
-// Users should either catch ErrShortDst and allow dst to grow or have dst be at
-// least of size MaxTransformChunkSize to be guaranteed of progress.
+// Transform implements the transform.Transformer interface. It may need to
+// write segments of up to MaxSegmentSize at once. Users should either catch
+// ErrShortDst and allow dst to grow or have dst be at least of size
+// MaxTransformChunkSize to be guaranteed of progress.
 func (f Form) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := 0
 	// Cap the maximum number of src bytes to check.

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/transform_test.go

@@ -8,7 +8,7 @@ import (
 	"fmt"
 	"testing"
 
-	"golang.org/x/text/transform"
+	"code.google.com/p/go.text/transform"
 )
 
 func TestTransform(t *testing.T) {

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/trie.go

@@ -0,0 +1,232 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+type valueRange struct {
+	value  uint16 // header: value:stride
+	lo, hi byte   // header: lo:n
+}
+
+type trie struct {
+	index        []uint8
+	values       []uint16
+	sparse       []valueRange
+	sparseOffset []uint16
+	cutoff       uint8 // indices >= cutoff are sparse
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
+// is a list of ranges with an accompanying value. Given a matching range r,
+// the value for b is by r.value + (b - r.lo) * stride.
+func (t *trie) lookupValue(n uint8, b byte) uint16 {
+	if n < t.cutoff {
+		return t.values[uint16(n)<<6+uint16(b)]
+	}
+	offset := t.sparseOffset[n-t.cutoff]
+	header := t.sparse[offset]
+	lo := offset + 1
+	hi := lo + uint16(header.lo)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := t.sparse[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value + uint16(b-r.lo)*header.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}
+
+const (
+	t1 = 0x00 // 0000 0000
+	tx = 0x80 // 1000 0000
+	t2 = 0xC0 // 1100 0000
+	t3 = 0xE0 // 1110 0000
+	t4 = 0xF0 // 1111 0000
+	t5 = 0xF8 // 1111 1000
+	t6 = 0xFC // 1111 1100
+	te = 0xFE // 1111 1110
+)
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *trie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < tx:
+		return t.values[c0], 1
+	case c0 < t2:
+		return 0, 1
+	case c0 < t3:
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := t.index[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		return t.lookupValue(i, c1), 2
+	case c0 < t4:
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := t.index[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := uint16(i)<<6 + uint16(c1)
+		i = t.index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		return t.lookupValue(i, c2), 3
+	case c0 < t5:
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := t.index[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := uint16(i)<<6 + uint16(c1)
+		i = t.index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		o = uint16(i)<<6 + uint16(c2)
+		i = t.index[o]
+		c3 := s[3]
+		if c3 < tx || t2 <= c3 {
+			return 0, 3
+		}
+		return t.lookupValue(i, c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *trie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < tx:
+		return t.values[c0], 1
+	case c0 < t2:
+		return 0, 1
+	case c0 < t3:
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := t.index[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		return t.lookupValue(i, c1), 2
+	case c0 < t4:
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := t.index[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := uint16(i)<<6 + uint16(c1)
+		i = t.index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		return t.lookupValue(i, c2), 3
+	case c0 < t5:
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := t.index[c0]
+		c1 := s[1]
+		if c1 < tx || t2 <= c1 {
+			return 0, 1
+		}
+		o := uint16(i)<<6 + uint16(c1)
+		i = t.index[o]
+		c2 := s[2]
+		if c2 < tx || t2 <= c2 {
+			return 0, 2
+		}
+		o = uint16(i)<<6 + uint16(c2)
+		i = t.index[o]
+		c3 := s[3]
+		if c3 < tx || t2 <= c3 {
+			return 0, 3
+		}
+		return t.lookupValue(i, c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must hold a full encoding.
+func (t *trie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < tx {
+		return t.values[c0]
+	}
+	if c0 < t2 {
+		return 0
+	}
+	i := t.index[c0]
+	if c0 < t3 {
+		return t.lookupValue(i, s[1])
+	}
+	i = t.index[uint16(i)<<6+uint16(s[1])]
+	if c0 < t4 {
+		return t.lookupValue(i, s[2])
+	}
+	i = t.index[uint16(i)<<6+uint16(s[2])]
+	if c0 < t5 {
+		return t.lookupValue(i, s[3])
+	}
+	return 0
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must hold a full encoding.
+func (t *trie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < tx {
+		return t.values[c0]
+	}
+	if c0 < t2 {
+		return 0
+	}
+	i := t.index[c0]
+	if c0 < t3 {
+		return t.lookupValue(i, s[1])
+	}
+	i = t.index[uint16(i)<<6+uint16(s[1])]
+	if c0 < t4 {
+		return t.lookupValue(i, s[2])
+	}
+	i = t.index[uint16(i)<<6+uint16(s[2])]
+	if c0 < t5 {
+		return t.lookupValue(i, s[3])
+	}
+	return 0
+}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/trie_test.go

@@ -0,0 +1,152 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+	"testing"
+	"unicode/utf8"
+)
+
+// Test data is located in triedata_test.go; generated by maketesttables.
+var testdata = testdataTrie
+
+type rangeTest struct {
+	block   uint8
+	lookup  byte
+	result  uint16
+	table   []valueRange
+	offsets []uint16
+}
+
+var range1Off = []uint16{0, 2}
+var range1 = []valueRange{
+	{0, 1, 0},
+	{1, 0x80, 0x80},
+	{0, 2, 0},
+	{1, 0x80, 0x80},
+	{9, 0xff, 0xff},
+}
+
+var rangeTests = []rangeTest{
+	{10, 0x80, 1, range1, range1Off},
+	{10, 0x00, 0, range1, range1Off},
+	{11, 0x80, 1, range1, range1Off},
+	{11, 0xff, 9, range1, range1Off},
+	{11, 0x00, 0, range1, range1Off},
+}
+
+func TestLookupSparse(t *testing.T) {
+	for i, test := range rangeTests {
+		n := trie{sparse: test.table, sparseOffset: test.offsets, cutoff: 10}
+		v := n.lookupValue(test.block, test.lookup)
+		if v != test.result {
+			t.Errorf("LookupSparse:%d: found %X; want %X", i, v, test.result)
+		}
+	}
+}
+
+// Test cases for illegal runes.
+type trietest struct {
+	size  int
+	bytes []byte
+}
+
+var tests = []trietest{
+	// illegal runes
+	{1, []byte{0x80}},
+	{1, []byte{0xFF}},
+	{1, []byte{t2, tx - 1}},
+	{1, []byte{t2, t2}},
+	{2, []byte{t3, tx, tx - 1}},
+	{2, []byte{t3, tx, t2}},
+	{1, []byte{t3, tx - 1, tx}},
+	{3, []byte{t4, tx, tx, tx - 1}},
+	{3, []byte{t4, tx, tx, t2}},
+	{1, []byte{t4, t2, tx, tx - 1}},
+	{2, []byte{t4, tx, t2, tx - 1}},
+
+	// short runes
+	{0, []byte{t2}},
+	{0, []byte{t3, tx}},
+	{0, []byte{t4, tx, tx}},
+
+	// we only support UTF-8 up to utf8.UTFMax bytes (4 bytes)
+	{1, []byte{t5, tx, tx, tx, tx}},
+	{1, []byte{t6, tx, tx, tx, tx, tx}},
+}
+
+func mkUTF8(r rune) ([]byte, int) {
+	var b [utf8.UTFMax]byte
+	sz := utf8.EncodeRune(b[:], r)
+	return b[:sz], sz
+}
+
+func TestLookup(t *testing.T) {
+	for i, tt := range testRunes {
+		b, szg := mkUTF8(tt)
+		v, szt := testdata.lookup(b)
+		if int(v) != i {
+			t.Errorf("lookup(%U): found value %#x, expected %#x", tt, v, i)
+		}
+		if szt != szg {
+			t.Errorf("lookup(%U): found size %d, expected %d", tt, szt, szg)
+		}
+	}
+	for i, tt := range tests {
+		v, sz := testdata.lookup(tt.bytes)
+		if v != 0 {
+			t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
+		}
+		if sz != tt.size {
+			t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
+		}
+	}
+	// Verify defaults.
+	if v, _ := testdata.lookup([]byte{0xC1, 0x8C}); v != 0 {
+		t.Errorf("lookup of non-existing rune should be 0; found %X", v)
+	}
+}
+
+func TestLookupUnsafe(t *testing.T) {
+	for i, tt := range testRunes {
+		b, _ := mkUTF8(tt)
+		v := testdata.lookupUnsafe(b)
+		if int(v) != i {
+			t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
+		}
+	}
+}
+
+func TestLookupString(t *testing.T) {
+	for i, tt := range testRunes {
+		b, szg := mkUTF8(tt)
+		v, szt := testdata.lookupString(string(b))
+		if int(v) != i {
+			t.Errorf("lookup(%U): found value %#x, expected %#x", i, v, i)
+		}
+		if szt != szg {
+			t.Errorf("lookup(%U): found size %d, expected %d", i, szt, szg)
+		}
+	}
+	for i, tt := range tests {
+		v, sz := testdata.lookupString(string(tt.bytes))
+		if int(v) != 0 {
+			t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
+		}
+		if sz != tt.size {
+			t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
+		}
+	}
+}
+
+func TestLookupStringUnsafe(t *testing.T) {
+	for i, tt := range testRunes {
+		b, _ := mkUTF8(tt)
+		v := testdata.lookupStringUnsafe(string(b))
+		if int(v) != i {
+			t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
+		}
+	}
+}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/triedata_test.go

@@ -0,0 +1,85 @@
+// Generated by running
+//	maketesttables
+// DO NOT EDIT
+
+package norm
+
+var testRunes = []int32{1, 12, 127, 128, 256, 2047, 2048, 2457, 65535, 65536, 65793, 1114111, 512, 513, 514, 528, 533}
+
+// testdataValues: 192 entries, 384 bytes
+// Block 2 is the null block.
+var testdataValues = [192]uint16{
+	// Block 0x0, offset 0x0
+	0x000c: 0x0001,
+	// Block 0x1, offset 0x40
+	0x007f: 0x0002,
+	// Block 0x2, offset 0x80
+}
+
+// testdataSparseOffset: 10 entries, 20 bytes
+var testdataSparseOffset = []uint16{0x0, 0x2, 0x4, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14}
+
+// testdataSparseValues: 22 entries, 88 bytes
+var testdataSparseValues = [22]valueRange{
+	// Block 0x0, offset 0x1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0003, lo: 0x80, hi: 0x80},
+	// Block 0x1, offset 0x2
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0004, lo: 0x80, hi: 0x80},
+	// Block 0x2, offset 0x3
+	{value: 0x0001, lo: 0x03},
+	{value: 0x000c, lo: 0x80, hi: 0x82},
+	{value: 0x000f, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	// Block 0x3, offset 0x4
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0005, lo: 0xbf, hi: 0xbf},
+	// Block 0x4, offset 0x5
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0006, lo: 0x80, hi: 0x80},
+	// Block 0x5, offset 0x6
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0007, lo: 0x99, hi: 0x99},
+	// Block 0x6, offset 0x7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0008, lo: 0xbf, hi: 0xbf},
+	// Block 0x7, offset 0x8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0009, lo: 0x80, hi: 0x80},
+	// Block 0x8, offset 0x9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x000a, lo: 0x81, hi: 0x81},
+	// Block 0x9, offset 0xa
+	{value: 0x0000, lo: 0x01},
+	{value: 0x000b, lo: 0xbf, hi: 0xbf},
+}
+
+// testdataLookup: 640 bytes
+// Block 0 is the null block.
+var testdataLookup = [640]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0x0c2: 0x01, 0x0c4: 0x02,
+	0x0c8: 0x03,
+	0x0df: 0x04,
+	0x0e0: 0x02,
+	0x0ef: 0x03,
+	0x0f0: 0x05, 0x0f4: 0x07,
+	// Block 0x4, offset 0x100
+	0x120: 0x05, 0x126: 0x06,
+	// Block 0x5, offset 0x140
+	0x17f: 0x07,
+	// Block 0x6, offset 0x180
+	0x180: 0x08, 0x184: 0x09,
+	// Block 0x7, offset 0x1c0
+	0x1d0: 0x04,
+	// Block 0x8, offset 0x200
+	0x23f: 0x0a,
+	// Block 0x9, offset 0x240
+	0x24f: 0x06,
+}
+
+var testdataTrie = trie{testdataLookup[:], testdataValues[:], testdataSparseValues[:], testdataSparseOffset[:], 1}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/triegen.go

@@ -0,0 +1,317 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+// Trie table generator.
+// Used by make*tables tools to generate a go file with trie data structures
+// for mapping UTF-8 to a 16-bit value. All but the last byte in a UTF-8 byte
+// sequence are used to lookup offsets in the index table to be used for the
+// next byte. The last byte is used to index into a table with 16-bit values.
+
+package main
+
+import (
+	"fmt"
+	"hash/crc32"
+	"log"
+	"unicode/utf8"
+)
+
+const (
+	blockSize        = 64
+	blockOffset      = 2 // Subtract two blocks to compensate for the 0x80 added to continuation bytes.
+	maxSparseEntries = 16
+)
+
+// Intermediate trie structure
+type trieNode struct {
+	table [256]*trieNode
+	value int
+	b     byte
+	leaf  bool
+}
+
+func newNode() *trieNode {
+	return new(trieNode)
+}
+
+func (n trieNode) String() string {
+	s := fmt.Sprint("trieNode{table: { non-nil at index: ")
+	for i, v := range n.table {
+		if v != nil {
+			s += fmt.Sprintf("%d, ", i)
+		}
+	}
+	s += fmt.Sprintf("}, value:%#x, b:%#x leaf:%v}", n.value, n.b, n.leaf)
+	return s
+}
+
+func (n trieNode) isInternal() bool {
+	internal := true
+	for i := 0; i < 256; i++ {
+		if nn := n.table[i]; nn != nil {
+			if !internal && !nn.leaf {
+				log.Fatalf("triegen: isInternal: node contains both leaf and non-leaf children (%v)", n)
+			}
+			internal = internal && !nn.leaf
+		}
+	}
+	return internal
+}
+
+func (n trieNode) mostFrequentStride() int {
+	counts := make(map[int]int)
+	v := 0
+	for _, t := range n.table[0x80 : 0x80+blockSize] {
+		if t != nil {
+			if stride := t.value - v; v != 0 && stride >= 0 {
+				counts[stride]++
+			}
+			v = t.value
+		} else {
+			v = 0
+		}
+	}
+	var maxs, maxc int
+	for stride, cnt := range counts {
+		if cnt > maxc || (cnt == maxc && stride < maxs) {
+			maxs, maxc = stride, cnt
+		}
+	}
+	return maxs
+}
+
+func (n trieNode) countSparseEntries() int {
+	stride := n.mostFrequentStride()
+	var count, v int
+	for _, t := range n.table[0x80 : 0x80+blockSize] {
+		tv := 0
+		if t != nil {
+			tv = t.value
+		}
+		if tv-v != stride {
+			if tv != 0 {
+				count++
+			}
+		}
+		v = tv
+	}
+	return count
+}
+
+func (n *trieNode) insert(r rune, value uint16) {
+	var p [utf8.UTFMax]byte
+	sz := utf8.EncodeRune(p[:], r)
+
+	for i := 0; i < sz; i++ {
+		if n.leaf {
+			log.Fatalf("triegen: insert: node (%#v) should not be a leaf", n)
+		}
+		nn := n.table[p[i]]
+		if nn == nil {
+			nn = newNode()
+			nn.b = p[i]
+			n.table[p[i]] = nn
+		}
+		n = nn
+	}
+	n.value = int(value)
+	n.leaf = true
+}
+
+type nodeIndex struct {
+	lookupBlocks []*trieNode
+	valueBlocks  []*trieNode
+	sparseBlocks []*trieNode
+	sparseOffset []uint16
+	sparseCount  int
+
+	lookupBlockIdx map[uint32]int
+	valueBlockIdx  map[uint32]int
+}
+
+func newIndex() *nodeIndex {
+	index := &nodeIndex{}
+	index.lookupBlocks = make([]*trieNode, 0)
+	index.valueBlocks = make([]*trieNode, 0)
+	index.sparseBlocks = make([]*trieNode, 0)
+	index.sparseOffset = make([]uint16, 1)
+	index.lookupBlockIdx = make(map[uint32]int)
+	index.valueBlockIdx = make(map[uint32]int)
+	return index
+}
+
+func computeOffsets(index *nodeIndex, n *trieNode) int {
+	if n.leaf {
+		return n.value
+	}
+	hasher := crc32.New(crc32.MakeTable(crc32.IEEE))
+	// We only index continuation bytes.
+	for i := 0; i < blockSize; i++ {
+		v := 0
+		if nn := n.table[0x80+i]; nn != nil {
+			v = computeOffsets(index, nn)
+		}
+		hasher.Write([]byte{uint8(v >> 8), uint8(v)})
+	}
+	h := hasher.Sum32()
+	if n.isInternal() {
+		v, ok := index.lookupBlockIdx[h]
+		if !ok {
+			v = len(index.lookupBlocks) - blockOffset
+			index.lookupBlocks = append(index.lookupBlocks, n)
+			index.lookupBlockIdx[h] = v
+		}
+		n.value = v
+	} else {
+		v, ok := index.valueBlockIdx[h]
+		if !ok {
+			if c := n.countSparseEntries(); c > maxSparseEntries {
+				v = len(index.valueBlocks) - blockOffset
+				index.valueBlocks = append(index.valueBlocks, n)
+				index.valueBlockIdx[h] = v
+			} else {
+				v = -len(index.sparseOffset)
+				index.sparseBlocks = append(index.sparseBlocks, n)
+				index.sparseOffset = append(index.sparseOffset, uint16(index.sparseCount))
+				index.sparseCount += c + 1
+				index.valueBlockIdx[h] = v
+			}
+		}
+		n.value = v
+	}
+	return n.value
+}
+
+func printValueBlock(nr int, n *trieNode, offset int) {
+	boff := nr * blockSize
+	fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
+	var printnewline bool
+	for i := 0; i < blockSize; i++ {
+		if i%6 == 0 {
+			printnewline = true
+		}
+		v := 0
+		if nn := n.table[i+offset]; nn != nil {
+			v = nn.value
+		}
+		if v != 0 {
+			if printnewline {
+				fmt.Printf("\n")
+				printnewline = false
+			}
+			fmt.Printf("%#04x:%#04x, ", boff+i, v)
+		}
+	}
+}
+
+func printSparseBlock(nr int, n *trieNode) {
+	boff := -n.value
+	fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
+	v := 0
+	//stride := f(n)
+	stride := n.mostFrequentStride()
+	c := n.countSparseEntries()
+	fmt.Printf("\n{value:%#04x,lo:%#02x},", stride, uint8(c))
+	for i, nn := range n.table[0x80 : 0x80+blockSize] {
+		nv := 0
+		if nn != nil {
+			nv = nn.value
+		}
+		if nv-v != stride {
+			if v != 0 {
+				fmt.Printf(",hi:%#02x},", 0x80+i-1)
+			}
+			if nv != 0 {
+				fmt.Printf("\n{value:%#04x,lo:%#02x", nv, nn.b)
+			}
+		}
+		v = nv
+	}
+	if v != 0 {
+		fmt.Printf(",hi:%#02x},", 0x80+blockSize-1)
+	}
+}
+
+func printLookupBlock(nr int, n *trieNode, offset, cutoff int) {
+	boff := nr * blockSize
+	fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
+	var printnewline bool
+	for i := 0; i < blockSize; i++ {
+		if i%8 == 0 {
+			printnewline = true
+		}
+		v := 0
+		if nn := n.table[i+offset]; nn != nil {
+			v = nn.value
+		}
+		if v != 0 {
+			if v < 0 {
+				v = -v - 1 + cutoff
+			}
+			if printnewline {
+				fmt.Printf("\n")
+				printnewline = false
+			}
+			fmt.Printf("%#03x:%#02x, ", boff+i, v)
+		}
+	}
+}
+
+// printTables returns the size in bytes of the generated tables.
+func (t *trieNode) printTables(name string) int {
+	index := newIndex()
+	// Values for 7-bit ASCII are stored in first two block, followed by nil block.
+	index.valueBlocks = append(index.valueBlocks, nil, nil, nil)
+	// First byte of multi-byte UTF-8 codepoints are indexed in 4th block.
+	index.lookupBlocks = append(index.lookupBlocks, nil, nil, nil, nil)
+	// Index starter bytes of multi-byte UTF-8.
+	for i := 0xC0; i < 0x100; i++ {
+		if t.table[i] != nil {
+			computeOffsets(index, t.table[i])
+		}
+	}
+
+	nv := len(index.valueBlocks) * blockSize
+	fmt.Printf("// %sValues: %d entries, %d bytes\n", name, nv, nv*2)
+	fmt.Printf("// Block 2 is the null block.\n")
+	fmt.Printf("var %sValues = [%d]uint16 {", name, nv)
+	printValueBlock(0, t, 0)
+	printValueBlock(1, t, 64)
+	printValueBlock(2, newNode(), 0)
+	for i := 3; i < len(index.valueBlocks); i++ {
+		printValueBlock(i, index.valueBlocks[i], 0x80)
+	}
+	fmt.Print("\n}\n\n")
+
+	ls := len(index.sparseBlocks)
+	fmt.Printf("// %sSparseOffset: %d entries, %d bytes\n", name, ls, ls*2)
+	fmt.Printf("var %sSparseOffset = %#v\n\n", name, index.sparseOffset[1:])
+
+	ns := index.sparseCount
+	fmt.Printf("// %sSparseValues: %d entries, %d bytes\n", name, ns, ns*4)
+	fmt.Printf("var %sSparseValues = [%d]valueRange {", name, ns)
+	for i, n := range index.sparseBlocks {
+		printSparseBlock(i, n)
+	}
+	fmt.Print("\n}\n\n")
+
+	cutoff := len(index.valueBlocks) - blockOffset
+	ni := len(index.lookupBlocks) * blockSize
+	fmt.Printf("// %sLookup: %d bytes\n", name, ni)
+	fmt.Printf("// Block 0 is the null block.\n")
+	fmt.Printf("var %sLookup = [%d]uint8 {", name, ni)
+	printLookupBlock(0, newNode(), 0, cutoff)
+	printLookupBlock(1, newNode(), 0, cutoff)
+	printLookupBlock(2, newNode(), 0, cutoff)
+	printLookupBlock(3, t, 0xC0, cutoff)
+	for i := 4; i < len(index.lookupBlocks); i++ {
+		printLookupBlock(i, index.lookupBlocks[i], 0x80, cutoff)
+	}
+	fmt.Print("\n}\n\n")
+	fmt.Printf("var %sTrie = trie{ %sLookup[:], %sValues[:], %sSparseValues[:], %sSparseOffset[:], %d}\n\n",
+		name, name, name, name, name, cutoff)
+	return nv*2 + ns*4 + ni + ls*2
+}

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2012 Dave Grijalva
-
-Permission is hereby granted, free of charge, to any person obtaining a 
-copy of this software and associated documentation files (the "Software"), 
-to deal in the Software without restriction, including without limitation 
-the rights to use, copy, modify, merge, publish, distribute, sublicense, 
-and/or sell copies of the Software, and to permit persons to whom the 
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included 
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
-THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 
-THE SOFTWARE.

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/README.md

@@ -1,19 +0,0 @@
-A simple LFU cache for golang.  Based on the paper [An O(1) algorithm for implementing the LFU cache eviction scheme](http://dhruvbird.com/lfu.pdf).
-
-Usage:
-
-```go
-import "github.com/dgrijalva/lfu-go"
-
-// Make a new thing
-c := lfu.New()
-
-// Set some values
-c.Set("myKey", myValue)
-
-// Retrieve some values
-myValue = c.Get("myKey")
-
-// Evict some values
-c.Evict(1)
-```

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/lfu.go

@@ -1,156 +0,0 @@
-package lfu
-
-import (
-	"container/list"
-	"sync"
-)
-
-type Eviction struct {
-	Key   string
-	Value interface{}
-}
-
-type Cache struct {
-	// If len > UpperBound, cache will automatically evict
-	// down to LowerBound.  If either value is 0, this behavior
-	// is disabled.
-	UpperBound      int
-	LowerBound      int
-	values          map[string]*cacheEntry
-	freqs           *list.List
-	len             int
-	lock            *sync.Mutex
-	EvictionChannel chan<- Eviction
-}
-
-type cacheEntry struct {
-	key      string
-	value    interface{}
-	freqNode *list.Element
-}
-
-type listEntry struct {
-	entries map[*cacheEntry]byte
-	freq    int
-}
-
-func New() *Cache {
-	c := new(Cache)
-	c.values = make(map[string]*cacheEntry)
-	c.freqs = list.New()
-	c.lock = new(sync.Mutex)
-	return c
-}
-
-func (c *Cache) Get(key string) interface{} {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if e, ok := c.values[key]; ok {
-		c.increment(e)
-		return e.value
-	}
-	return nil
-}
-
-func (c *Cache) Set(key string, value interface{}) {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	if e, ok := c.values[key]; ok {
-		// value already exists for key.  overwrite
-		e.value = value
-		c.increment(e)
-	} else {
-		// value doesn't exist.  insert
-		e := new(cacheEntry)
-		e.key = key
-		e.value = value
-		c.values[key] = e
-		c.increment(e)
-		c.len++
-		// bounds mgmt
-		if c.UpperBound > 0 && c.LowerBound > 0 {
-			if c.len > c.UpperBound {
-				c.evict(c.len - c.LowerBound)
-			}
-		}
-	}
-}
-
-func (c *Cache) Len() int {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	return c.len
-}
-
-func (c *Cache) Evict(count int) int {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	return c.evict(count)
-}
-
-func (c *Cache) evict(count int) int {
-	// No lock here so it can be called
-	// from within the lock (during Set)
-	var evicted int
-	for i := 0; i < count; {
-		if place := c.freqs.Front(); place != nil {
-			for entry, _ := range place.Value.(*listEntry).entries {
-				if i < count {
-					if c.EvictionChannel != nil {
-						c.EvictionChannel <- Eviction{
-							Key:   entry.key,
-							Value: entry.value,
-						}
-					}
-					delete(c.values, entry.key)
-					c.remEntry(place, entry)
-					evicted++
-					c.len--
-					i++
-				}
-			}
-		}
-	}
-	return evicted
-}
-
-func (c *Cache) increment(e *cacheEntry) {
-	currentPlace := e.freqNode
-	var nextFreq int
-	var nextPlace *list.Element
-	if currentPlace == nil {
-		// new entry
-		nextFreq = 1
-		nextPlace = c.freqs.Front()
-	} else {
-		// move up
-		nextFreq = currentPlace.Value.(*listEntry).freq + 1
-		nextPlace = currentPlace.Next()
-	}
-
-	if nextPlace == nil || nextPlace.Value.(*listEntry).freq != nextFreq {
-		// create a new list entry
-		li := new(listEntry)
-		li.freq = nextFreq
-		li.entries = make(map[*cacheEntry]byte)
-		if currentPlace != nil {
-			nextPlace = c.freqs.InsertAfter(li, currentPlace)
-		} else {
-			nextPlace = c.freqs.PushFront(li)
-		}
-	}
-	e.freqNode = nextPlace
-	nextPlace.Value.(*listEntry).entries[e] = 1
-	if currentPlace != nil {
-		// remove from current position
-		c.remEntry(currentPlace, e)
-	}
-}
-
-func (c *Cache) remEntry(place *list.Element, entry *cacheEntry) {
-	entries := place.Value.(*listEntry).entries
-	delete(entries, entry)
-	if len(entries) == 0 {
-		c.freqs.Remove(place)
-	}
-}

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/lfu_test.go

@@ -1,68 +0,0 @@
-package lfu
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestLFU(t *testing.T) {
-	c := New()
-	c.Set("a", "a")
-	if v := c.Get("a"); v != "a" {
-		t.Errorf("Value was not saved: %v != 'a'", v)
-	}
-	if l := c.Len(); l != 1 {
-		t.Errorf("Length was not updated: %v != 1", l)
-	}
-
-	c.Set("b", "b")
-	if v := c.Get("b"); v != "b" {
-		t.Errorf("Value was not saved: %v != 'b'", v)
-	}
-	if l := c.Len(); l != 2 {
-		t.Errorf("Length was not updated: %v != 2", l)
-	}
-
-	c.Get("a")
-	evicted := c.Evict(1)
-	if v := c.Get("a"); v != "a" {
-		t.Errorf("Value was improperly evicted: %v != 'a'", v)
-	}
-	if v := c.Get("b"); v != nil {
-		t.Errorf("Value was not evicted: %v", v)
-	}
-	if l := c.Len(); l != 1 {
-		t.Errorf("Length was not updated: %v != 1", l)
-	}
-	if evicted != 1 {
-		t.Errorf("Number of evicted items is wrong: %v != 1", evicted)
-	}
-}
-
-func TestBoundsMgmt(t *testing.T) {
-	c := New()
-	c.UpperBound = 10
-	c.LowerBound = 5
-
-	for i := 0; i < 100; i++ {
-		c.Set(fmt.Sprintf("%v", i), i)
-	}
-	if c.Len() > 10 {
-		t.Errorf("Bounds management failed to evict properly: %v", c.Len())
-	}
-}
-
-func TestEviction(t *testing.T) {
-	ch := make(chan Eviction, 1)
-
-	c := New()
-	c.EvictionChannel = ch
-	c.Set("a", "b")
-	c.Evict(1)
-
-	ev := <-ch
-
-	if ev.Key != "a" || ev.Value.(string) != "b" {
-		t.Error("Incorrect item")
-	}
-}

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/lz4-example/main.go

@@ -72,18 +72,10 @@ func main() {
 
 	if *decompress {
 		data, _ = ioutil.ReadAll(input)
-		data, err = lz4.Decode(nil, data)
-		if err != nil {
-			fmt.Println("Failed to decode:", err)
-			return
-		}
+		data, _ = lz4.Decode(nil, data)
 	} else {
 		data, _ = ioutil.ReadAll(input)
-		data, err = lz4.Encode(nil, data)
-		if err != nil {
-			fmt.Println("Failed to encode:", err)
-			return
-		}
+		data, _ = lz4.Encode(nil, data)
 	}
 
 	err = ioutil.WriteFile(args[1], data, 0644)

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/writer.go

@@ -121,7 +121,7 @@ func Encode(dst, src []byte) ([]byte, error) {
 	)
 
 	for {
-		if int(e.pos)+12 >= len(e.src) {
+		if int(e.pos)+4 >= len(e.src) {
 			e.writeLiterals(uint32(len(e.src))-e.anchor, 0, e.anchor)
 			return e.dst[:e.dpos], nil
 		}
@@ -158,7 +158,7 @@ func Encode(dst, src []byte) ([]byte, error) {
 		ref += minMatch
 		e.anchor = e.pos
 
-		for int(e.pos) < len(e.src)-5 && e.src[e.pos] == e.src[ref] {
+		for int(e.pos) < len(e.src) && e.src[e.pos] == e.src[ref] {
 			e.pos++
 			ref++
 		}

Godeps/_workspace/src/github.com/calmh/logger/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2013 Jakob Borg
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-- The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Godeps/_workspace/src/github.com/calmh/logger/README.md

@@ -1,15 +0,0 @@
-logger
-======
-
-A small wrapper around `log` to provide log levels.
-
-Documentation
--------------
-
-http://godoc.org/github.com/calmh/logger
-
-License
--------
-
-MIT
-

Godeps/_workspace/src/github.com/calmh/xdr/bench_test.go

@@ -33,15 +33,11 @@ var s = XDRBenchStruct{
 	S0:  "Hello World! String one.",
 	S1:  "Hello World! String two.",
 }
-var e []byte
-
-func init() {
-	e, _ = s.MarshalXDR()
-}
+var e = s.MarshalXDR()
 
 func BenchmarkThisMarshal(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		res, _ = s.MarshalXDR()
+		res = s.MarshalXDR()
 	}
 }
 

Godeps/_workspace/src/github.com/calmh/xdr/bench_xdr_test.go

@@ -72,23 +72,15 @@ func (o XDRBenchStruct) EncodeXDR(w io.Writer) (int, error) {
 	return o.encodeXDR(xw)
 }
 
-func (o XDRBenchStruct) MarshalXDR() ([]byte, error) {
+func (o XDRBenchStruct) MarshalXDR() []byte {
 	return o.AppendXDR(make([]byte, 0, 128))
 }
 
-func (o XDRBenchStruct) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o XDRBenchStruct) AppendXDR(bs []byte) ([]byte, error) {
+func (o XDRBenchStruct) AppendXDR(bs []byte) []byte {
 	var aw = xdr.AppendWriter(bs)
 	var xw = xdr.NewWriter(&aw)
-	_, err := o.encodeXDR(xw)
-	return []byte(aw), err
+	o.encodeXDR(xw)
+	return []byte(aw)
 }
 
 func (o XDRBenchStruct) encodeXDR(xw *xdr.Writer) (int, error) {
@@ -96,13 +88,13 @@ func (o XDRBenchStruct) encodeXDR(xw *xdr.Writer) (int, error) {
 	xw.WriteUint32(o.I2)
 	xw.WriteUint16(o.I3)
 	xw.WriteUint8(o.I4)
-	if l := len(o.Bs0); l > 128 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Bs0", l, 128)
+	if len(o.Bs0) > 128 {
+		return xw.Tot(), xdr.ErrElementSizeExceeded
 	}
 	xw.WriteBytes(o.Bs0)
 	xw.WriteBytes(o.Bs1)
-	if l := len(o.S0); l > 128 {
-		return xw.Tot(), xdr.ElementSizeExceeded("S0", l, 128)
+	if len(o.S0) > 128 {
+		return xw.Tot(), xdr.ErrElementSizeExceeded
 	}
 	xw.WriteString(o.S0)
 	xw.WriteString(o.S1)
@@ -158,23 +150,15 @@ func (o repeatReader) EncodeXDR(w io.Writer) (int, error) {
 	return o.encodeXDR(xw)
 }
 
-func (o repeatReader) MarshalXDR() ([]byte, error) {
+func (o repeatReader) MarshalXDR() []byte {
 	return o.AppendXDR(make([]byte, 0, 128))
 }
 
-func (o repeatReader) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o repeatReader) AppendXDR(bs []byte) ([]byte, error) {
+func (o repeatReader) AppendXDR(bs []byte) []byte {
 	var aw = xdr.AppendWriter(bs)
 	var xw = xdr.NewWriter(&aw)
-	_, err := o.encodeXDR(xw)
-	return []byte(aw), err
+	o.encodeXDR(xw)
+	return []byte(aw)
 }
 
 func (o repeatReader) encodeXDR(xw *xdr.Writer) (int, error) {

Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go

@@ -11,8 +11,6 @@ import (
 	"go/format"
 	"go/parser"
 	"go/token"
-	"io"
-	"log"
 	"os"
 	"regexp"
 	"strconv"
@@ -55,23 +53,15 @@ func (o {{.TypeName}}) EncodeXDR(w io.Writer) (int, error) {
 	return o.encodeXDR(xw)
 }//+n
 
-func (o {{.TypeName}}) MarshalXDR() ([]byte, error) {
+func (o {{.TypeName}}) MarshalXDR() []byte {
 	return o.AppendXDR(make([]byte, 0, 128))
 }//+n
 
-func (o {{.TypeName}}) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}//+n
-
-func (o {{.TypeName}}) AppendXDR(bs []byte) ([]byte, error) {
+func (o {{.TypeName}}) AppendXDR(bs []byte) []byte {
 	var aw = xdr.AppendWriter(bs)
 	var xw = xdr.NewWriter(&aw)
-	_, err := o.encodeXDR(xw)
-	return []byte(aw), err
+	o.encodeXDR(xw)
+	return []byte(aw)
 }//+n
 
 func (o {{.TypeName}}) encodeXDR(xw *xdr.Writer) (int, error) {
@@ -81,8 +71,8 @@ func (o {{.TypeName}}) encodeXDR(xw *xdr.Writer) (int, error) {
 				xw.Write{{$fieldInfo.Encoder}}({{$fieldInfo.Convert}}(o.{{$fieldInfo.Name}}))
 			{{else if $fieldInfo.IsBasic}}
 				{{if ge $fieldInfo.Max 1}}
-					if l := len(o.{{$fieldInfo.Name}}); l > {{$fieldInfo.Max}} {
-						return xw.Tot(), xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", l, {{$fieldInfo.Max}})
+					if len(o.{{$fieldInfo.Name}}) > {{$fieldInfo.Max}} {
+						return xw.Tot(), xdr.ErrElementSizeExceeded
 					}
 				{{end}}
 				xw.Write{{$fieldInfo.Encoder}}(o.{{$fieldInfo.Name}})
@@ -94,8 +84,8 @@ func (o {{.TypeName}}) encodeXDR(xw *xdr.Writer) (int, error) {
 			{{end}}
 		{{else}}
 			{{if ge $fieldInfo.Max 1}}
-				if l := len(o.{{$fieldInfo.Name}}); l > {{$fieldInfo.Max}} {
-					return xw.Tot(), xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", l, {{$fieldInfo.Max}})
+				if len(o.{{$fieldInfo.Name}}) > {{$fieldInfo.Max}} {
+					return xw.Tot(), xdr.ErrElementSizeExceeded
 				}
 			{{end}}
 			xw.WriteUint32(uint32(len(o.{{$fieldInfo.Name}})))
@@ -145,7 +135,7 @@ func (o *{{.TypeName}}) decodeXDR(xr *xdr.Reader) error {
 			_{{$fieldInfo.Name}}Size := int(xr.ReadUint32())
 			{{if ge $fieldInfo.Max 1}}
 				if _{{$fieldInfo.Name}}Size > {{$fieldInfo.Max}} {
-					return xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", _{{$fieldInfo.Name}}Size, {{$fieldInfo.Max}})
+					return xdr.ErrElementSizeExceeded
 				}
 			{{end}}
 			o.{{$fieldInfo.Name}} = make([]{{$fieldInfo.FieldType}}, _{{$fieldInfo.Name}}Size)
@@ -271,7 +261,7 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 	return fs
 }
 
-func generateCode(output io.Writer, s structInfo) {
+func generateCode(s structInfo) {
 	name := s.Name
 	fs := s.Fields
 
@@ -288,7 +278,7 @@ func generateCode(output io.Writer, s structInfo) {
 	if err != nil {
 		panic(err)
 	}
-	fmt.Fprintln(output, string(bs))
+	fmt.Println(string(bs))
 }
 
 func uncamelize(s string) string {
@@ -297,16 +287,16 @@ func uncamelize(s string) string {
 	})
 }
 
-func generateDiagram(output io.Writer, s structInfo) {
+func generateDiagram(s structInfo) {
 	sn := s.Name
 	fs := s.Fields
 
-	fmt.Fprintln(output, sn+" Structure:")
-	fmt.Fprintln(output)
-	fmt.Fprintln(output, " 0                   1                   2                   3")
-	fmt.Fprintln(output, " 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1")
+	fmt.Println(sn + " Structure:")
+	fmt.Println()
+	fmt.Println(" 0                   1                   2                   3")
+	fmt.Println(" 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1")
 	line := "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-	fmt.Fprintln(output, line)
+	fmt.Println(line)
 
 	for _, f := range fs {
 		tn := f.FieldType
@@ -314,52 +304,52 @@ func generateDiagram(output io.Writer, s structInfo) {
 		name := uncamelize(f.Name)
 
 		if sl {
-			fmt.Fprintf(output, "| %s |\n", center("Number of "+name, 61))
-			fmt.Fprintln(output, line)
+			fmt.Printf("| %s |\n", center("Number of "+name, 61))
+			fmt.Println(line)
 		}
 		switch tn {
 		case "bool":
-			fmt.Fprintf(output, "| %s |V|\n", center(name+" (V=0 or 1)", 59))
-			fmt.Fprintln(output, line)
+			fmt.Printf("| %s |V|\n", center(name+" (V=0 or 1)", 59))
+			fmt.Println(line)
 		case "uint16":
-			fmt.Fprintf(output, "| %s | %s |\n", center("0x0000", 29), center(name, 29))
-			fmt.Fprintln(output, line)
+			fmt.Printf("| %s | %s |\n", center("0x0000", 29), center(name, 29))
+			fmt.Println(line)
 		case "uint32":
-			fmt.Fprintf(output, "| %s |\n", center(name, 61))
-			fmt.Fprintln(output, line)
+			fmt.Printf("| %s |\n", center(name, 61))
+			fmt.Println(line)
 		case "int64", "uint64":
-			fmt.Fprintf(output, "| %-61s |\n", "")
-			fmt.Fprintf(output, "+ %s +\n", center(name+" (64 bits)", 61))
-			fmt.Fprintf(output, "| %-61s |\n", "")
-			fmt.Fprintln(output, line)
+			fmt.Printf("| %-61s |\n", "")
+			fmt.Printf("+ %s +\n", center(name+" (64 bits)", 61))
+			fmt.Printf("| %-61s |\n", "")
+			fmt.Println(line)
 		case "string", "byte": // XXX We assume slice of byte!
-			fmt.Fprintf(output, "| %s |\n", center("Length of "+name, 61))
-			fmt.Fprintln(output, line)
-			fmt.Fprintf(output, "/ %61s /\n", "")
-			fmt.Fprintf(output, "\\ %s \\\n", center(name+" (variable length)", 61))
-			fmt.Fprintf(output, "/ %61s /\n", "")
-			fmt.Fprintln(output, line)
+			fmt.Printf("| %s |\n", center("Length of "+name, 61))
+			fmt.Println(line)
+			fmt.Printf("/ %61s /\n", "")
+			fmt.Printf("\\ %s \\\n", center(name+" (variable length)", 61))
+			fmt.Printf("/ %61s /\n", "")
+			fmt.Println(line)
 		default:
 			if sl {
 				tn = "Zero or more " + tn + " Structures"
-				fmt.Fprintf(output, "/ %s /\n", center("", 61))
-				fmt.Fprintf(output, "\\ %s \\\n", center(tn, 61))
-				fmt.Fprintf(output, "/ %s /\n", center("", 61))
+				fmt.Printf("/ %s /\n", center("", 61))
+				fmt.Printf("\\ %s \\\n", center(tn, 61))
+				fmt.Printf("/ %s /\n", center("", 61))
 			} else {
-				fmt.Fprintf(output, "| %s |\n", center(tn, 61))
+				fmt.Printf("| %s |\n", center(tn, 61))
 			}
-			fmt.Fprintln(output, line)
+			fmt.Println(line)
 		}
 	}
-	fmt.Fprintln(output)
-	fmt.Fprintln(output)
+	fmt.Println()
+	fmt.Println()
 }
 
-func generateXdr(output io.Writer, s structInfo) {
+func generateXdr(s structInfo) {
 	sn := s.Name
 	fs := s.Fields
 
-	fmt.Fprintf(output, "struct %s {\n", sn)
+	fmt.Printf("struct %s {\n", sn)
 
 	for _, f := range fs {
 		tn := f.FieldType
@@ -375,21 +365,21 @@ func generateXdr(output io.Writer, s structInfo) {
 
 		switch tn {
 		case "uint16", "uint32":
-			fmt.Fprintf(output, "\tunsigned int %s%s;\n", fn, suf)
+			fmt.Printf("\tunsigned int %s%s;\n", fn, suf)
 		case "int64":
-			fmt.Fprintf(output, "\thyper %s%s;\n", fn, suf)
+			fmt.Printf("\thyper %s%s;\n", fn, suf)
 		case "uint64":
-			fmt.Fprintf(output, "\tunsigned hyper %s%s;\n", fn, suf)
+			fmt.Printf("\tunsigned hyper %s%s;\n", fn, suf)
 		case "string":
-			fmt.Fprintf(output, "\tstring %s<%s>;\n", fn, l)
+			fmt.Printf("\tstring %s<%s>;\n", fn, l)
 		case "byte":
-			fmt.Fprintf(output, "\topaque %s<%s>;\n", fn, l)
+			fmt.Printf("\topaque %s<%s>;\n", fn, l)
 		default:
-			fmt.Fprintf(output, "\t%s %s%s;\n", tn, fn, suf)
+			fmt.Printf("\t%s %s%s;\n", tn, fn, suf)
 		}
 	}
-	fmt.Fprintln(output, "}")
-	fmt.Fprintln(output)
+	fmt.Println("}")
+	fmt.Println()
 }
 
 func center(s string, w int) string {
@@ -420,35 +410,25 @@ func inspector(structs *[]structInfo) func(ast.Node) bool {
 }
 
 func main() {
-	outputFile := flag.String("o", "", "Output file, blank for stdout")
 	flag.Parse()
 	fname := flag.Arg(0)
 
 	fset := token.NewFileSet()
 	f, err := parser.ParseFile(fset, fname, nil, parser.ParseComments)
 	if err != nil {
-		log.Fatal(err)
+		panic(err)
 	}
 
 	var structs []structInfo
 	i := inspector(&structs)
 	ast.Inspect(f, i)
 
-	var output io.Writer = os.Stdout
-	if *outputFile != "" {
-		fd, err := os.Create(*outputFile)
-		if err != nil {
-			log.Fatal(err)
-		}
-		output = fd
-	}
-
-	headerTpl.Execute(output, map[string]string{"Package": f.Name.Name})
+	headerTpl.Execute(os.Stdout, map[string]string{"Package": f.Name.Name})
 	for _, s := range structs {
-		fmt.Fprintf(output, "\n/*\n\n")
-		generateDiagram(output, s)
-		generateXdr(output, s)
-		fmt.Fprintf(output, "*/\n")
-		generateCode(output, s)
+		fmt.Printf("\n/*\n\n")
+		generateDiagram(s)
+		generateXdr(s)
+		fmt.Printf("*/\n")
+		generateCode(s)
 	}
 }

Godeps/_workspace/src/github.com/calmh/xdr/encdec_test.go

@@ -24,10 +24,9 @@ type TestStruct struct {
 	UI32 uint32
 	I64  int64
 	UI64 uint64
-	BS   []byte // max:1024
-	S    string // max:1024
+	BS   []byte
+	S    string
 	C    Opaque
-	SS   []string // max:1024
 }
 
 type Opaque [32]byte
@@ -50,12 +49,9 @@ func (Opaque) Generate(rand *rand.Rand, size int) reflect.Value {
 
 func TestEncDec(t *testing.T) {
 	fn := func(t0 TestStruct) bool {
-		bs, err := t0.MarshalXDR()
-		if err != nil {
-			t.Fatal(err)
-		}
+		bs := t0.MarshalXDR()
 		var t1 TestStruct
-		err = t1.UnmarshalXDR(bs)
+		err := t1.UnmarshalXDR(bs)
 		if err != nil {
 			t.Fatal(err)
 		}

Godeps/_workspace/src/github.com/calmh/xdr/encdec_xdr_test.go

@@ -54,14 +54,6 @@ TestStruct Structure:
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |                            Opaque                             |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Number of SS                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of SS                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     SS (variable length)                      \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 
 struct TestStruct {
@@ -74,10 +66,9 @@ struct TestStruct {
 	unsigned int UI32;
 	hyper I64;
 	unsigned hyper UI64;
-	opaque BS<1024>;
-	string S<1024>;
+	opaque BS<>;
+	string S<>;
 	Opaque C;
-	string SS<1024>;
 }
 
 */
@@ -87,23 +78,15 @@ func (o TestStruct) EncodeXDR(w io.Writer) (int, error) {
 	return o.encodeXDR(xw)
 }
 
-func (o TestStruct) MarshalXDR() ([]byte, error) {
+func (o TestStruct) MarshalXDR() []byte {
 	return o.AppendXDR(make([]byte, 0, 128))
 }
 
-func (o TestStruct) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o TestStruct) AppendXDR(bs []byte) ([]byte, error) {
+func (o TestStruct) AppendXDR(bs []byte) []byte {
 	var aw = xdr.AppendWriter(bs)
 	var xw = xdr.NewWriter(&aw)
-	_, err := o.encodeXDR(xw)
-	return []byte(aw), err
+	o.encodeXDR(xw)
+	return []byte(aw)
 }
 
 func (o TestStruct) encodeXDR(xw *xdr.Writer) (int, error) {
@@ -116,25 +99,12 @@ func (o TestStruct) encodeXDR(xw *xdr.Writer) (int, error) {
 	xw.WriteUint32(o.UI32)
 	xw.WriteUint64(uint64(o.I64))
 	xw.WriteUint64(o.UI64)
-	if l := len(o.BS); l > 1024 {
-		return xw.Tot(), xdr.ElementSizeExceeded("BS", l, 1024)
-	}
 	xw.WriteBytes(o.BS)
-	if l := len(o.S); l > 1024 {
-		return xw.Tot(), xdr.ElementSizeExceeded("S", l, 1024)
-	}
 	xw.WriteString(o.S)
 	_, err := o.C.encodeXDR(xw)
 	if err != nil {
 		return xw.Tot(), err
 	}
-	if l := len(o.SS); l > 1024 {
-		return xw.Tot(), xdr.ElementSizeExceeded("SS", l, 1024)
-	}
-	xw.WriteUint32(uint32(len(o.SS)))
-	for i := range o.SS {
-		xw.WriteString(o.SS[i])
-	}
 	return xw.Tot(), xw.Error()
 }
 
@@ -159,16 +129,8 @@ func (o *TestStruct) decodeXDR(xr *xdr.Reader) error {
 	o.UI32 = xr.ReadUint32()
 	o.I64 = int64(xr.ReadUint64())
 	o.UI64 = xr.ReadUint64()
-	o.BS = xr.ReadBytesMax(1024)
-	o.S = xr.ReadStringMax(1024)
+	o.BS = xr.ReadBytes()
+	o.S = xr.ReadString()
 	(&o.C).decodeXDR(xr)
-	_SSSize := int(xr.ReadUint32())
-	if _SSSize > 1024 {
-		return xdr.ElementSizeExceeded("SS", _SSSize, 1024)
-	}
-	o.SS = make([]string, _SSSize)
-	for i := range o.SS {
-		o.SS[i] = xr.ReadString()
-	}
 	return xr.Error()
 }

Godeps/_workspace/src/github.com/calmh/xdr/reader.go

@@ -5,12 +5,14 @@
 package xdr
 
 import (
-	"fmt"
+	"errors"
 	"io"
 	"reflect"
 	"unsafe"
 )
 
+var ErrElementSizeExceeded = errors.New("element size exceeded")
+
 type Reader struct {
 	r   io.Reader
 	err error
@@ -69,7 +71,7 @@ func (r *Reader) ReadBytesMaxInto(max int, dst []byte) []byte {
 		return nil
 	}
 	if max > 0 && l > max {
-		r.err = ElementSizeExceeded("bytes field", l, max)
+		r.err = ErrElementSizeExceeded
 		return nil
 	}
 
@@ -154,17 +156,9 @@ func (e XDRError) Error() string {
 	return "xdr " + e.op + ": " + e.err.Error()
 }
 
-func (e XDRError) IsEOF() bool {
-	return e.err == io.EOF
-}
-
 func (r *Reader) Error() error {
 	if r.err == nil {
 		return nil
 	}
 	return XDRError{"read", r.err}
 }
-
-func ElementSizeExceeded(field string, size, limit int) error {
-	return fmt.Errorf("%s exceeds size limit; %d > %d", field, size, limit)
-}

Godeps/_workspace/src/github.com/calmh/xdr/xdr_test.go

@@ -5,7 +5,6 @@ package xdr
 
 import (
 	"bytes"
-	"strings"
 	"testing"
 	"testing/quick"
 )
@@ -61,7 +60,7 @@ func TestReadBytesMaxInto(t *testing.T) {
 				if read := len(bs); read != tot {
 					t.Errorf("Incorrect read bytes, wrote=%d, buf=%d, max=%d, read=%d", tot, tot+diff, max, read)
 				}
-			} else if !strings.Contains(r.err.Error(), "exceeds size") {
+			} else if r.err != ErrElementSizeExceeded {
 				t.Errorf("Unexpected non-ErrElementSizeExceeded error for wrote=%d, max=%d: %v", tot, max, r.err)
 			}
 		}
@@ -85,7 +84,7 @@ func TestReadStringMax(t *testing.T) {
 				if read != tot {
 					t.Errorf("Incorrect read bytes, wrote=%d, max=%d, read=%d", tot, max, read)
 				}
-			} else if !strings.Contains(r.err.Error(), "exceeds size") {
+			} else if r.err != ErrElementSizeExceeded {
 				t.Errorf("Unexpected non-ErrElementSizeExceeded error for wrote=%d, max=%d, read=%d: %v", tot, max, read, r.err)
 			}
 		}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch.go

@@ -8,84 +8,65 @@ package leveldb
 
 import (
 	"encoding/binary"
-	"fmt"
+	"errors"
 
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/memdb"
 )
 
-type ErrBatchCorrupted struct {
-	Reason string
-}
-
-func (e *ErrBatchCorrupted) Error() string {
-	return fmt.Sprintf("leveldb: batch corrupted: %s", e.Reason)
-}
-
-func newErrBatchCorrupted(reason string) error {
-	return errors.NewErrCorrupted(nil, &ErrBatchCorrupted{reason})
-}
-
-const (
-	batchHdrLen  = 8 + 4
-	batchGrowRec = 3000
+var (
+	errBatchTooShort  = errors.New("leveldb: batch is too short")
+	errBatchBadRecord = errors.New("leveldb: bad record in batch")
 )
 
-type BatchReplay interface {
-	Put(key, value []byte)
-	Delete(key []byte)
+const kBatchHdrLen = 8 + 4
+
+type batchReplay interface {
+	put(key, value []byte, seq uint64)
+	delete(key []byte, seq uint64)
 }
 
 // Batch is a write batch.
 type Batch struct {
-	data       []byte
+	buf        []byte
 	rLen, bLen int
 	seq        uint64
 	sync       bool
 }
 
 func (b *Batch) grow(n int) {
-	off := len(b.data)
+	off := len(b.buf)
 	if off == 0 {
-		off = batchHdrLen
-		if b.data != nil {
-			b.data = b.data[:off]
-		}
+		// include headers
+		off = kBatchHdrLen
+		n += off
 	}
-	if cap(b.data)-off < n {
-		if b.data == nil {
-			b.data = make([]byte, off, off+n)
-		} else {
-			odata := b.data
-			div := 1
-			if b.rLen > batchGrowRec {
-				div = b.rLen / batchGrowRec
-			}
-			b.data = make([]byte, off, off+n+(off-batchHdrLen)/div)
-			copy(b.data, odata)
-		}
+	if cap(b.buf)-off >= n {
+		return
 	}
+	buf := make([]byte, 2*cap(b.buf)+n)
+	copy(buf, b.buf)
+	b.buf = buf[:off]
 }
 
-func (b *Batch) appendRec(kt kType, key, value []byte) {
+func (b *Batch) appendRec(t vType, key, value []byte) {
 	n := 1 + binary.MaxVarintLen32 + len(key)
-	if kt == ktVal {
+	if t == tVal {
 		n += binary.MaxVarintLen32 + len(value)
 	}
 	b.grow(n)
-	off := len(b.data)
-	data := b.data[:off+n]
-	data[off] = byte(kt)
+	off := len(b.buf)
+	buf := b.buf[:off+n]
+	buf[off] = byte(t)
 	off += 1
-	off += binary.PutUvarint(data[off:], uint64(len(key)))
-	copy(data[off:], key)
+	off += binary.PutUvarint(buf[off:], uint64(len(key)))
+	copy(buf[off:], key)
 	off += len(key)
-	if kt == ktVal {
-		off += binary.PutUvarint(data[off:], uint64(len(value)))
-		copy(data[off:], value)
+	if t == tVal {
+		off += binary.PutUvarint(buf[off:], uint64(len(value)))
+		copy(buf[off:], value)
 		off += len(value)
 	}
-	b.data = data[:off]
+	b.buf = buf[:off]
 	b.rLen++
 	//  Include 8-byte ikey header
 	b.bLen += len(key) + len(value) + 8
@@ -94,51 +75,18 @@ func (b *Batch) appendRec(kt kType, key, value []byte) {
 // Put appends 'put operation' of the given key/value pair to the batch.
 // It is safe to modify the contents of the argument after Put returns.
 func (b *Batch) Put(key, value []byte) {
-	b.appendRec(ktVal, key, value)
+	b.appendRec(tVal, key, value)
 }
 
 // Delete appends 'delete operation' of the given key to the batch.
 // It is safe to modify the contents of the argument after Delete returns.
 func (b *Batch) Delete(key []byte) {
-	b.appendRec(ktDel, key, nil)
-}
-
-// Dump dumps batch contents. The returned slice can be loaded into the
-// batch using Load method.
-// The returned slice is not its own copy, so the contents should not be
-// modified.
-func (b *Batch) Dump() []byte {
-	return b.encode()
-}
-
-// Load loads given slice into the batch. Previous contents of the batch
-// will be discarded.
-// The given slice will not be copied and will be used as batch buffer, so
-// it is not safe to modify the contents of the slice.
-func (b *Batch) Load(data []byte) error {
-	return b.decode(0, data)
-}
-
-// Replay replays batch contents.
-func (b *Batch) Replay(r BatchReplay) error {
-	return b.decodeRec(func(i int, kt kType, key, value []byte) {
-		switch kt {
-		case ktVal:
-			r.Put(key, value)
-		case ktDel:
-			r.Delete(key)
-		}
-	})
-}
-
-// Len returns number of records in the batch.
-func (b *Batch) Len() int {
-	return b.rLen
+	b.appendRec(tDel, key, nil)
 }
 
 // Reset resets the batch.
 func (b *Batch) Reset() {
-	b.data = b.data[:0]
+	b.buf = nil
 	b.seq = 0
 	b.rLen = 0
 	b.bLen = 0
@@ -149,10 +97,24 @@ func (b *Batch) init(sync bool) {
 	b.sync = sync
 }
 
+func (b *Batch) put(key, value []byte, seq uint64) {
+	if b.rLen == 0 {
+		b.seq = seq
+	}
+	b.Put(key, value)
+}
+
+func (b *Batch) delete(key []byte, seq uint64) {
+	if b.rLen == 0 {
+		b.seq = seq
+	}
+	b.Delete(key)
+}
+
 func (b *Batch) append(p *Batch) {
 	if p.rLen > 0 {
-		b.grow(len(p.data) - batchHdrLen)
-		b.data = append(b.data, p.data[batchHdrLen:]...)
+		b.grow(len(p.buf) - kBatchHdrLen)
+		b.buf = append(b.buf, p.buf[kBatchHdrLen:]...)
 		b.rLen += p.rLen
 	}
 	if p.sync {
@@ -160,93 +122,95 @@ func (b *Batch) append(p *Batch) {
 	}
 }
 
-// size returns sums of key/value pair length plus 8-bytes ikey.
+func (b *Batch) len() int {
+	return b.rLen
+}
+
 func (b *Batch) size() int {
 	return b.bLen
 }
 
 func (b *Batch) encode() []byte {
 	b.grow(0)
-	binary.LittleEndian.PutUint64(b.data, b.seq)
-	binary.LittleEndian.PutUint32(b.data[8:], uint32(b.rLen))
+	binary.LittleEndian.PutUint64(b.buf, b.seq)
+	binary.LittleEndian.PutUint32(b.buf[8:], uint32(b.rLen))
 
-	return b.data
+	return b.buf
 }
 
-func (b *Batch) decode(prevSeq uint64, data []byte) error {
-	if len(data) < batchHdrLen {
-		return newErrBatchCorrupted("too short")
+func (b *Batch) decode(buf []byte) error {
+	if len(buf) < kBatchHdrLen {
+		return errBatchTooShort
 	}
 
-	b.seq = binary.LittleEndian.Uint64(data)
-	if b.seq < prevSeq {
-		return newErrBatchCorrupted("invalid sequence number")
-	}
-	b.rLen = int(binary.LittleEndian.Uint32(data[8:]))
-	if b.rLen < 0 {
-		return newErrBatchCorrupted("invalid records length")
-	}
+	b.seq = binary.LittleEndian.Uint64(buf)
+	b.rLen = int(binary.LittleEndian.Uint32(buf[8:]))
 	// No need to be precise at this point, it won't be used anyway
-	b.bLen = len(data) - batchHdrLen
-	b.data = data
+	b.bLen = len(buf) - kBatchHdrLen
+	b.buf = buf
 
 	return nil
 }
 
-func (b *Batch) decodeRec(f func(i int, kt kType, key, value []byte)) (err error) {
-	off := batchHdrLen
+func (b *Batch) decodeRec(f func(i int, t vType, key, value []byte)) error {
+	off := kBatchHdrLen
 	for i := 0; i < b.rLen; i++ {
-		if off >= len(b.data) {
-			return newErrBatchCorrupted("invalid records length")
+		if off >= len(b.buf) {
+			return errors.New("leveldb: invalid batch record length")
 		}
 
-		kt := kType(b.data[off])
-		if kt > ktVal {
-			return newErrBatchCorrupted("bad record: invalid type")
+		t := vType(b.buf[off])
+		if t > tVal {
+			return errors.New("leveldb: invalid batch record type in batch")
 		}
 		off += 1
 
-		x, n := binary.Uvarint(b.data[off:])
+		x, n := binary.Uvarint(b.buf[off:])
 		off += n
-		if n <= 0 || off+int(x) > len(b.data) {
-			return newErrBatchCorrupted("bad record: invalid key length")
+		if n <= 0 || off+int(x) > len(b.buf) {
+			return errBatchBadRecord
 		}
-		key := b.data[off : off+int(x)]
+		key := b.buf[off : off+int(x)]
 		off += int(x)
+
 		var value []byte
-		if kt == ktVal {
-			x, n := binary.Uvarint(b.data[off:])
+		if t == tVal {
+			x, n := binary.Uvarint(b.buf[off:])
 			off += n
-			if n <= 0 || off+int(x) > len(b.data) {
-				return newErrBatchCorrupted("bad record: invalid value length")
+			if n <= 0 || off+int(x) > len(b.buf) {
+				return errBatchBadRecord
 			}
-			value = b.data[off : off+int(x)]
+			value = b.buf[off : off+int(x)]
 			off += int(x)
 		}
 
-		f(i, kt, key, value)
+		f(i, t, key, value)
 	}
 
 	return nil
 }
 
+func (b *Batch) replay(to batchReplay) error {
+	return b.decodeRec(func(i int, t vType, key, value []byte) {
+		switch t {
+		case tVal:
+			to.put(key, value, b.seq+uint64(i))
+		case tDel:
+			to.delete(key, b.seq+uint64(i))
+		}
+	})
+}
+
 func (b *Batch) memReplay(to *memdb.DB) error {
-	return b.decodeRec(func(i int, kt kType, key, value []byte) {
-		ikey := newIkey(key, b.seq+uint64(i), kt)
+	return b.decodeRec(func(i int, t vType, key, value []byte) {
+		ikey := newIKey(key, b.seq+uint64(i), t)
 		to.Put(ikey, value)
 	})
 }
 
-func (b *Batch) memDecodeAndReplay(prevSeq uint64, data []byte, to *memdb.DB) error {
-	if err := b.decode(prevSeq, data); err != nil {
-		return err
-	}
-	return b.memReplay(to)
-}
-
 func (b *Batch) revertMemReplay(to *memdb.DB) error {
-	return b.decodeRec(func(i int, kt kType, key, value []byte) {
-		ikey := newIkey(key, b.seq+uint64(i), kt)
+	return b.decodeRec(func(i int, t vType, key, value []byte) {
+		ikey := newIKey(key, b.seq+uint64(i), t)
 		to.Delete(ikey)
 	})
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch_test.go

@@ -15,7 +15,7 @@ import (
 )
 
 type tbRec struct {
-	kt         kType
+	t          vType
 	key, value []byte
 }
 
@@ -23,39 +23,39 @@ type testBatch struct {
 	rec []*tbRec
 }
 
-func (p *testBatch) Put(key, value []byte) {
-	p.rec = append(p.rec, &tbRec{ktVal, key, value})
+func (p *testBatch) put(key, value []byte, seq uint64) {
+	p.rec = append(p.rec, &tbRec{tVal, key, value})
 }
 
-func (p *testBatch) Delete(key []byte) {
-	p.rec = append(p.rec, &tbRec{ktDel, key, nil})
+func (p *testBatch) delete(key []byte, seq uint64) {
+	p.rec = append(p.rec, &tbRec{tDel, key, nil})
 }
 
 func compareBatch(t *testing.T, b1, b2 *Batch) {
 	if b1.seq != b2.seq {
 		t.Errorf("invalid seq number want %d, got %d", b1.seq, b2.seq)
 	}
-	if b1.Len() != b2.Len() {
-		t.Fatalf("invalid record length want %d, got %d", b1.Len(), b2.Len())
+	if b1.len() != b2.len() {
+		t.Fatalf("invalid record length want %d, got %d", b1.len(), b2.len())
 	}
 	p1, p2 := new(testBatch), new(testBatch)
-	err := b1.Replay(p1)
+	err := b1.replay(p1)
 	if err != nil {
 		t.Fatal("error when replaying batch 1: ", err)
 	}
-	err = b2.Replay(p2)
+	err = b2.replay(p2)
 	if err != nil {
 		t.Fatal("error when replaying batch 2: ", err)
 	}
 	for i := range p1.rec {
 		r1, r2 := p1.rec[i], p2.rec[i]
-		if r1.kt != r2.kt {
-			t.Errorf("invalid type on record '%d' want %d, got %d", i, r1.kt, r2.kt)
+		if r1.t != r2.t {
+			t.Errorf("invalid type on record '%d' want %d, got %d", i, r1.t, r2.t)
 		}
 		if !bytes.Equal(r1.key, r2.key) {
 			t.Errorf("invalid key on record '%d' want %s, got %s", i, string(r1.key), string(r2.key))
 		}
-		if r1.kt == ktVal {
+		if r1.t == tVal {
 			if !bytes.Equal(r1.value, r2.value) {
 				t.Errorf("invalid value on record '%d' want %s, got %s", i, string(r1.value), string(r2.value))
 			}
@@ -75,7 +75,7 @@ func TestBatch_EncodeDecode(t *testing.T) {
 	b1.Delete([]byte("k"))
 	buf := b1.encode()
 	b2 := new(Batch)
-	err := b2.decode(0, buf)
+	err := b2.decode(buf)
 	if err != nil {
 		t.Error("error when decoding batch: ", err)
 	}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go

@@ -8,669 +8,151 @@
 package cache
 
 import (
-	"sync"
 	"sync/atomic"
-	"unsafe"
-
-	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
-// Cacher provides interface to implements a caching functionality.
-// An implementation must be goroutine-safe.
-type Cacher interface {
-	// Capacity returns cache capacity.
-	Capacity() int
+// SetFunc is the function that will be called by Namespace.Get to create
+// a cache object, if charge is less than one than the cache object will
+// not be registered to cache tree, if value is nil then the cache object
+// will not be created.
+type SetFunc func() (charge int, value interface{})
 
-	// SetCapacity sets cache capacity.
+// DelFin is the function that will be called as the result of a delete operation.
+// Exist == true is indication that the object is exist, and pending == true is
+// indication of deletion already happen but haven't done yet (wait for all handles
+// to be released). And exist == false means the object doesn't exist.
+type DelFin func(exist, pending bool)
+
+// PurgeFin is the function that will be called as the result of a purge operation.
+type PurgeFin func(ns, key uint64)
+
+// Cache is a cache tree. A cache instance must be goroutine-safe.
+type Cache interface {
+	// SetCapacity sets cache tree capacity.
 	SetCapacity(capacity int)
 
-	// Promote promotes the 'cache node'.
-	Promote(n *Node)
+	// Capacity returns cache tree capacity.
+	Capacity() int
 
-	// Ban evicts the 'cache node' and prevent subsequent 'promote'.
-	Ban(n *Node)
+	// Used returns used cache tree capacity.
+	Used() int
 
-	// Evict evicts the 'cache node'.
-	Evict(n *Node)
+	// Size returns entire alive cache objects size.
+	Size() int
 
-	// EvictNS evicts 'cache node' with the given namespace.
-	EvictNS(ns uint64)
+	// NumObjects returns number of alive objects.
+	NumObjects() int
 
-	// EvictAll evicts all 'cache node'.
-	EvictAll()
+	// GetNamespace gets cache namespace with the given id.
+	// GetNamespace is never return nil.
+	GetNamespace(id uint64) Namespace
 
-	// Close closes the 'cache tree'
-	Close() error
+	// PurgeNamespace purges cache namespace with the given id from this cache tree.
+	// Also read Namespace.Purge.
+	PurgeNamespace(id uint64, fin PurgeFin)
+
+	// ZapNamespace detaches cache namespace with the given id from this cache tree.
+	// Also read Namespace.Zap.
+	ZapNamespace(id uint64)
+
+	// Purge purges all cache namespace from this cache tree.
+	// This is behave the same as calling Namespace.Purge method on all cache namespace.
+	Purge(fin PurgeFin)
+
+	// Zap detaches all cache namespace from this cache tree.
+	// This is behave the same as calling Namespace.Zap method on all cache namespace.
+	Zap()
 }
 
-// Value is a 'cacheable object'. It may implements util.Releaser, if
-// so the the Release method will be called once object is released.
-type Value interface{}
+// Namespace is a cache namespace. A namespace instance must be goroutine-safe.
+type Namespace interface {
+	// Get gets cache object with the given key.
+	// If cache object is not found and setf is not nil, Get will atomically creates
+	// the cache object by calling setf. Otherwise Get will returns nil.
+	//
+	// The returned cache handle should be released after use by calling Release
+	// method.
+	Get(key uint64, setf SetFunc) Handle
 
-type CacheGetter struct {
-	Cache *Cache
-	NS    uint64
+	// Delete removes cache object with the given key from cache tree.
+	// A deleted cache object will be released as soon as all of its handles have
+	// been released.
+	// Delete only happen once, subsequent delete will consider cache object doesn't
+	// exist, even if the cache object ins't released yet.
+	//
+	// If not nil, fin will be called if the cache object doesn't exist or when
+	// finally be released.
+	//
+	// Delete returns true if such cache object exist and never been deleted.
+	Delete(key uint64, fin DelFin) bool
+
+	// Purge removes all cache objects within this namespace from cache tree.
+	// This is the same as doing delete on all cache objects.
+	//
+	// If not nil, fin will be called on all cache objects when its finally be
+	// released.
+	Purge(fin PurgeFin)
+
+	// Zap detaches namespace from cache tree and release all its cache objects.
+	// A zapped namespace can never be filled again.
+	// Calling Get on zapped namespace will always return nil.
+	Zap()
 }
 
-func (g *CacheGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle {
-	return g.Cache.Get(g.NS, key, setFunc)
-}
+// Handle is a cache handle.
+type Handle interface {
+	// Release releases this cache handle. This method can be safely called mutiple
+	// times.
+	Release()
 
-// The hash tables implementation is based on:
-// "Dynamic-Sized Nonblocking Hash Tables", by Yujie Liu, Kunlong Zhang, and Michael Spear. ACM Symposium on Principles of Distributed Computing, Jul 2014.
+	// Value returns value of this cache handle.
+	// Value will returns nil after this cache handle have be released.
+	Value() interface{}
+}
 
 const (
-	mInitialSize           = 1 << 4
-	mOverflowThreshold     = 1 << 5
-	mOverflowGrowThreshold = 1 << 7
+	DelNotExist = iota
+	DelExist
+	DelPendig
 )
 
-type mBucket struct {
-	mu     sync.Mutex
-	node   []*Node
-	frozen bool
+// Namespace state.
+type nsState int
+
+const (
+	nsEffective nsState = iota
+	nsZapped
+)
+
+// Node state.
+type nodeState int
+
+const (
+	nodeEffective nodeState = iota
+	nodeEvicted
+	nodeDeleted
+)
+
+// Fake handle.
+type fakeHandle struct {
+	value interface{}
+	fin   func()
+	once  uint32
 }
 
-func (b *mBucket) freeze() []*Node {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	if !b.frozen {
-		b.frozen = true
-	}
-	return b.node
-}
-
-func (b *mBucket) get(r *Cache, h *mNode, hash uint32, ns, key uint64, noset bool) (done, added bool, n *Node) {
-	b.mu.Lock()
-
-	if b.frozen {
-		b.mu.Unlock()
-		return
-	}
-
-	// Scan the node.
-	for _, n := range b.node {
-		if n.hash == hash && n.ns == ns && n.key == key {
-			atomic.AddInt32(&n.ref, 1)
-			b.mu.Unlock()
-			return true, false, n
-		}
-	}
-
-	// Get only.
-	if noset {
-		b.mu.Unlock()
-		return true, false, nil
-	}
-
-	// Create node.
-	n = &Node{
-		r:    r,
-		hash: hash,
-		ns:   ns,
-		key:  key,
-		ref:  1,
-	}
-	// Add node to bucket.
-	b.node = append(b.node, n)
-	bLen := len(b.node)
-	b.mu.Unlock()
-
-	// Update counter.
-	grow := atomic.AddInt32(&r.nodes, 1) >= h.growThreshold
-	if bLen > mOverflowThreshold {
-		grow = grow || atomic.AddInt32(&h.overflow, 1) >= mOverflowGrowThreshold
-	}
-
-	// Grow.
-	if grow && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
-		nhLen := len(h.buckets) << 1
-		nh := &mNode{
-			buckets:         make([]unsafe.Pointer, nhLen),
-			mask:            uint32(nhLen) - 1,
-			pred:            unsafe.Pointer(h),
-			growThreshold:   int32(nhLen * mOverflowThreshold),
-			shrinkThreshold: int32(nhLen >> 1),
-		}
-		ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
-		if !ok {
-			panic("BUG: failed swapping head")
-		}
-		go nh.initBuckets()
-	}
-
-	return true, true, n
-}
-
-func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
-	b.mu.Lock()
-
-	if b.frozen {
-		b.mu.Unlock()
-		return
-	}
-
-	// Scan the node.
-	var (
-		n    *Node
-		bLen int
-	)
-	for i := range b.node {
-		n = b.node[i]
-		if n.ns == ns && n.key == key {
-			if atomic.LoadInt32(&n.ref) == 0 {
-				deleted = true
-
-				// Call releaser.
-				if n.value != nil {
-					if r, ok := n.value.(util.Releaser); ok {
-						r.Release()
-					}
-					n.value = nil
-				}
-
-				// Remove node from bucket.
-				b.node = append(b.node[:i], b.node[i+1:]...)
-				bLen = len(b.node)
-			}
-			break
-		}
-	}
-	b.mu.Unlock()
-
-	if deleted {
-		// Call OnDel.
-		for _, f := range n.onDel {
-			f()
-		}
-
-		// Update counter.
-		atomic.AddInt32(&r.size, int32(n.size)*-1)
-		shrink := atomic.AddInt32(&r.nodes, -1) < h.shrinkThreshold
-		if bLen >= mOverflowThreshold {
-			atomic.AddInt32(&h.overflow, -1)
-		}
-
-		// Shrink.
-		if shrink && len(h.buckets) > mInitialSize && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
-			nhLen := len(h.buckets) >> 1
-			nh := &mNode{
-				buckets:         make([]unsafe.Pointer, nhLen),
-				mask:            uint32(nhLen) - 1,
-				pred:            unsafe.Pointer(h),
-				growThreshold:   int32(nhLen * mOverflowThreshold),
-				shrinkThreshold: int32(nhLen >> 1),
-			}
-			ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
-			if !ok {
-				panic("BUG: failed swapping head")
-			}
-			go nh.initBuckets()
-		}
-	}
-
-	return true, deleted
-}
-
-type mNode struct {
-	buckets         []unsafe.Pointer // []*mBucket
-	mask            uint32
-	pred            unsafe.Pointer // *mNode
-	resizeInProgess int32
-
-	overflow        int32
-	growThreshold   int32
-	shrinkThreshold int32
-}
-
-func (n *mNode) initBucket(i uint32) *mBucket {
-	if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
-		return b
-	}
-
-	p := (*mNode)(atomic.LoadPointer(&n.pred))
-	if p != nil {
-		var node []*Node
-		if n.mask > p.mask {
-			// Grow.
-			pb := (*mBucket)(atomic.LoadPointer(&p.buckets[i&p.mask]))
-			if pb == nil {
-				pb = p.initBucket(i & p.mask)
-			}
-			m := pb.freeze()
-			// Split nodes.
-			for _, x := range m {
-				if x.hash&n.mask == i {
-					node = append(node, x)
-				}
-			}
-		} else {
-			// Shrink.
-			pb0 := (*mBucket)(atomic.LoadPointer(&p.buckets[i]))
-			if pb0 == nil {
-				pb0 = p.initBucket(i)
-			}
-			pb1 := (*mBucket)(atomic.LoadPointer(&p.buckets[i+uint32(len(n.buckets))]))
-			if pb1 == nil {
-				pb1 = p.initBucket(i + uint32(len(n.buckets)))
-			}
-			m0 := pb0.freeze()
-			m1 := pb1.freeze()
-			// Merge nodes.
-			node = make([]*Node, 0, len(m0)+len(m1))
-			node = append(node, m0...)
-			node = append(node, m1...)
-		}
-		b := &mBucket{node: node}
-		if atomic.CompareAndSwapPointer(&n.buckets[i], nil, unsafe.Pointer(b)) {
-			if len(node) > mOverflowThreshold {
-				atomic.AddInt32(&n.overflow, int32(len(node)-mOverflowThreshold))
-			}
-			return b
-		}
-	}
-
-	return (*mBucket)(atomic.LoadPointer(&n.buckets[i]))
-}
-
-func (n *mNode) initBuckets() {
-	for i := range n.buckets {
-		n.initBucket(uint32(i))
-	}
-	atomic.StorePointer(&n.pred, nil)
-}
-
-// Cache is a 'cache map'.
-type Cache struct {
-	mu     sync.RWMutex
-	mHead  unsafe.Pointer // *mNode
-	nodes  int32
-	size   int32
-	cacher Cacher
-	closed bool
-}
-
-// NewCache creates a new 'cache map'. The cacher is optional and
-// may be nil.
-func NewCache(cacher Cacher) *Cache {
-	h := &mNode{
-		buckets:         make([]unsafe.Pointer, mInitialSize),
-		mask:            mInitialSize - 1,
-		growThreshold:   int32(mInitialSize * mOverflowThreshold),
-		shrinkThreshold: 0,
-	}
-	for i := range h.buckets {
-		h.buckets[i] = unsafe.Pointer(&mBucket{})
-	}
-	r := &Cache{
-		mHead:  unsafe.Pointer(h),
-		cacher: cacher,
-	}
-	return r
-}
-
-func (r *Cache) getBucket(hash uint32) (*mNode, *mBucket) {
-	h := (*mNode)(atomic.LoadPointer(&r.mHead))
-	i := hash & h.mask
-	b := (*mBucket)(atomic.LoadPointer(&h.buckets[i]))
-	if b == nil {
-		b = h.initBucket(i)
-	}
-	return h, b
-}
-
-func (r *Cache) delete(n *Node) bool {
-	for {
-		h, b := r.getBucket(n.hash)
-		done, deleted := b.delete(r, h, n.hash, n.ns, n.key)
-		if done {
-			return deleted
-		}
-	}
-	return false
-}
-
-// Nodes returns number of 'cache node' in the map.
-func (r *Cache) Nodes() int {
-	return int(atomic.LoadInt32(&r.nodes))
-}
-
-// Size returns sums of 'cache node' size in the map.
-func (r *Cache) Size() int {
-	return int(atomic.LoadInt32(&r.size))
-}
-
-// Capacity returns cache capacity.
-func (r *Cache) Capacity() int {
-	if r.cacher == nil {
-		return 0
-	}
-	return r.cacher.Capacity()
-}
-
-// SetCapacity sets cache capacity.
-func (r *Cache) SetCapacity(capacity int) {
-	if r.cacher != nil {
-		r.cacher.SetCapacity(capacity)
-	}
-}
-
-// Get gets 'cache node' with the given namespace and key.
-// If cache node is not found and setFunc is not nil, Get will atomically creates
-// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
-//
-// The returned 'cache handle' should be released after use by calling Release
-// method.
-func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return nil
-	}
-
-	hash := murmur32(ns, key, 0xf00)
-	for {
-		h, b := r.getBucket(hash)
-		done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
-		if done {
-			if n != nil {
-				n.mu.Lock()
-				if n.value == nil {
-					if setFunc == nil {
-						n.mu.Unlock()
-						n.unref()
-						return nil
-					}
-
-					n.size, n.value = setFunc()
-					if n.value == nil {
-						n.size = 0
-						n.mu.Unlock()
-						n.unref()
-						return nil
-					}
-					atomic.AddInt32(&r.size, int32(n.size))
-				}
-				n.mu.Unlock()
-				if r.cacher != nil {
-					r.cacher.Promote(n)
-				}
-				return &Handle{unsafe.Pointer(n)}
-			}
-
-			break
-		}
+func (h *fakeHandle) Value() interface{} {
+	if atomic.LoadUint32(&h.once) == 0 {
+		return h.value
 	}
 	return nil
 }
 
-// Delete removes and ban 'cache node' with the given namespace and key.
-// A banned 'cache node' will never inserted into the 'cache tree'. Ban
-// only attributed to the particular 'cache node', so when a 'cache node'
-// is recreated it will not be banned.
-//
-// If onDel is not nil, then it will be executed if such 'cache node'
-// doesn't exist or once the 'cache node' is released.
-//
-// Delete return true is such 'cache node' exist.
-func (r *Cache) Delete(ns, key uint64, onDel func()) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return false
-	}
-
-	hash := murmur32(ns, key, 0xf00)
-	for {
-		h, b := r.getBucket(hash)
-		done, _, n := b.get(r, h, hash, ns, key, true)
-		if done {
-			if n != nil {
-				if onDel != nil {
-					n.mu.Lock()
-					n.onDel = append(n.onDel, onDel)
-					n.mu.Unlock()
-				}
-				if r.cacher != nil {
-					r.cacher.Ban(n)
-				}
-				n.unref()
-				return true
-			}
-
-			break
-		}
-	}
-
-	if onDel != nil {
-		onDel()
-	}
-
-	return false
-}
-
-// Evict evicts 'cache node' with the given namespace and key. This will
-// simply call Cacher.Evict.
-//
-// Evict return true is such 'cache node' exist.
-func (r *Cache) Evict(ns, key uint64) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return false
-	}
-
-	hash := murmur32(ns, key, 0xf00)
-	for {
-		h, b := r.getBucket(hash)
-		done, _, n := b.get(r, h, hash, ns, key, true)
-		if done {
-			if n != nil {
-				if r.cacher != nil {
-					r.cacher.Evict(n)
-				}
-				n.unref()
-				return true
-			}
-
-			break
-		}
-	}
-
-	return false
-}
-
-// EvictNS evicts 'cache node' with the given namespace. This will
-// simply call Cacher.EvictNS.
-func (r *Cache) EvictNS(ns uint64) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
+func (h *fakeHandle) Release() {
+	if !atomic.CompareAndSwapUint32(&h.once, 0, 1) {
 		return
 	}
-
-	if r.cacher != nil {
-		r.cacher.EvictNS(ns)
+	if h.fin != nil {
+		h.fin()
+		h.fin = nil
 	}
 }
-
-// EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
-func (r *Cache) EvictAll() {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return
-	}
-
-	if r.cacher != nil {
-		r.cacher.EvictAll()
-	}
-}
-
-// Close closes the 'cache map' and releases all 'cache node'.
-func (r *Cache) Close() error {
-	r.mu.Lock()
-	if !r.closed {
-		r.closed = true
-
-		if r.cacher != nil {
-			if err := r.cacher.Close(); err != nil {
-				return err
-			}
-		}
-
-		h := (*mNode)(r.mHead)
-		h.initBuckets()
-
-		for i := range h.buckets {
-			b := (*mBucket)(h.buckets[i])
-			for _, n := range b.node {
-				// Call releaser.
-				if n.value != nil {
-					if r, ok := n.value.(util.Releaser); ok {
-						r.Release()
-					}
-					n.value = nil
-				}
-
-				// Call OnDel.
-				for _, f := range n.onDel {
-					f()
-				}
-			}
-		}
-	}
-	r.mu.Unlock()
-	return nil
-}
-
-// Node is a 'cache node'.
-type Node struct {
-	r *Cache
-
-	hash    uint32
-	ns, key uint64
-
-	mu    sync.Mutex
-	size  int
-	value Value
-
-	ref   int32
-	onDel []func()
-
-	CacheData unsafe.Pointer
-}
-
-// NS returns this 'cache node' namespace.
-func (n *Node) NS() uint64 {
-	return n.ns
-}
-
-// Key returns this 'cache node' key.
-func (n *Node) Key() uint64 {
-	return n.key
-}
-
-// Size returns this 'cache node' size.
-func (n *Node) Size() int {
-	return n.size
-}
-
-// Value returns this 'cache node' value.
-func (n *Node) Value() Value {
-	return n.value
-}
-
-// Ref returns this 'cache node' ref counter.
-func (n *Node) Ref() int32 {
-	return atomic.LoadInt32(&n.ref)
-}
-
-// GetHandle returns an handle for this 'cache node'.
-func (n *Node) GetHandle() *Handle {
-	if atomic.AddInt32(&n.ref, 1) <= 1 {
-		panic("BUG: Node.GetHandle on zero ref")
-	}
-	return &Handle{unsafe.Pointer(n)}
-}
-
-func (n *Node) unref() {
-	if atomic.AddInt32(&n.ref, -1) == 0 {
-		n.r.delete(n)
-	}
-}
-
-func (n *Node) unrefLocked() {
-	if atomic.AddInt32(&n.ref, -1) == 0 {
-		n.r.mu.RLock()
-		if !n.r.closed {
-			n.r.delete(n)
-		}
-		n.r.mu.RUnlock()
-	}
-}
-
-type Handle struct {
-	n unsafe.Pointer // *Node
-}
-
-func (h *Handle) Value() Value {
-	n := (*Node)(atomic.LoadPointer(&h.n))
-	if n != nil {
-		return n.value
-	}
-	return nil
-}
-
-func (h *Handle) Release() {
-	nPtr := atomic.LoadPointer(&h.n)
-	if nPtr != nil && atomic.CompareAndSwapPointer(&h.n, nPtr, nil) {
-		n := (*Node)(nPtr)
-		n.unrefLocked()
-	}
-}
-
-func murmur32(ns, key uint64, seed uint32) uint32 {
-	const (
-		m = uint32(0x5bd1e995)
-		r = 24
-	)
-
-	k1 := uint32(ns >> 32)
-	k2 := uint32(ns)
-	k3 := uint32(key >> 32)
-	k4 := uint32(key)
-
-	k1 *= m
-	k1 ^= k1 >> r
-	k1 *= m
-
-	k2 *= m
-	k2 ^= k2 >> r
-	k2 *= m
-
-	k3 *= m
-	k3 ^= k3 >> r
-	k3 *= m
-
-	k4 *= m
-	k4 ^= k4 >> r
-	k4 *= m
-
-	h := seed
-
-	h *= m
-	h ^= k1
-	h *= m
-	h ^= k2
-	h *= m
-	h ^= k3
-	h *= m
-	h ^= k4
-
-	h ^= h >> 13
-	h *= m
-	h ^= h >> 15
-
-	return h
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go

@@ -7,32 +7,19 @@
 package cache
 
 import (
+	"fmt"
 	"math/rand"
 	"runtime"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
-	"unsafe"
 )
 
-type int32o int32
-
-func (o *int32o) acquire() {
-	if atomic.AddInt32((*int32)(o), 1) != 1 {
-		panic("BUG: invalid ref")
-	}
-}
-
-func (o *int32o) Release() {
-	if atomic.AddInt32((*int32)(o), -1) != 0 {
-		panic("BUG: invalid ref")
-	}
-}
-
 type releaserFunc struct {
 	fn    func()
-	value Value
+	value interface{}
 }
 
 func (r releaserFunc) Release() {
@@ -41,8 +28,8 @@ func (r releaserFunc) Release() {
 	}
 }
 
-func set(c *Cache, ns, key uint64, value Value, charge int, relf func()) *Handle {
-	return c.Get(ns, key, func() (int, Value) {
+func set(ns Namespace, key uint64, value interface{}, charge int, relf func()) Handle {
+	return ns.Get(key, func() (int, interface{}) {
 		if relf != nil {
 			return charge, releaserFunc{relf, value}
 		} else {
@@ -51,246 +38,7 @@ func set(c *Cache, ns, key uint64, value Value, charge int, relf func()) *Handle
 	})
 }
 
-func TestCacheMap(t *testing.T) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	nsx := []struct {
-		nobjects, nhandles, concurrent, repeat int
-	}{
-		{10000, 400, 50, 3},
-		{100000, 1000, 100, 10},
-	}
-
-	var (
-		objects [][]int32o
-		handles [][]unsafe.Pointer
-	)
-
-	for _, x := range nsx {
-		objects = append(objects, make([]int32o, x.nobjects))
-		handles = append(handles, make([]unsafe.Pointer, x.nhandles))
-	}
-
-	c := NewCache(nil)
-
-	wg := new(sync.WaitGroup)
-	var done int32
-
-	for ns, x := range nsx {
-		for i := 0; i < x.concurrent; i++ {
-			wg.Add(1)
-			go func(ns, i, repeat int, objects []int32o, handles []unsafe.Pointer) {
-				defer wg.Done()
-				r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-				for j := len(objects) * repeat; j >= 0; j-- {
-					key := uint64(r.Intn(len(objects)))
-					h := c.Get(uint64(ns), key, func() (int, Value) {
-						o := &objects[key]
-						o.acquire()
-						return 1, o
-					})
-					if v := h.Value().(*int32o); v != &objects[key] {
-						t.Fatalf("#%d invalid value: want=%p got=%p", ns, &objects[key], v)
-					}
-					if objects[key] != 1 {
-						t.Fatalf("#%d invalid object %d: %d", ns, key, objects[key])
-					}
-					if !atomic.CompareAndSwapPointer(&handles[r.Intn(len(handles))], nil, unsafe.Pointer(h)) {
-						h.Release()
-					}
-				}
-			}(ns, i, x.repeat, objects[ns], handles[ns])
-		}
-
-		go func(handles []unsafe.Pointer) {
-			r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-			for atomic.LoadInt32(&done) == 0 {
-				i := r.Intn(len(handles))
-				h := (*Handle)(atomic.LoadPointer(&handles[i]))
-				if h != nil && atomic.CompareAndSwapPointer(&handles[i], unsafe.Pointer(h), nil) {
-					h.Release()
-				}
-				time.Sleep(time.Millisecond)
-			}
-		}(handles[ns])
-	}
-
-	go func() {
-		handles := make([]*Handle, 100000)
-		for atomic.LoadInt32(&done) == 0 {
-			for i := range handles {
-				handles[i] = c.Get(999999999, uint64(i), func() (int, Value) {
-					return 1, 1
-				})
-			}
-			for _, h := range handles {
-				h.Release()
-			}
-		}
-	}()
-
-	wg.Wait()
-
-	atomic.StoreInt32(&done, 1)
-
-	for _, handles0 := range handles {
-		for i := range handles0 {
-			h := (*Handle)(atomic.LoadPointer(&handles0[i]))
-			if h != nil && atomic.CompareAndSwapPointer(&handles0[i], unsafe.Pointer(h), nil) {
-				h.Release()
-			}
-		}
-	}
-
-	for ns, objects0 := range objects {
-		for i, o := range objects0 {
-			if o != 0 {
-				t.Fatalf("invalid object #%d.%d: ref=%d", ns, i, o)
-			}
-		}
-	}
-}
-
-func TestCacheMap_NodesAndSize(t *testing.T) {
-	c := NewCache(nil)
-	if c.Nodes() != 0 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
-	}
-	if c.Size() != 0 {
-		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
-	}
-	set(c, 0, 1, 1, 1, nil)
-	set(c, 0, 2, 2, 2, nil)
-	set(c, 1, 1, 3, 3, nil)
-	set(c, 2, 1, 4, 1, nil)
-	if c.Nodes() != 4 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 4, c.Nodes())
-	}
-	if c.Size() != 7 {
-		t.Errorf("invalid size counter: want=%d got=%d", 4, c.Size())
-	}
-}
-
-func TestLRUCache_Capacity(t *testing.T) {
-	c := NewCache(NewLRU(10))
-	if c.Capacity() != 10 {
-		t.Errorf("invalid capacity: want=%d got=%d", 10, c.Capacity())
-	}
-	set(c, 0, 1, 1, 1, nil).Release()
-	set(c, 0, 2, 2, 2, nil).Release()
-	set(c, 1, 1, 3, 3, nil).Release()
-	set(c, 2, 1, 4, 1, nil).Release()
-	set(c, 2, 2, 5, 1, nil).Release()
-	set(c, 2, 3, 6, 1, nil).Release()
-	set(c, 2, 4, 7, 1, nil).Release()
-	set(c, 2, 5, 8, 1, nil).Release()
-	if c.Nodes() != 7 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 7, c.Nodes())
-	}
-	if c.Size() != 10 {
-		t.Errorf("invalid size counter: want=%d got=%d", 10, c.Size())
-	}
-	c.SetCapacity(9)
-	if c.Capacity() != 9 {
-		t.Errorf("invalid capacity: want=%d got=%d", 9, c.Capacity())
-	}
-	if c.Nodes() != 6 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 6, c.Nodes())
-	}
-	if c.Size() != 8 {
-		t.Errorf("invalid size counter: want=%d got=%d", 8, c.Size())
-	}
-}
-
-func TestCacheMap_NilValue(t *testing.T) {
-	c := NewCache(NewLRU(10))
-	h := c.Get(0, 0, func() (size int, value Value) {
-		return 1, nil
-	})
-	if h != nil {
-		t.Error("cache handle is non-nil")
-	}
-	if c.Nodes() != 0 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
-	}
-	if c.Size() != 0 {
-		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
-	}
-}
-
-func TestLRUCache_GetLatency(t *testing.T) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	const (
-		concurrentSet = 30
-		concurrentGet = 3
-		duration      = 3 * time.Second
-		delay         = 3 * time.Millisecond
-		maxkey        = 100000
-	)
-
-	var (
-		set, getHit, getAll        int32
-		getMaxLatency, getDuration int64
-	)
-
-	c := NewCache(NewLRU(5000))
-	wg := &sync.WaitGroup{}
-	until := time.Now().Add(duration)
-	for i := 0; i < concurrentSet; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			r := rand.New(rand.NewSource(time.Now().UnixNano()))
-			for time.Now().Before(until) {
-				c.Get(0, uint64(r.Intn(maxkey)), func() (int, Value) {
-					time.Sleep(delay)
-					atomic.AddInt32(&set, 1)
-					return 1, 1
-				}).Release()
-			}
-		}(i)
-	}
-	for i := 0; i < concurrentGet; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			r := rand.New(rand.NewSource(time.Now().UnixNano()))
-			for {
-				mark := time.Now()
-				if mark.Before(until) {
-					h := c.Get(0, uint64(r.Intn(maxkey)), nil)
-					latency := int64(time.Now().Sub(mark))
-					m := atomic.LoadInt64(&getMaxLatency)
-					if latency > m {
-						atomic.CompareAndSwapInt64(&getMaxLatency, m, latency)
-					}
-					atomic.AddInt64(&getDuration, latency)
-					if h != nil {
-						atomic.AddInt32(&getHit, 1)
-						h.Release()
-					}
-					atomic.AddInt32(&getAll, 1)
-				} else {
-					break
-				}
-			}
-		}(i)
-	}
-
-	wg.Wait()
-	getAvglatency := time.Duration(getDuration) / time.Duration(getAll)
-	t.Logf("set=%d getHit=%d getAll=%d getMaxLatency=%v getAvgLatency=%v",
-		set, getHit, getAll, time.Duration(getMaxLatency), getAvglatency)
-
-	if getAvglatency > delay/3 {
-		t.Errorf("get avg latency > %v: got=%v", delay/3, getAvglatency)
-	}
-}
-
-func TestLRUCache_HitMiss(t *testing.T) {
+func TestCache_HitMiss(t *testing.T) {
 	cases := []struct {
 		key   uint64
 		value string
@@ -308,13 +56,14 @@ func TestLRUCache_HitMiss(t *testing.T) {
 	}
 
 	setfin := 0
-	c := NewCache(NewLRU(1000))
+	c := NewLRUCache(1000)
+	ns := c.GetNamespace(0)
 	for i, x := range cases {
-		set(c, 0, x.key, x.value, len(x.value), func() {
+		set(ns, x.key, x.value, len(x.value), func() {
 			setfin++
 		}).Release()
 		for j, y := range cases {
-			h := c.Get(0, y.key, nil)
+			h := ns.Get(y.key, nil)
 			if j <= i {
 				// should hit
 				if h == nil {
@@ -338,7 +87,7 @@ func TestLRUCache_HitMiss(t *testing.T) {
 
 	for i, x := range cases {
 		finalizerOk := false
-		c.Delete(0, x.key, func() {
+		ns.Delete(x.key, func(exist, pending bool) {
 			finalizerOk = true
 		})
 
@@ -347,7 +96,7 @@ func TestLRUCache_HitMiss(t *testing.T) {
 		}
 
 		for j, y := range cases {
-			h := c.Get(0, y.key, nil)
+			h := ns.Get(y.key, nil)
 			if j > i {
 				// should hit
 				if h == nil {
@@ -375,19 +124,20 @@ func TestLRUCache_HitMiss(t *testing.T) {
 }
 
 func TestLRUCache_Eviction(t *testing.T) {
-	c := NewCache(NewLRU(12))
-	o1 := set(c, 0, 1, 1, 1, nil)
-	set(c, 0, 2, 2, 1, nil).Release()
-	set(c, 0, 3, 3, 1, nil).Release()
-	set(c, 0, 4, 4, 1, nil).Release()
-	set(c, 0, 5, 5, 1, nil).Release()
-	if h := c.Get(0, 2, nil); h != nil { // 1,3,4,5,2
+	c := NewLRUCache(12)
+	ns := c.GetNamespace(0)
+	o1 := set(ns, 1, 1, 1, nil)
+	set(ns, 2, 2, 1, nil).Release()
+	set(ns, 3, 3, 1, nil).Release()
+	set(ns, 4, 4, 1, nil).Release()
+	set(ns, 5, 5, 1, nil).Release()
+	if h := ns.Get(2, nil); h != nil { // 1,3,4,5,2
 		h.Release()
 	}
-	set(c, 0, 9, 9, 10, nil).Release() // 5,2,9
+	set(ns, 9, 9, 10, nil).Release() // 5,2,9
 
 	for _, key := range []uint64{9, 2, 5, 1} {
-		h := c.Get(0, key, nil)
+		h := ns.Get(key, nil)
 		if h == nil {
 			t.Errorf("miss for key '%d'", key)
 		} else {
@@ -399,7 +149,7 @@ func TestLRUCache_Eviction(t *testing.T) {
 	}
 	o1.Release()
 	for _, key := range []uint64{1, 2, 5} {
-		h := c.Get(0, key, nil)
+		h := ns.Get(key, nil)
 		if h == nil {
 			t.Errorf("miss for key '%d'", key)
 		} else {
@@ -410,7 +160,7 @@ func TestLRUCache_Eviction(t *testing.T) {
 		}
 	}
 	for _, key := range []uint64{3, 4, 9} {
-		h := c.Get(0, key, nil)
+		h := ns.Get(key, nil)
 		if h != nil {
 			t.Errorf("hit for key '%d'", key)
 			if x := h.Value().(int); x != int(key) {
@@ -421,150 +171,377 @@ func TestLRUCache_Eviction(t *testing.T) {
 	}
 }
 
-func TestLRUCache_Evict(t *testing.T) {
-	c := NewCache(NewLRU(6))
-	set(c, 0, 1, 1, 1, nil).Release()
-	set(c, 0, 2, 2, 1, nil).Release()
-	set(c, 1, 1, 4, 1, nil).Release()
-	set(c, 1, 2, 5, 1, nil).Release()
-	set(c, 2, 1, 6, 1, nil).Release()
-	set(c, 2, 2, 7, 1, nil).Release()
-
-	for ns := 0; ns < 3; ns++ {
-		for key := 1; key < 3; key++ {
-			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
-				h.Release()
+func TestLRUCache_SetGet(t *testing.T) {
+	c := NewLRUCache(13)
+	ns := c.GetNamespace(0)
+	for i := 0; i < 200; i++ {
+		n := uint64(rand.Intn(99999) % 20)
+		set(ns, n, n, 1, nil).Release()
+		if h := ns.Get(n, nil); h != nil {
+			if h.Value() == nil {
+				t.Errorf("key '%d' contains nil value", n)
 			} else {
-				t.Errorf("Cache.Get on #%d.%d return nil", ns, key)
+				if x := h.Value().(uint64); x != n {
+					t.Errorf("invalid value for key '%d' want '%d', got '%d'", n, n, x)
+				}
 			}
-		}
-	}
-
-	if ok := c.Evict(0, 1); !ok {
-		t.Error("first Cache.Evict on #0.1 return false")
-	}
-	if ok := c.Evict(0, 1); ok {
-		t.Error("second Cache.Evict on #0.1 return true")
-	}
-	if h := c.Get(0, 1, nil); h != nil {
-		t.Errorf("Cache.Get on #0.1 return non-nil: %v", h.Value())
-	}
-
-	c.EvictNS(1)
-	if h := c.Get(1, 1, nil); h != nil {
-		t.Errorf("Cache.Get on #1.1 return non-nil: %v", h.Value())
-	}
-	if h := c.Get(1, 2, nil); h != nil {
-		t.Errorf("Cache.Get on #1.2 return non-nil: %v", h.Value())
-	}
-
-	c.EvictAll()
-	for ns := 0; ns < 3; ns++ {
-		for key := 1; key < 3; key++ {
-			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
-				t.Errorf("Cache.Get on #%d.%d return non-nil: %v", ns, key, h.Value())
-			}
-		}
-	}
-}
-
-func TestLRUCache_Delete(t *testing.T) {
-	delFuncCalled := 0
-	delFunc := func() {
-		delFuncCalled++
-	}
-
-	c := NewCache(NewLRU(2))
-	set(c, 0, 1, 1, 1, nil).Release()
-	set(c, 0, 2, 2, 1, nil).Release()
-
-	if ok := c.Delete(0, 1, delFunc); !ok {
-		t.Error("Cache.Delete on #1 return false")
-	}
-	if h := c.Get(0, 1, nil); h != nil {
-		t.Errorf("Cache.Get on #1 return non-nil: %v", h.Value())
-	}
-	if ok := c.Delete(0, 1, delFunc); ok {
-		t.Error("Cache.Delete on #1 return true")
-	}
-
-	h2 := c.Get(0, 2, nil)
-	if h2 == nil {
-		t.Error("Cache.Get on #2 return nil")
-	}
-	if ok := c.Delete(0, 2, delFunc); !ok {
-		t.Error("(1) Cache.Delete on #2 return false")
-	}
-	if ok := c.Delete(0, 2, delFunc); !ok {
-		t.Error("(2) Cache.Delete on #2 return false")
-	}
-
-	set(c, 0, 3, 3, 1, nil).Release()
-	set(c, 0, 4, 4, 1, nil).Release()
-	c.Get(0, 2, nil).Release()
-
-	for key := 2; key <= 4; key++ {
-		if h := c.Get(0, uint64(key), nil); h != nil {
 			h.Release()
 		} else {
-			t.Errorf("Cache.Get on #%d return nil", key)
+			t.Errorf("key '%d' doesn't exist", n)
+		}
+	}
+}
+
+func TestLRUCache_Purge(t *testing.T) {
+	c := NewLRUCache(3)
+	ns1 := c.GetNamespace(0)
+	o1 := set(ns1, 1, 1, 1, nil)
+	o2 := set(ns1, 2, 2, 1, nil)
+	ns1.Purge(nil)
+	set(ns1, 3, 3, 1, nil).Release()
+	for _, key := range []uint64{1, 2, 3} {
+		h := ns1.Get(key, nil)
+		if h == nil {
+			t.Errorf("miss for key '%d'", key)
+		} else {
+			if x := h.Value().(int); x != int(key) {
+				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
+			}
+			h.Release()
+		}
+	}
+	o1.Release()
+	o2.Release()
+	for _, key := range []uint64{1, 2} {
+		h := ns1.Get(key, nil)
+		if h != nil {
+			t.Errorf("hit for key '%d'", key)
+			if x := h.Value().(int); x != int(key) {
+				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
+			}
+			h.Release()
+		}
+	}
+}
+
+type testingCacheObjectCounter struct {
+	created  uint32
+	released uint32
+}
+
+func (c *testingCacheObjectCounter) createOne() {
+	atomic.AddUint32(&c.created, 1)
+}
+
+func (c *testingCacheObjectCounter) releaseOne() {
+	atomic.AddUint32(&c.released, 1)
+}
+
+type testingCacheObject struct {
+	t   *testing.T
+	cnt *testingCacheObjectCounter
+
+	ns, key uint64
+
+	releaseCalled uint32
+}
+
+func (x *testingCacheObject) Release() {
+	if atomic.CompareAndSwapUint32(&x.releaseCalled, 0, 1) {
+		x.cnt.releaseOne()
+	} else {
+		x.t.Errorf("duplicate setfin NS#%d KEY#%s", x.ns, x.key)
+	}
+}
+
+func TestLRUCache_Finalizer(t *testing.T) {
+	const (
+		capacity   = 100
+		goroutines = 100
+		iterations = 10000
+		keymax     = 8000
+	)
+
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	defer runtime.GOMAXPROCS(1)
+
+	wg := &sync.WaitGroup{}
+	cnt := &testingCacheObjectCounter{}
+
+	c := NewLRUCache(capacity)
+
+	type instance struct {
+		seed       int64
+		rnd        *rand.Rand
+		ns         uint64
+		effective  int32
+		handles    []Handle
+		handlesMap map[uint64]int
+
+		delete          bool
+		purge           bool
+		zap             bool
+		wantDel         int32
+		delfinCalledAll int32
+		delfinCalledEff int32
+		purgefinCalled  int32
+	}
+
+	instanceGet := func(p *instance, ns Namespace, key uint64) {
+		h := ns.Get(key, func() (charge int, value interface{}) {
+			to := &testingCacheObject{
+				t: t, cnt: cnt,
+				ns:  p.ns,
+				key: key,
+			}
+			atomic.AddInt32(&p.effective, 1)
+			cnt.createOne()
+			return 1, releaserFunc{func() {
+				to.Release()
+				atomic.AddInt32(&p.effective, -1)
+			}, to}
+		})
+		p.handles = append(p.handles, h)
+		p.handlesMap[key] = p.handlesMap[key] + 1
+	}
+	instanceRelease := func(p *instance, ns Namespace, i int) {
+		h := p.handles[i]
+		key := h.Value().(releaserFunc).value.(*testingCacheObject).key
+		if n := p.handlesMap[key]; n == 0 {
+			t.Fatal("key ref == 0")
+		} else if n > 1 {
+			p.handlesMap[key] = n - 1
+		} else {
+			delete(p.handlesMap, key)
+		}
+		h.Release()
+		p.handles = append(p.handles[:i], p.handles[i+1:]...)
+		p.handles[len(p.handles) : len(p.handles)+1][0] = nil
+	}
+
+	seeds := make([]int64, goroutines)
+	instances := make([]instance, goroutines)
+	for i := range instances {
+		p := &instances[i]
+		p.handlesMap = make(map[uint64]int)
+		if seeds[i] == 0 {
+			seeds[i] = time.Now().UnixNano()
+		}
+		p.seed = seeds[i]
+		p.rnd = rand.New(rand.NewSource(p.seed))
+		p.ns = uint64(i)
+		p.delete = i%6 == 0
+		p.purge = i%8 == 0
+		p.zap = i%12 == 0 || i%3 == 0
+	}
+
+	seedsStr := make([]string, len(seeds))
+	for i, seed := range seeds {
+		seedsStr[i] = fmt.Sprint(seed)
+	}
+	t.Logf("seeds := []int64{%s}", strings.Join(seedsStr, ", "))
+
+	// Get and release.
+	for i := range instances {
+		p := &instances[i]
+
+		wg.Add(1)
+		go func(p *instance) {
+			defer wg.Done()
+
+			ns := c.GetNamespace(p.ns)
+			for i := 0; i < iterations; i++ {
+				if len(p.handles) == 0 || p.rnd.Int()%2 == 0 {
+					instanceGet(p, ns, uint64(p.rnd.Intn(keymax)))
+				} else {
+					instanceRelease(p, ns, p.rnd.Intn(len(p.handles)))
+				}
+			}
+		}(p)
+	}
+	wg.Wait()
+
+	if used, cap := c.Used(), c.Capacity(); used > cap {
+		t.Errorf("Used > capacity, used=%d cap=%d", used, cap)
+	}
+
+	// Check effective objects.
+	for i := range instances {
+		p := &instances[i]
+		if int(p.effective) < len(p.handlesMap) {
+			t.Errorf("#%d effective objects < acquired handle, eo=%d ah=%d", i, p.effective, len(p.handlesMap))
 		}
 	}
 
-	h2.Release()
-	if h := c.Get(0, 2, nil); h != nil {
-		t.Errorf("Cache.Get on #2 return non-nil: %v", h.Value())
+	if want := int(cnt.created - cnt.released); c.Size() != want {
+		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
 	}
 
-	if delFuncCalled != 4 {
-		t.Errorf("delFunc isn't called 4 times: got=%d", delFuncCalled)
-	}
-}
+	// Delete and purge.
+	for i := range instances {
+		p := &instances[i]
+		p.wantDel = p.effective
 
-func TestLRUCache_Close(t *testing.T) {
-	relFuncCalled := 0
-	relFunc := func() {
-		relFuncCalled++
+		wg.Add(1)
+		go func(p *instance) {
+			defer wg.Done()
+
+			ns := c.GetNamespace(p.ns)
+
+			if p.delete {
+				for key := uint64(0); key < keymax; key++ {
+					_, wantExist := p.handlesMap[key]
+					gotExist := ns.Delete(key, func(exist, pending bool) {
+						atomic.AddInt32(&p.delfinCalledAll, 1)
+						if exist {
+							atomic.AddInt32(&p.delfinCalledEff, 1)
+						}
+					})
+					if !gotExist && wantExist {
+						t.Errorf("delete on NS#%d KEY#%d not found", p.ns, key)
+					}
+				}
+
+				var delfinCalled int
+				for key := uint64(0); key < keymax; key++ {
+					func(key uint64) {
+						gotExist := ns.Delete(key, func(exist, pending bool) {
+							if exist && !pending {
+								t.Errorf("delete fin on NS#%d KEY#%d exist and not pending for deletion", p.ns, key)
+							}
+							delfinCalled++
+						})
+						if gotExist {
+							t.Errorf("delete on NS#%d KEY#%d found", p.ns, key)
+						}
+					}(key)
+				}
+				if delfinCalled != keymax {
+					t.Errorf("(2) #%d not all delete fin called, diff=%d", p.ns, keymax-delfinCalled)
+				}
+			}
+
+			if p.purge {
+				ns.Purge(func(ns, key uint64) {
+					atomic.AddInt32(&p.purgefinCalled, 1)
+				})
+			}
+		}(p)
 	}
-	delFuncCalled := 0
-	delFunc := func() {
-		delFuncCalled++
+	wg.Wait()
+
+	if want := int(cnt.created - cnt.released); c.Size() != want {
+		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
 	}
 
-	c := NewCache(NewLRU(2))
-	set(c, 0, 1, 1, 1, relFunc).Release()
-	set(c, 0, 2, 2, 1, relFunc).Release()
+	// Release.
+	for i := range instances {
+		p := &instances[i]
 
-	h3 := set(c, 0, 3, 3, 1, relFunc)
-	if h3 == nil {
-		t.Error("Cache.Get on #3 return nil")
-	}
-	if ok := c.Delete(0, 3, delFunc); !ok {
-		t.Error("Cache.Delete on #3 return false")
-	}
+		if !p.zap {
+			wg.Add(1)
+			go func(p *instance) {
+				defer wg.Done()
 
-	c.Close()
-
-	if relFuncCalled != 3 {
-		t.Errorf("relFunc isn't called 3 times: got=%d", relFuncCalled)
-	}
-	if delFuncCalled != 1 {
-		t.Errorf("delFunc isn't called 1 times: got=%d", delFuncCalled)
-	}
-}
-
-func BenchmarkLRUCache(b *testing.B) {
-	c := NewCache(NewLRU(10000))
-
-	b.SetParallelism(10)
-	b.RunParallel(func(pb *testing.PB) {
-		r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-		for pb.Next() {
-			key := uint64(r.Intn(1000000))
-			c.Get(0, key, func() (int, Value) {
-				return 1, key
-			}).Release()
+				ns := c.GetNamespace(p.ns)
+				for i := len(p.handles) - 1; i >= 0; i-- {
+					instanceRelease(p, ns, i)
+				}
+			}(p)
 		}
-	})
+	}
+	wg.Wait()
+
+	if want := int(cnt.created - cnt.released); c.Size() != want {
+		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
+	}
+
+	// Zap.
+	for i := range instances {
+		p := &instances[i]
+
+		if p.zap {
+			wg.Add(1)
+			go func(p *instance) {
+				defer wg.Done()
+
+				ns := c.GetNamespace(p.ns)
+				ns.Zap()
+
+				p.handles = nil
+				p.handlesMap = nil
+			}(p)
+		}
+	}
+	wg.Wait()
+
+	if want := int(cnt.created - cnt.released); c.Size() != want {
+		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
+	}
+
+	if notrel, used := int(cnt.created-cnt.released), c.Used(); notrel != used {
+		t.Errorf("Invalid used value, want=%d got=%d", notrel, used)
+	}
+
+	c.Purge(nil)
+
+	for i := range instances {
+		p := &instances[i]
+
+		if p.delete {
+			if p.delfinCalledAll != keymax {
+				t.Errorf("#%d not all delete fin called, purge=%v zap=%v diff=%d", p.ns, p.purge, p.zap, keymax-p.delfinCalledAll)
+			}
+			if p.delfinCalledEff != p.wantDel {
+				t.Errorf("#%d not all effective delete fin called, diff=%d", p.ns, p.wantDel-p.delfinCalledEff)
+			}
+			if p.purge && p.purgefinCalled > 0 {
+				t.Errorf("#%d some purge fin called, delete=%v zap=%v n=%d", p.ns, p.delete, p.zap, p.purgefinCalled)
+			}
+		} else {
+			if p.purge {
+				if p.purgefinCalled != p.wantDel {
+					t.Errorf("#%d not all purge fin called, delete=%v zap=%v diff=%d", p.ns, p.delete, p.zap, p.wantDel-p.purgefinCalled)
+				}
+			}
+		}
+	}
+
+	if cnt.created != cnt.released {
+		t.Errorf("Some cache object weren't released, created=%d released=%d", cnt.created, cnt.released)
+	}
+}
+
+func BenchmarkLRUCache_SetRelease(b *testing.B) {
+	capacity := b.N / 100
+	if capacity <= 0 {
+		capacity = 10
+	}
+	c := NewLRUCache(capacity)
+	ns := c.GetNamespace(0)
+	b.ResetTimer()
+	for i := uint64(0); i < uint64(b.N); i++ {
+		set(ns, i, nil, 1, nil).Release()
+	}
+}
+
+func BenchmarkLRUCache_SetReleaseTwice(b *testing.B) {
+	capacity := b.N / 100
+	if capacity <= 0 {
+		capacity = 10
+	}
+	c := NewLRUCache(capacity)
+	ns := c.GetNamespace(0)
+	b.ResetTimer()
+
+	na := b.N / 2
+	nb := b.N - na
+
+	for i := uint64(0); i < uint64(na); i++ {
+		set(ns, i, nil, 1, nil).Release()
+	}
+
+	for i := uint64(0); i < uint64(nb); i++ {
+		set(ns, i, nil, 1, nil).Release()
+	}
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru.go

@@ -1,195 +0,0 @@
-// Copyright (c) 2012, 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 cache
-
-import (
-	"sync"
-	"unsafe"
-)
-
-type lruNode struct {
-	n   *Node
-	h   *Handle
-	ban bool
-
-	next, prev *lruNode
-}
-
-func (n *lruNode) insert(at *lruNode) {
-	x := at.next
-	at.next = n
-	n.prev = at
-	n.next = x
-	x.prev = n
-}
-
-func (n *lruNode) remove() {
-	if n.prev != nil {
-		n.prev.next = n.next
-		n.next.prev = n.prev
-		n.prev = nil
-		n.next = nil
-	} else {
-		panic("BUG: removing removed node")
-	}
-}
-
-type lru struct {
-	mu       sync.Mutex
-	capacity int
-	used     int
-	recent   lruNode
-}
-
-func (r *lru) reset() {
-	r.recent.next = &r.recent
-	r.recent.prev = &r.recent
-	r.used = 0
-}
-
-func (r *lru) Capacity() int {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	return r.capacity
-}
-
-func (r *lru) SetCapacity(capacity int) {
-	var evicted []*lruNode
-
-	r.mu.Lock()
-	r.capacity = capacity
-	for r.used > r.capacity {
-		rn := r.recent.prev
-		if rn == nil {
-			panic("BUG: invalid LRU used or capacity counter")
-		}
-		rn.remove()
-		rn.n.CacheData = nil
-		r.used -= rn.n.Size()
-		evicted = append(evicted, rn)
-	}
-	r.mu.Unlock()
-
-	for _, rn := range evicted {
-		rn.h.Release()
-	}
-}
-
-func (r *lru) Promote(n *Node) {
-	var evicted []*lruNode
-
-	r.mu.Lock()
-	if n.CacheData == nil {
-		if n.Size() <= r.capacity {
-			rn := &lruNode{n: n, h: n.GetHandle()}
-			rn.insert(&r.recent)
-			n.CacheData = unsafe.Pointer(rn)
-			r.used += n.Size()
-
-			for r.used > r.capacity {
-				rn := r.recent.prev
-				if rn == nil {
-					panic("BUG: invalid LRU used or capacity counter")
-				}
-				rn.remove()
-				rn.n.CacheData = nil
-				r.used -= rn.n.Size()
-				evicted = append(evicted, rn)
-			}
-		}
-	} else {
-		rn := (*lruNode)(n.CacheData)
-		if !rn.ban {
-			rn.remove()
-			rn.insert(&r.recent)
-		}
-	}
-	r.mu.Unlock()
-
-	for _, rn := range evicted {
-		rn.h.Release()
-	}
-}
-
-func (r *lru) Ban(n *Node) {
-	r.mu.Lock()
-	if n.CacheData == nil {
-		n.CacheData = unsafe.Pointer(&lruNode{n: n, ban: true})
-	} else {
-		rn := (*lruNode)(n.CacheData)
-		if !rn.ban {
-			rn.remove()
-			rn.ban = true
-			r.used -= rn.n.Size()
-			r.mu.Unlock()
-
-			rn.h.Release()
-			rn.h = nil
-			return
-		}
-	}
-	r.mu.Unlock()
-}
-
-func (r *lru) Evict(n *Node) {
-	r.mu.Lock()
-	rn := (*lruNode)(n.CacheData)
-	if rn == nil || rn.ban {
-		r.mu.Unlock()
-		return
-	}
-	n.CacheData = nil
-	r.mu.Unlock()
-
-	rn.h.Release()
-}
-
-func (r *lru) EvictNS(ns uint64) {
-	var evicted []*lruNode
-
-	r.mu.Lock()
-	for e := r.recent.prev; e != &r.recent; {
-		rn := e
-		e = e.prev
-		if rn.n.NS() == ns {
-			rn.remove()
-			rn.n.CacheData = nil
-			r.used -= rn.n.Size()
-			evicted = append(evicted, rn)
-		}
-	}
-	r.mu.Unlock()
-
-	for _, rn := range evicted {
-		rn.h.Release()
-	}
-}
-
-func (r *lru) EvictAll() {
-	r.mu.Lock()
-	back := r.recent.prev
-	for rn := back; rn != &r.recent; rn = rn.prev {
-		rn.n.CacheData = nil
-	}
-	r.reset()
-	r.mu.Unlock()
-
-	for rn := back; rn != &r.recent; rn = rn.prev {
-		rn.h.Release()
-	}
-}
-
-func (r *lru) Close() error {
-	return nil
-}
-
-// NewLRU create a new LRU-cache.
-func NewLRU(capacity int) Cacher {
-	r := &lru{capacity: capacity}
-	r.reset()
-	return r
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru_cache.go

@@ -0,0 +1,382 @@
+// Copyright (c) 2012, 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 cache
+
+import (
+	"sync"
+	"sync/atomic"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// lruCache represent a LRU cache state.
+type lruCache struct {
+	mu                sync.Mutex
+	recent            lruNode
+	table             map[uint64]*lruNs
+	capacity          int
+	used, size, alive int
+}
+
+// NewLRUCache creates a new initialized LRU cache with the given capacity.
+func NewLRUCache(capacity int) Cache {
+	c := &lruCache{
+		table:    make(map[uint64]*lruNs),
+		capacity: capacity,
+	}
+	c.recent.rNext = &c.recent
+	c.recent.rPrev = &c.recent
+	return c
+}
+
+func (c *lruCache) Capacity() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.capacity
+}
+
+func (c *lruCache) Used() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.used
+}
+
+func (c *lruCache) Size() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.size
+}
+
+func (c *lruCache) NumObjects() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.alive
+}
+
+// SetCapacity set cache capacity.
+func (c *lruCache) SetCapacity(capacity int) {
+	c.mu.Lock()
+	c.capacity = capacity
+	c.evict()
+	c.mu.Unlock()
+}
+
+// GetNamespace return namespace object for given id.
+func (c *lruCache) GetNamespace(id uint64) Namespace {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if ns, ok := c.table[id]; ok {
+		return ns
+	}
+
+	ns := &lruNs{
+		lru:   c,
+		id:    id,
+		table: make(map[uint64]*lruNode),
+	}
+	c.table[id] = ns
+	return ns
+}
+
+func (c *lruCache) ZapNamespace(id uint64) {
+	c.mu.Lock()
+	if ns, exist := c.table[id]; exist {
+		ns.zapNB()
+		delete(c.table, id)
+	}
+	c.mu.Unlock()
+}
+
+func (c *lruCache) PurgeNamespace(id uint64, fin PurgeFin) {
+	c.mu.Lock()
+	if ns, exist := c.table[id]; exist {
+		ns.purgeNB(fin)
+	}
+	c.mu.Unlock()
+}
+
+// Purge purge entire cache.
+func (c *lruCache) Purge(fin PurgeFin) {
+	c.mu.Lock()
+	for _, ns := range c.table {
+		ns.purgeNB(fin)
+	}
+	c.mu.Unlock()
+}
+
+func (c *lruCache) Zap() {
+	c.mu.Lock()
+	for _, ns := range c.table {
+		ns.zapNB()
+	}
+	c.table = make(map[uint64]*lruNs)
+	c.mu.Unlock()
+}
+
+func (c *lruCache) evict() {
+	top := &c.recent
+	for n := c.recent.rPrev; c.used > c.capacity && n != top; {
+		n.state = nodeEvicted
+		n.rRemove()
+		n.derefNB()
+		c.used -= n.charge
+		n = c.recent.rPrev
+	}
+}
+
+type lruNs struct {
+	lru   *lruCache
+	id    uint64
+	table map[uint64]*lruNode
+	state nsState
+}
+
+func (ns *lruNs) Get(key uint64, setf SetFunc) Handle {
+	ns.lru.mu.Lock()
+
+	if ns.state != nsEffective {
+		ns.lru.mu.Unlock()
+		return nil
+	}
+
+	node, ok := ns.table[key]
+	if ok {
+		switch node.state {
+		case nodeEvicted:
+			// Insert to recent list.
+			node.state = nodeEffective
+			node.ref++
+			ns.lru.used += node.charge
+			ns.lru.evict()
+			fallthrough
+		case nodeEffective:
+			// Bump to front.
+			node.rRemove()
+			node.rInsert(&ns.lru.recent)
+		}
+		node.ref++
+	} else {
+		if setf == nil {
+			ns.lru.mu.Unlock()
+			return nil
+		}
+
+		charge, value := setf()
+		if value == nil {
+			ns.lru.mu.Unlock()
+			return nil
+		}
+
+		node = &lruNode{
+			ns:     ns,
+			key:    key,
+			value:  value,
+			charge: charge,
+			ref:    1,
+		}
+		ns.table[key] = node
+
+		ns.lru.size += charge
+		ns.lru.alive++
+		if charge > 0 {
+			node.ref++
+			node.rInsert(&ns.lru.recent)
+			ns.lru.used += charge
+			ns.lru.evict()
+		}
+	}
+
+	ns.lru.mu.Unlock()
+	return &lruHandle{node: node}
+}
+
+func (ns *lruNs) Delete(key uint64, fin DelFin) bool {
+	ns.lru.mu.Lock()
+
+	if ns.state != nsEffective {
+		if fin != nil {
+			fin(false, false)
+		}
+		ns.lru.mu.Unlock()
+		return false
+	}
+
+	node, exist := ns.table[key]
+	if !exist {
+		if fin != nil {
+			fin(false, false)
+		}
+		ns.lru.mu.Unlock()
+		return false
+	}
+
+	switch node.state {
+	case nodeDeleted:
+		if fin != nil {
+			fin(true, true)
+		}
+		ns.lru.mu.Unlock()
+		return false
+	case nodeEffective:
+		ns.lru.used -= node.charge
+		node.state = nodeDeleted
+		node.delfin = fin
+		node.rRemove()
+		node.derefNB()
+	default:
+		node.state = nodeDeleted
+		node.delfin = fin
+	}
+
+	ns.lru.mu.Unlock()
+	return true
+}
+
+func (ns *lruNs) purgeNB(fin PurgeFin) {
+	if ns.state != nsEffective {
+		return
+	}
+
+	for _, node := range ns.table {
+		switch node.state {
+		case nodeDeleted:
+		case nodeEffective:
+			ns.lru.used -= node.charge
+			node.state = nodeDeleted
+			node.purgefin = fin
+			node.rRemove()
+			node.derefNB()
+		default:
+			node.state = nodeDeleted
+			node.purgefin = fin
+		}
+	}
+}
+
+func (ns *lruNs) Purge(fin PurgeFin) {
+	ns.lru.mu.Lock()
+	ns.purgeNB(fin)
+	ns.lru.mu.Unlock()
+}
+
+func (ns *lruNs) zapNB() {
+	if ns.state != nsEffective {
+		return
+	}
+
+	ns.state = nsZapped
+
+	for _, node := range ns.table {
+		if node.state == nodeEffective {
+			ns.lru.used -= node.charge
+			node.rRemove()
+		}
+		ns.lru.size -= node.charge
+		node.state = nodeDeleted
+		node.fin()
+	}
+	ns.table = nil
+}
+
+func (ns *lruNs) Zap() {
+	ns.lru.mu.Lock()
+	ns.zapNB()
+	delete(ns.lru.table, ns.id)
+	ns.lru.mu.Unlock()
+}
+
+type lruNode struct {
+	ns *lruNs
+
+	rNext, rPrev *lruNode
+
+	key      uint64
+	value    interface{}
+	charge   int
+	ref      int
+	state    nodeState
+	delfin   DelFin
+	purgefin PurgeFin
+}
+
+func (n *lruNode) rInsert(at *lruNode) {
+	x := at.rNext
+	at.rNext = n
+	n.rPrev = at
+	n.rNext = x
+	x.rPrev = n
+}
+
+func (n *lruNode) rRemove() bool {
+	if n.rPrev == nil {
+		return false
+	}
+
+	n.rPrev.rNext = n.rNext
+	n.rNext.rPrev = n.rPrev
+	n.rPrev = nil
+	n.rNext = nil
+
+	return true
+}
+
+func (n *lruNode) fin() {
+	if r, ok := n.value.(util.Releaser); ok {
+		r.Release()
+	}
+	if n.purgefin != nil {
+		n.purgefin(n.ns.id, n.key)
+		n.delfin = nil
+		n.purgefin = nil
+	} else if n.delfin != nil {
+		n.delfin(true, false)
+		n.delfin = nil
+	}
+}
+
+func (n *lruNode) derefNB() {
+	n.ref--
+	if n.ref == 0 {
+		if n.ns.state == nsEffective {
+			// Remove elemement.
+			delete(n.ns.table, n.key)
+			n.ns.lru.size -= n.charge
+			n.ns.lru.alive--
+			n.fin()
+		}
+		n.value = nil
+	} else if n.ref < 0 {
+		panic("leveldb/cache: lruCache: negative node reference")
+	}
+}
+
+func (n *lruNode) deref() {
+	n.ns.lru.mu.Lock()
+	n.derefNB()
+	n.ns.lru.mu.Unlock()
+}
+
+type lruHandle struct {
+	node *lruNode
+	once uint32
+}
+
+func (h *lruHandle) Value() interface{} {
+	if atomic.LoadUint32(&h.once) == 0 {
+		return h.node.value
+	}
+	return nil
+}
+
+func (h *lruHandle) Release() {
+	if !atomic.CompareAndSwapUint32(&h.once, 0, 1) {
+		return
+	}
+	h.node.deref()
+	h.node = nil
+}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/config.go

@@ -0,0 +1,40 @@
+// Copyright (c) 2012, 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 leveldb
+
+const (
+	kNumLevels = 7
+
+	// Level-0 compaction is started when we hit this many files.
+	kL0_CompactionTrigger float64 = 4
+
+	// Soft limit on number of level-0 files.  We slow down writes at this point.
+	kL0_SlowdownWritesTrigger = 8
+
+	// Maximum number of level-0 files.  We stop writes at this point.
+	kL0_StopWritesTrigger = 12
+
+	// Maximum level to which a new compacted memdb is pushed if it
+	// does not create overlap.  We try to push to level 2 to avoid the
+	// relatively expensive level 0=>1 compactions and to avoid some
+	// expensive manifest file operations.  We do not push all the way to
+	// the largest level since that can generate a lot of wasted disk
+	// space if the same key space is being repeatedly overwritten.
+	kMaxMemCompactLevel = 2
+
+	// Maximum size of a table.
+	kMaxTableSize = 2 * 1048576
+
+	// Maximum bytes of overlaps in grandparent (i.e., level+2) before we
+	// stop building a single file in a level->level+1 compaction.
+	kMaxGrandParentOverlapBytes = 10 * kMaxTableSize
+
+	// Maximum number of bytes in all compacted files.  We avoid expanding
+	// the lower level file set of a compaction if it would make the
+	// total compaction cover more than this many bytes.
+	kExpCompactionMaxBytes = 25 * kMaxTableSize
+)

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go

@@ -9,12 +9,13 @@ package leveldb
 import (
 	"bytes"
 	"fmt"
-	"github.com/syndtr/goleveldb/leveldb/filter"
-	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/storage"
 	"io"
 	"math/rand"
 	"testing"
+
+	"github.com/syndtr/goleveldb/leveldb/cache"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
 const ctValSize = 1000
@@ -31,8 +32,8 @@ func newDbCorruptHarnessWopt(t *testing.T, o *opt.Options) *dbCorruptHarness {
 
 func newDbCorruptHarness(t *testing.T) *dbCorruptHarness {
 	return newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCacheCapacity: 100,
-		Strict:             opt.StrictJournalChecksum,
+		BlockCache: cache.NewLRUCache(100),
+		Strict:     opt.StrictJournalChecksum,
 	})
 }
 
@@ -95,22 +96,21 @@ func (h *dbCorruptHarness) deleteRand(n, max int, rnd *rand.Rand) {
 	}
 }
 
-func (h *dbCorruptHarness) corrupt(ft storage.FileType, fi, offset, n int) {
+func (h *dbCorruptHarness) corrupt(ft storage.FileType, offset, n int) {
 	p := &h.dbHarness
 	t := p.t
 
+	var file storage.File
 	ff, _ := p.stor.GetFiles(ft)
-	sff := files(ff)
-	sff.sort()
-	if fi < 0 {
-		fi = len(sff) - 1
+	for _, f := range ff {
+		if file == nil || f.Num() > file.Num() {
+			file = f
+		}
 	}
-	if fi >= len(sff) {
-		t.Fatalf("no such file with type %q with index %d", ft, fi)
+	if file == nil {
+		t.Fatalf("no such file with type %q", ft)
 	}
 
-	file := sff[fi]
-
 	r, err := file.Open()
 	if err != nil {
 		t.Fatal("cannot open file: ", err)
@@ -225,8 +225,8 @@ func TestCorruptDB_Journal(t *testing.T) {
 	h.build(100)
 	h.check(100, 100)
 	h.closeDB()
-	h.corrupt(storage.TypeJournal, -1, 19, 1)
-	h.corrupt(storage.TypeJournal, -1, 32*1024+1000, 1)
+	h.corrupt(storage.TypeJournal, 19, 1)
+	h.corrupt(storage.TypeJournal, 32*1024+1000, 1)
 
 	h.openDB()
 	h.check(36, 36)
@@ -242,7 +242,7 @@ func TestCorruptDB_Table(t *testing.T) {
 	h.compactRangeAt(0, "", "")
 	h.compactRangeAt(1, "", "")
 	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, 100, 1)
+	h.corrupt(storage.TypeTable, 100, 1)
 
 	h.openDB()
 	h.check(99, 99)
@@ -256,7 +256,7 @@ func TestCorruptDB_TableIndex(t *testing.T) {
 	h.build(10000)
 	h.compactMem()
 	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, -2000, 500)
+	h.corrupt(storage.TypeTable, -2000, 500)
 
 	h.openDB()
 	h.check(5000, 9999)
@@ -267,9 +267,9 @@ func TestCorruptDB_TableIndex(t *testing.T) {
 func TestCorruptDB_MissingManifest(t *testing.T) {
 	rnd := rand.New(rand.NewSource(0x0badda7a))
 	h := newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCacheCapacity: 100,
-		Strict:             opt.StrictJournalChecksum,
-		WriteBuffer:        1000 * 60,
+		BlockCache:  cache.NewLRUCache(100),
+		Strict:      opt.StrictJournalChecksum,
+		WriteBuffer: 1000 * 60,
 	})
 
 	h.build(1000)
@@ -355,7 +355,7 @@ func TestCorruptDB_CorruptedManifest(t *testing.T) {
 	h.compactMem()
 	h.compactRange("", "")
 	h.closeDB()
-	h.corrupt(storage.TypeManifest, -1, 0, 1000)
+	h.corrupt(storage.TypeManifest, 0, 1000)
 	h.openAssert(false)
 
 	h.recover()
@@ -370,7 +370,7 @@ func TestCorruptDB_CompactionInputError(t *testing.T) {
 	h.build(10)
 	h.compactMem()
 	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, 100, 1)
+	h.corrupt(storage.TypeTable, 100, 1)
 
 	h.openDB()
 	h.check(9, 9)
@@ -387,7 +387,7 @@ func TestCorruptDB_UnrelatedKeys(t *testing.T) {
 	h.build(10)
 	h.compactMem()
 	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, 100, 1)
+	h.corrupt(storage.TypeTable, 100, 1)
 
 	h.openDB()
 	h.put(string(tkey(1000)), string(tval(1000, ctValSize)))
@@ -470,31 +470,3 @@ func TestCorruptDB_MissingTableFiles(t *testing.T) {
 
 	h.close()
 }
-
-func TestCorruptDB_RecoverTable(t *testing.T) {
-	h := newDbCorruptHarnessWopt(t, &opt.Options{
-		WriteBuffer:         112 * opt.KiB,
-		CompactionTableSize: 90 * opt.KiB,
-		Filter:              filter.NewBloomFilter(10),
-	})
-
-	h.build(1000)
-	h.compactMem()
-	h.compactRangeAt(0, "", "")
-	h.compactRangeAt(1, "", "")
-	seq := h.db.seq
-	h.closeDB()
-	h.corrupt(storage.TypeTable, 0, 1000, 1)
-	h.corrupt(storage.TypeTable, 3, 10000, 1)
-	// Corrupted filter shouldn't affect recovery.
-	h.corrupt(storage.TypeTable, 3, 113888, 10)
-	h.corrupt(storage.TypeTable, -1, 20000, 1)
-
-	h.recover()
-	if h.db.seq != seq {
-		t.Errorf("invalid seq, want=%d got=%d", seq, h.db.seq)
-	}
-	h.check(985, 985)
-
-	h.close()
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db.go

@@ -7,7 +7,7 @@
 package leveldb
 
 import (
-	"container/list"
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -17,7 +17,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
 	"github.com/syndtr/goleveldb/leveldb/journal"
 	"github.com/syndtr/goleveldb/leveldb/memdb"
@@ -47,7 +46,7 @@ type DB struct {
 
 	// Snapshot.
 	snapsMu   sync.Mutex
-	snapsList *list.List
+	snapsRoot snapshotElement
 
 	// Stats.
 	aliveSnaps, aliveIters int32
@@ -57,19 +56,18 @@ type DB struct {
 	writeMergedC chan bool
 	writeLockC   chan struct{}
 	writeAckC    chan error
-	writeDelay   time.Duration
-	writeDelayN  int
 	journalC     chan *Batch
 	journalAckC  chan error
 
 	// Compaction.
-	tcompCmdC   chan cCmd
-	tcompPauseC chan chan<- struct{}
-	mcompCmdC   chan cCmd
-	compErrC    chan error
-	compPerErrC chan error
-	compErrSetC chan error
-	compStats   []cStats
+	tcompCmdC     chan cCmd
+	tcompPauseC   chan chan<- struct{}
+	tcompTriggerC chan struct{}
+	mcompCmdC     chan cCmd
+	mcompTriggerC chan struct{}
+	compErrC      chan error
+	compErrSetC   chan error
+	compStats     [kNumLevels]cStats
 
 	// Close.
 	closeW sync.WaitGroup
@@ -84,11 +82,9 @@ func openDB(s *session) (*DB, error) {
 	db := &DB{
 		s: s,
 		// Initial sequence
-		seq: s.stSeqNum,
+		seq: s.stSeq,
 		// MemDB
 		memPool: make(chan *memdb.DB, 1),
-		// Snapshot
-		snapsList: list.New(),
 		// Write
 		writeC:       make(chan *Batch),
 		writeMergedC: make(chan bool),
@@ -97,16 +93,17 @@ func openDB(s *session) (*DB, error) {
 		journalC:     make(chan *Batch),
 		journalAckC:  make(chan error),
 		// Compaction
-		tcompCmdC:   make(chan cCmd),
-		tcompPauseC: make(chan chan<- struct{}),
-		mcompCmdC:   make(chan cCmd),
-		compErrC:    make(chan error),
-		compPerErrC: make(chan error),
-		compErrSetC: make(chan error),
-		compStats:   make([]cStats, s.o.GetNumLevel()),
+		tcompCmdC:     make(chan cCmd),
+		tcompPauseC:   make(chan chan<- struct{}),
+		tcompTriggerC: make(chan struct{}, 1),
+		mcompCmdC:     make(chan cCmd),
+		mcompTriggerC: make(chan struct{}, 1),
+		compErrC:      make(chan error),
+		compErrSetC:   make(chan error),
 		// Close
 		closeC: make(chan struct{}),
 	}
+	db.initSnapshot()
 
 	if err := db.recoverJournal(); err != nil {
 		return nil, err
@@ -122,14 +119,14 @@ func openDB(s *session) (*DB, error) {
 		return nil, err
 	}
 
-	// Doesn't need to be included in the wait group.
+	// Don't include compaction error goroutine into wait group.
 	go db.compactionError()
-	go db.mpoolDrain()
 
 	db.closeW.Add(3)
 	go db.tCompaction()
 	go db.mCompaction()
 	go db.jWriter()
+	go db.mpoolDrain()
 
 	s.logf("db@open done T·%v", time.Since(start))
 
@@ -256,10 +253,6 @@ func RecoverFile(path string, o *opt.Options) (db *DB, err error) {
 }
 
 func recoverTable(s *session, o *opt.Options) error {
-	o = dupOptions(o)
-	// Mask StrictReader, lets StrictRecovery doing its job.
-	o.Strict &= ^opt.StrictReader
-
 	// Get all tables and sort it by file number.
 	tableFiles_, err := s.getFiles(storage.TypeTable)
 	if err != nil {
@@ -268,16 +261,10 @@ func recoverTable(s *session, o *opt.Options) error {
 	tableFiles := files(tableFiles_)
 	tableFiles.sort()
 
-	var (
-		maxSeq                                                            uint64
-		recoveredKey, goodKey, corruptedKey, corruptedBlock, droppedTable int
-
-		// We will drop corrupted table.
-		strict = o.GetStrict(opt.StrictRecovery)
-
-		rec   = &sessionRecord{numLevel: o.GetNumLevel()}
-		bpool = util.NewBufferPool(o.GetBlockSize() + 5)
-	)
+	var mSeq uint64
+	var good, corrupted int
+	rec := new(sessionRecord)
+	bpool := util.NewBufferPool(o.GetBlockSize() + 5)
 	buildTable := func(iter iterator.Iterator) (tmp storage.File, size int64, err error) {
 		tmp = s.newTemp()
 		writer, err := tmp.Create()
@@ -324,12 +311,7 @@ func recoverTable(s *session, o *opt.Options) error {
 		if err != nil {
 			return err
 		}
-		var closed bool
-		defer func() {
-			if !closed {
-				reader.Close()
-			}
-		}()
+		defer reader.Close()
 
 		// Get file size.
 		size, err := reader.Seek(0, 2)
@@ -337,32 +319,25 @@ func recoverTable(s *session, o *opt.Options) error {
 			return err
 		}
 
-		var (
-			tSeq                                     uint64
-			tgoodKey, tcorruptedKey, tcorruptedBlock int
-			imin, imax                               []byte
-		)
-		tr, err := table.NewReader(reader, size, storage.NewFileInfo(file), nil, bpool, o)
-		if err != nil {
-			return err
-		}
+		var tSeq uint64
+		var tgood, tcorrupted, blockerr int
+		var imin, imax []byte
+		tr := table.NewReader(reader, size, nil, bpool, o)
 		iter := tr.NewIterator(nil, nil)
 		iter.(iterator.ErrorCallbackSetter).SetErrorCallback(func(err error) {
-			if errors.IsCorrupted(err) {
-				s.logf("table@recovery block corruption @%d %q", file.Num(), err)
-				tcorruptedBlock++
-			}
+			s.logf("table@recovery found error @%d %q", file.Num(), err)
+			blockerr++
 		})
 
 		// Scan the table.
 		for iter.Next() {
 			key := iter.Key()
-			_, seq, _, kerr := parseIkey(key)
-			if kerr != nil {
-				tcorruptedKey++
+			_, seq, _, ok := parseIkey(key)
+			if !ok {
+				tcorrupted++
 				continue
 			}
-			tgoodKey++
+			tgood++
 			if seq > tSeq {
 				tSeq = seq
 			}
@@ -377,18 +352,8 @@ func recoverTable(s *session, o *opt.Options) error {
 		}
 		iter.Release()
 
-		goodKey += tgoodKey
-		corruptedKey += tcorruptedKey
-		corruptedBlock += tcorruptedBlock
-
-		if strict && (tcorruptedKey > 0 || tcorruptedBlock > 0) {
-			droppedTable++
-			s.logf("table@recovery dropped @%d Gk·%d Ck·%d Cb·%d S·%d Q·%d", file.Num(), tgoodKey, tcorruptedKey, tcorruptedBlock, size, tSeq)
-			return nil
-		}
-
-		if tgoodKey > 0 {
-			if tcorruptedKey > 0 || tcorruptedBlock > 0 {
+		if tgood > 0 {
+			if tcorrupted > 0 || blockerr > 0 {
 				// Rebuild the table.
 				s.logf("table@recovery rebuilding @%d", file.Num())
 				iter := tr.NewIterator(nil, nil)
@@ -397,25 +362,25 @@ func recoverTable(s *session, o *opt.Options) error {
 				if err != nil {
 					return err
 				}
-				closed = true
 				reader.Close()
 				if err := file.Replace(tmp); err != nil {
 					return err
 				}
 				size = newSize
 			}
-			if tSeq > maxSeq {
-				maxSeq = tSeq
+			if tSeq > mSeq {
+				mSeq = tSeq
 			}
-			recoveredKey += tgoodKey
 			// Add table to level 0.
 			rec.addTable(0, file.Num(), uint64(size), imin, imax)
-			s.logf("table@recovery recovered @%d Gk·%d Ck·%d Cb·%d S·%d Q·%d", file.Num(), tgoodKey, tcorruptedKey, tcorruptedBlock, size, tSeq)
+			s.logf("table@recovery recovered @%d N·%d C·%d B·%d S·%d Q·%d", file.Num(), tgood, tcorrupted, blockerr, size, tSeq)
 		} else {
-			droppedTable++
-			s.logf("table@recovery unrecoverable @%d Ck·%d Cb·%d S·%d", file.Num(), tcorruptedKey, tcorruptedBlock, size)
+			s.logf("table@recovery unrecoverable @%d C·%d B·%d S·%d", file.Num(), tcorrupted, blockerr, size)
 		}
 
+		good += tgood
+		corrupted += tcorrupted
+
 		return nil
 	}
 
@@ -432,11 +397,11 @@ func recoverTable(s *session, o *opt.Options) error {
 			}
 		}
 
-		s.logf("table@recovery recovered F·%d N·%d Gk·%d Ck·%d Q·%d", len(tableFiles), recoveredKey, goodKey, corruptedKey, maxSeq)
+		s.logf("table@recovery recovered F·%d N·%d C·%d Q·%d", len(tableFiles), good, corrupted, mSeq)
 	}
 
 	// Set sequence number.
-	rec.setSeqNum(maxSeq)
+	rec.setSeq(mSeq + 1)
 
 	// Create new manifest.
 	if err := s.create(); err != nil {
@@ -519,30 +484,26 @@ func (db *DB) recoverJournal() error {
 				if err == io.EOF {
 					break
 				}
-				return errors.SetFile(err, file)
+				return err
 			}
 
 			buf.Reset()
 			if _, err := buf.ReadFrom(r); err != nil {
 				if err == io.ErrUnexpectedEOF {
-					// This is error returned due to corruption, with strict == false.
 					continue
 				} else {
-					return errors.SetFile(err, file)
+					return err
 				}
 			}
-			if err := batch.memDecodeAndReplay(db.seq, buf.Bytes(), mem); err != nil {
-				if strict || !errors.IsCorrupted(err) {
-					return errors.SetFile(err, file)
-				} else {
-					db.s.logf("journal error: %v (skipped)", err)
-					// We won't apply sequence number as it might be corrupted.
-					continue
-				}
+			if err := batch.decode(buf.Bytes()); err != nil {
+				return err
+			}
+			if err := batch.memReplay(mem); err != nil {
+				return err
 			}
 
 			// Save sequence number.
-			db.seq = batch.seq + uint64(batch.Len())
+			db.seq = batch.seq + uint64(batch.len())
 
 			// Flush it if large enough.
 			if mem.Size() >= writeBuffer {
@@ -603,7 +564,7 @@ func (db *DB) recoverJournal() error {
 }
 
 func (db *DB) get(key []byte, seq uint64, ro *opt.ReadOptions) (value []byte, err error) {
-	ikey := newIkey(key, seq, ktSeek)
+	ikey := newIKey(key, seq, tSeek)
 
 	em, fm := db.getMems()
 	for _, m := range [...]*memDB{em, fm} {
@@ -614,13 +575,9 @@ func (db *DB) get(key []byte, seq uint64, ro *opt.ReadOptions) (value []byte, er
 
 		mk, mv, me := m.mdb.Find(ikey)
 		if me == nil {
-			ukey, _, kt, kerr := parseIkey(mk)
-			if kerr != nil {
-				// Shouldn't have had happen.
-				panic(kerr)
-			}
-			if db.s.icmp.uCompare(ukey, key) == 0 {
-				if kt == ktDel {
+			ukey, _, t, ok := parseIkey(mk)
+			if ok && db.s.icmp.uCompare(ukey, key) == 0 {
+				if t == tDel {
 					return nil, ErrNotFound
 				}
 				return append([]byte{}, mv...), nil
@@ -631,60 +588,17 @@ func (db *DB) get(key []byte, seq uint64, ro *opt.ReadOptions) (value []byte, er
 	}
 
 	v := db.s.version()
-	value, cSched, err := v.get(ikey, ro, false)
+	value, cSched, err := v.get(ikey, ro)
 	v.release()
 	if cSched {
 		// Trigger table compaction.
-		db.compSendTrigger(db.tcompCmdC)
-	}
-	return
-}
-
-func (db *DB) has(key []byte, seq uint64, ro *opt.ReadOptions) (ret bool, err error) {
-	ikey := newIkey(key, seq, ktSeek)
-
-	em, fm := db.getMems()
-	for _, m := range [...]*memDB{em, fm} {
-		if m == nil {
-			continue
-		}
-		defer m.decref()
-
-		mk, _, me := m.mdb.Find(ikey)
-		if me == nil {
-			ukey, _, kt, kerr := parseIkey(mk)
-			if kerr != nil {
-				// Shouldn't have had happen.
-				panic(kerr)
-			}
-			if db.s.icmp.uCompare(ukey, key) == 0 {
-				if kt == ktDel {
-					return false, nil
-				}
-				return true, nil
-			}
-		} else if me != ErrNotFound {
-			return false, me
-		}
-	}
-
-	v := db.s.version()
-	_, cSched, err := v.get(ikey, ro, true)
-	v.release()
-	if cSched {
-		// Trigger table compaction.
-		db.compSendTrigger(db.tcompCmdC)
-	}
-	if err == nil {
-		ret = true
-	} else if err == ErrNotFound {
-		err = nil
+		db.compTrigger(db.tcompTriggerC)
 	}
 	return
 }
 
 // Get gets the value for the given key. It returns ErrNotFound if the
-// DB does not contains the key.
+// DB does not contain the key.
 //
 // The returned slice is its own copy, it is safe to modify the contents
 // of the returned slice.
@@ -695,23 +609,7 @@ func (db *DB) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
 		return
 	}
 
-	se := db.acquireSnapshot()
-	defer db.releaseSnapshot(se)
-	return db.get(key, se.seq, ro)
-}
-
-// Has returns true if the DB does contains the given key.
-//
-// It is safe to modify the contents of the argument after Get returns.
-func (db *DB) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
-	err = db.ok()
-	if err != nil {
-		return
-	}
-
-	se := db.acquireSnapshot()
-	defer db.releaseSnapshot(se)
-	return db.has(key, se.seq, ro)
+	return db.get(key, db.getSeq(), ro)
 }
 
 // NewIterator returns an iterator for the latest snapshot of the
@@ -735,11 +633,9 @@ func (db *DB) NewIterator(slice *util.Range, ro *opt.ReadOptions) iterator.Itera
 		return iterator.NewEmptyIterator(err)
 	}
 
-	se := db.acquireSnapshot()
-	defer db.releaseSnapshot(se)
-	// Iterator holds 'version' lock, 'version' is immutable so snapshot
-	// can be released after iterator created.
-	return db.newIterator(se.seq, slice, ro)
+	snap := db.newSnapshot()
+	defer snap.Release()
+	return snap.NewIterator(slice, ro)
 }
 
 // GetSnapshot returns a latest snapshot of the underlying DB. A snapshot
@@ -759,7 +655,7 @@ func (db *DB) GetSnapshot() (*Snapshot, error) {
 //
 // Property names:
 //	leveldb.num-files-at-level{n}
-//		Returns the number of files at level 'n'.
+//		Returns the number of filer at level 'n'.
 //	leveldb.stats
 //		Returns statistics of the underlying DB.
 //	leveldb.sstables
@@ -789,13 +685,12 @@ func (db *DB) GetProperty(name string) (value string, err error) {
 	v := db.s.version()
 	defer v.release()
 
-	numFilesPrefix := "num-files-at-level"
 	switch {
-	case strings.HasPrefix(p, numFilesPrefix):
+	case strings.HasPrefix(p, "num-files-at-level"):
 		var level uint
 		var rest string
-		n, _ := fmt.Sscanf(p[len(numFilesPrefix):], "%d%s", &level, &rest)
-		if n != 1 || int(level) >= db.s.o.GetNumLevel() {
+		n, _ := fmt.Scanf("%d%s", &level, &rest)
+		if n != 1 || level >= kNumLevels {
 			err = errors.New("leveldb: GetProperty: invalid property: " + name)
 		} else {
 			value = fmt.Sprint(v.tLen(int(level)))
@@ -823,8 +718,8 @@ func (db *DB) GetProperty(name string) (value string, err error) {
 	case p == "blockpool":
 		value = fmt.Sprintf("%v", db.s.tops.bpool)
 	case p == "cachedblock":
-		if db.s.tops.bcache != nil {
-			value = fmt.Sprintf("%d", db.s.tops.bcache.Size())
+		if bc := db.s.o.GetBlockCache(); bc != nil {
+			value = fmt.Sprintf("%d", bc.Size())
 		} else {
 			value = "<nil>"
 		}
@@ -857,8 +752,8 @@ func (db *DB) SizeOf(ranges []util.Range) (Sizes, error) {
 
 	sizes := make(Sizes, 0, len(ranges))
 	for _, r := range ranges {
-		imin := newIkey(r.Start, kMaxSeq, ktSeek)
-		imax := newIkey(r.Limit, kMaxSeq, ktSeek)
+		imin := newIKey(r.Start, kMaxSeq, tSeek)
+		imax := newIKey(r.Limit, kMaxSeq, tSeek)
 		start, err := v.offsetOf(imin)
 		if err != nil {
 			return nil, err
@@ -901,23 +796,18 @@ func (db *DB) Close() error {
 	default:
 	}
 
-	// Signal all goroutines.
 	close(db.closeC)
 
-	// Wait for all gorotines to exit.
+	// Wait for the close WaitGroup.
 	db.closeW.Wait()
 
-	// Lock writer and closes journal.
+	// Close journal.
 	db.writeLockC <- struct{}{}
 	if db.journal != nil {
 		db.journal.Close()
 		db.journalWriter.Close()
 	}
 
-	if db.writeDelayN > 0 {
-		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
-	}
-
 	// Close session.
 	db.s.close()
 	db.logf("db@close done T·%v", time.Since(start))
@@ -937,6 +827,7 @@ func (db *DB) Close() error {
 	db.journalWriter = nil
 	db.journalFile = nil
 	db.frozenJournalFile = nil
+	db.snapsRoot = snapshotElement{}
 	db.closer = nil
 
 	return err

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_compaction.go

@@ -7,12 +7,11 @@
 package leveldb
 
 import (
+	"errors"
 	"sync"
 	"time"
 
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/memdb"
-	"github.com/syndtr/goleveldb/leveldb/opt"
 )
 
 var (
@@ -69,7 +68,7 @@ type cMem struct {
 }
 
 func newCMem(s *session) *cMem {
-	return &cMem{s: s, rec: &sessionRecord{numLevel: s.o.GetNumLevel()}}
+	return &cMem{s: s, rec: new(sessionRecord)}
 }
 
 func (c *cMem) flush(mem *memdb.DB, level int) error {
@@ -85,9 +84,7 @@ func (c *cMem) flush(mem *memdb.DB, level int) error {
 
 	// Pick level.
 	if level < 0 {
-		v := s.version()
-		level = v.pickLevel(t.imin.ukey(), t.imax.ukey())
-		v.release()
+		level = s.version_NB().pickLevel(t.imin.ukey(), t.imax.ukey())
 	}
 	c.rec.addTableFile(level, t)
 
@@ -98,32 +95,24 @@ func (c *cMem) flush(mem *memdb.DB, level int) error {
 }
 
 func (c *cMem) reset() {
-	c.rec = &sessionRecord{numLevel: c.s.o.GetNumLevel()}
+	c.rec = new(sessionRecord)
 }
 
 func (c *cMem) commit(journal, seq uint64) error {
 	c.rec.setJournalNum(journal)
-	c.rec.setSeqNum(seq)
+	c.rec.setSeq(seq)
 
 	// Commit changes.
 	return c.s.commit(c.rec)
 }
 
 func (db *DB) compactionError() {
-	var (
-		err     error
-		wlocked bool
-	)
+	var err error
 noerr:
-	// No error.
 	for {
 		select {
 		case err = <-db.compErrSetC:
-			switch {
-			case err == nil:
-			case errors.IsCorrupted(err):
-				goto hasperr
-			default:
+			if err != nil {
 				goto haserr
 			}
 		case _, _ = <-db.closeC:
@@ -131,39 +120,17 @@ noerr:
 		}
 	}
 haserr:
-	// Transient error.
 	for {
 		select {
 		case db.compErrC <- err:
 		case err = <-db.compErrSetC:
-			switch {
-			case err == nil:
+			if err == nil {
 				goto noerr
-			case errors.IsCorrupted(err):
-				goto hasperr
-			default:
 			}
 		case _, _ = <-db.closeC:
 			return
 		}
 	}
-hasperr:
-	// Persistent error.
-	for {
-		select {
-		case db.compErrC <- err:
-		case db.compPerErrC <- err:
-		case db.writeLockC <- struct{}{}:
-			// Hold write lock, so that write won't pass-through.
-			wlocked = true
-		case _, _ = <-db.closeC:
-			if wlocked {
-				// We should release the lock or Close will hang.
-				<-db.writeLockC
-			}
-			return
-		}
-	}
 }
 
 type compactionTransactCounter int
@@ -172,17 +139,12 @@ func (cnt *compactionTransactCounter) incr() {
 	*cnt++
 }
 
-type compactionTransactInterface interface {
-	run(cnt *compactionTransactCounter) error
-	revert() error
-}
-
-func (db *DB) compactionTransact(name string, t compactionTransactInterface) {
+func (db *DB) compactionTransact(name string, exec func(cnt *compactionTransactCounter) error, rollback func() error) {
 	defer func() {
 		if x := recover(); x != nil {
-			if x == errCompactionTransactExiting {
-				if err := t.revert(); err != nil {
-					db.logf("%s revert error %q", name, err)
+			if x == errCompactionTransactExiting && rollback != nil {
+				if err := rollback(); err != nil {
+					db.logf("%s rollback error %q", name, err)
 				}
 			}
 			panic(x)
@@ -194,13 +156,9 @@ func (db *DB) compactionTransact(name string, t compactionTransactInterface) {
 		backoffMax = 8 * time.Second
 		backoffMul = 2 * time.Second
 	)
-	var (
-		backoff  = backoffMin
-		backoffT = time.NewTimer(backoff)
-		lastCnt  = compactionTransactCounter(0)
-
-		disableBackoff = db.s.o.GetDisableCompactionBackoff()
-	)
+	backoff := backoffMin
+	backoffT := time.NewTimer(backoff)
+	lastCnt := compactionTransactCounter(0)
 	for n := 0; ; n++ {
 		// Check wether the DB is closed.
 		if db.isClosed() {
@@ -212,19 +170,11 @@ func (db *DB) compactionTransact(name string, t compactionTransactInterface) {
 
 		// Execute.
 		cnt := compactionTransactCounter(0)
-		err := t.run(&cnt)
-		if err != nil {
-			db.logf("%s error I·%d %q", name, cnt, err)
-		}
+		err := exec(&cnt)
 
 		// Set compaction error status.
 		select {
 		case db.compErrSetC <- err:
-		case perr := <-db.compPerErrC:
-			if err != nil {
-				db.logf("%s exiting (persistent error %q)", name, perr)
-				db.compactionExitTransact()
-			}
 		case _, _ = <-db.closeC:
 			db.logf("%s exiting", name)
 			db.compactionExitTransact()
@@ -232,56 +182,31 @@ func (db *DB) compactionTransact(name string, t compactionTransactInterface) {
 		if err == nil {
 			return
 		}
-		if errors.IsCorrupted(err) {
-			db.logf("%s exiting (corruption detected)", name)
+		db.logf("%s error I·%d %q", name, cnt, err)
+
+		// Reset backoff duration if counter is advancing.
+		if cnt > lastCnt {
+			backoff = backoffMin
+			lastCnt = cnt
+		}
+
+		// Backoff.
+		backoffT.Reset(backoff)
+		if backoff < backoffMax {
+			backoff *= backoffMul
+			if backoff > backoffMax {
+				backoff = backoffMax
+			}
+		}
+		select {
+		case <-backoffT.C:
+		case _, _ = <-db.closeC:
+			db.logf("%s exiting", name)
 			db.compactionExitTransact()
 		}
-
-		if !disableBackoff {
-			// Reset backoff duration if counter is advancing.
-			if cnt > lastCnt {
-				backoff = backoffMin
-				lastCnt = cnt
-			}
-
-			// Backoff.
-			backoffT.Reset(backoff)
-			if backoff < backoffMax {
-				backoff *= backoffMul
-				if backoff > backoffMax {
-					backoff = backoffMax
-				}
-			}
-			select {
-			case <-backoffT.C:
-			case _, _ = <-db.closeC:
-				db.logf("%s exiting", name)
-				db.compactionExitTransact()
-			}
-		}
 	}
 }
 
-type compactionTransactFunc struct {
-	runFunc    func(cnt *compactionTransactCounter) error
-	revertFunc func() error
-}
-
-func (t *compactionTransactFunc) run(cnt *compactionTransactCounter) error {
-	return t.runFunc(cnt)
-}
-
-func (t *compactionTransactFunc) revert() error {
-	if t.revertFunc != nil {
-		return t.revertFunc()
-	}
-	return nil
-}
-
-func (db *DB) compactionTransactFunc(name string, run func(cnt *compactionTransactCounter) error, revert func() error) {
-	db.compactionTransact(name, &compactionTransactFunc{run, revert})
-}
-
 func (db *DB) compactionExitTransact() {
 	panic(errCompactionTransactExiting)
 }
@@ -307,23 +232,20 @@ func (db *DB) memCompaction() {
 	}
 
 	// Pause table compaction.
-	resumeC := make(chan struct{})
+	ch := make(chan struct{})
 	select {
-	case db.tcompPauseC <- (chan<- struct{})(resumeC):
-	case <-db.compPerErrC:
-		close(resumeC)
-		resumeC = nil
+	case db.tcompPauseC <- (chan<- struct{})(ch):
 	case _, _ = <-db.closeC:
 		return
 	}
 
-	db.compactionTransactFunc("mem@flush", func(cnt *compactionTransactCounter) (err error) {
+	db.compactionTransact("mem@flush", func(cnt *compactionTransactCounter) (err error) {
 		stats.startTimer()
 		defer stats.stopTimer()
 		return c.flush(mem.mdb, -1)
 	}, func() error {
 		for _, r := range c.rec.addedTables {
-			db.logf("mem@flush revert @%d", r.num)
+			db.logf("mem@flush rollback @%d", r.num)
 			f := db.s.getTableFile(r.num)
 			if err := f.Remove(); err != nil {
 				return err
@@ -332,13 +254,13 @@ func (db *DB) memCompaction() {
 		return nil
 	})
 
-	db.compactionTransactFunc("mem@commit", func(cnt *compactionTransactCounter) (err error) {
+	db.compactionTransact("mem@commit", func(cnt *compactionTransactCounter) (err error) {
 		stats.startTimer()
 		defer stats.stopTimer()
 		return c.commit(db.journalFile.Num(), db.frozenSeq)
 	}, nil)
 
-	db.logf("mem@flush committed F·%d T·%v", len(c.rec.addedTables), stats.duration)
+	db.logf("mem@flush commited F·%d T·%v", len(c.rec.addedTables), stats.duration)
 
 	for _, r := range c.rec.addedTables {
 		stats.write += r.size
@@ -349,223 +271,26 @@ func (db *DB) memCompaction() {
 	db.dropFrozenMem()
 
 	// Resume table compaction.
-	if resumeC != nil {
-		select {
-		case <-resumeC:
-			close(resumeC)
-		case _, _ = <-db.closeC:
-			return
-		}
+	select {
+	case <-ch:
+	case _, _ = <-db.closeC:
+		return
 	}
 
 	// Trigger table compaction.
-	db.compSendTrigger(db.tcompCmdC)
-}
-
-type tableCompactionBuilder struct {
-	db           *DB
-	s            *session
-	c            *compaction
-	rec          *sessionRecord
-	stat0, stat1 *cStatsStaging
-
-	snapHasLastUkey bool
-	snapLastUkey    []byte
-	snapLastSeq     uint64
-	snapIter        int
-	snapKerrCnt     int
-	snapDropCnt     int
-
-	kerrCnt int
-	dropCnt int
-
-	minSeq    uint64
-	strict    bool
-	tableSize int
-
-	tw *tWriter
-}
-
-func (b *tableCompactionBuilder) appendKV(key, value []byte) error {
-	// Create new table if not already.
-	if b.tw == nil {
-		// Check for pause event.
-		if b.db != nil {
-			select {
-			case ch := <-b.db.tcompPauseC:
-				b.db.pauseCompaction(ch)
-			case _, _ = <-b.db.closeC:
-				b.db.compactionExitTransact()
-			default:
-			}
-		}
-
-		// Create new table.
-		var err error
-		b.tw, err = b.s.tops.create()
-		if err != nil {
-			return err
-		}
-	}
-
-	// Write key/value into table.
-	return b.tw.append(key, value)
-}
-
-func (b *tableCompactionBuilder) needFlush() bool {
-	return b.tw.tw.BytesLen() >= b.tableSize
-}
-
-func (b *tableCompactionBuilder) flush() error {
-	t, err := b.tw.finish()
-	if err != nil {
-		return err
-	}
-	b.rec.addTableFile(b.c.level+1, t)
-	b.stat1.write += t.size
-	b.s.logf("table@build created L%d@%d N·%d S·%s %q:%q", b.c.level+1, t.file.Num(), b.tw.tw.EntriesLen(), shortenb(int(t.size)), t.imin, t.imax)
-	b.tw = nil
-	return nil
-}
-
-func (b *tableCompactionBuilder) cleanup() {
-	if b.tw != nil {
-		b.tw.drop()
-		b.tw = nil
-	}
-}
-
-func (b *tableCompactionBuilder) run(cnt *compactionTransactCounter) error {
-	snapResumed := b.snapIter > 0
-	hasLastUkey := b.snapHasLastUkey // The key might has zero length, so this is necessary.
-	lastUkey := append([]byte{}, b.snapLastUkey...)
-	lastSeq := b.snapLastSeq
-	b.kerrCnt = b.snapKerrCnt
-	b.dropCnt = b.snapDropCnt
-	// Restore compaction state.
-	b.c.restore()
-
-	defer b.cleanup()
-
-	b.stat1.startTimer()
-	defer b.stat1.stopTimer()
-
-	iter := b.c.newIterator()
-	defer iter.Release()
-	for i := 0; iter.Next(); i++ {
-		// Incr transact counter.
-		cnt.incr()
-
-		// Skip until last state.
-		if i < b.snapIter {
-			continue
-		}
-
-		resumed := false
-		if snapResumed {
-			resumed = true
-			snapResumed = false
-		}
-
-		ikey := iter.Key()
-		ukey, seq, kt, kerr := parseIkey(ikey)
-
-		if kerr == nil {
-			shouldStop := !resumed && b.c.shouldStopBefore(ikey)
-
-			if !hasLastUkey || b.s.icmp.uCompare(lastUkey, ukey) != 0 {
-				// First occurrence of this user key.
-
-				// Only rotate tables if ukey doesn't hop across.
-				if b.tw != nil && (shouldStop || b.needFlush()) {
-					if err := b.flush(); err != nil {
-						return err
-					}
-
-					// Creates snapshot of the state.
-					b.c.save()
-					b.snapHasLastUkey = hasLastUkey
-					b.snapLastUkey = append(b.snapLastUkey[:0], lastUkey...)
-					b.snapLastSeq = lastSeq
-					b.snapIter = i
-					b.snapKerrCnt = b.kerrCnt
-					b.snapDropCnt = b.dropCnt
-				}
-
-				hasLastUkey = true
-				lastUkey = append(lastUkey[:0], ukey...)
-				lastSeq = kMaxSeq
-			}
-
-			switch {
-			case lastSeq <= b.minSeq:
-				// Dropped because newer entry for same user key exist
-				fallthrough // (A)
-			case kt == ktDel && seq <= b.minSeq && b.c.baseLevelForKey(lastUkey):
-				// For this user key:
-				// (1) there is no data in higher levels
-				// (2) data in lower levels will have larger seq numbers
-				// (3) data in layers that are being compacted here and have
-				//     smaller seq numbers will be dropped in the next
-				//     few iterations of this loop (by rule (A) above).
-				// Therefore this deletion marker is obsolete and can be dropped.
-				lastSeq = seq
-				b.dropCnt++
-				continue
-			default:
-				lastSeq = seq
-			}
-		} else {
-			if b.strict {
-				return kerr
-			}
-
-			// Don't drop corrupted keys.
-			hasLastUkey = false
-			lastUkey = lastUkey[:0]
-			lastSeq = kMaxSeq
-			b.kerrCnt++
-		}
-
-		if err := b.appendKV(ikey, iter.Value()); err != nil {
-			return err
-		}
-	}
-
-	if err := iter.Error(); err != nil {
-		return err
-	}
-
-	// Finish last table.
-	if b.tw != nil && !b.tw.empty() {
-		return b.flush()
-	}
-	return nil
-}
-
-func (b *tableCompactionBuilder) revert() error {
-	for _, at := range b.rec.addedTables {
-		b.s.logf("table@build revert @%d", at.num)
-		f := b.s.getTableFile(at.num)
-		if err := f.Remove(); err != nil {
-			return err
-		}
-	}
-	return nil
+	db.compTrigger(db.mcompTriggerC)
 }
 
 func (db *DB) tableCompaction(c *compaction, noTrivial bool) {
-	defer c.release()
-
-	rec := &sessionRecord{numLevel: db.s.o.GetNumLevel()}
-	rec.addCompPtr(c.level, c.imax)
+	rec := new(sessionRecord)
+	rec.addCompactionPointer(c.level, c.imax)
 
 	if !noTrivial && c.trivial() {
 		t := c.tables[0][0]
 		db.logf("table@move L%d@%d -> L%d", c.level, t.file.Num(), c.level+1)
-		rec.delTable(c.level, t.file.Num())
+		rec.deleteTable(c.level, t.file.Num())
 		rec.addTableFile(c.level+1, t)
-		db.compactionTransactFunc("table@move", func(cnt *compactionTransactCounter) (err error) {
+		db.compactionTransact("table@move", func(cnt *compactionTransactCounter) (err error) {
 			return db.s.commit(rec)
 		}, nil)
 		return
@@ -576,34 +301,184 @@ func (db *DB) tableCompaction(c *compaction, noTrivial bool) {
 		for _, t := range tables {
 			stats[i].read += t.size
 			// Insert deleted tables into record
-			rec.delTable(c.level+i, t.file.Num())
+			rec.deleteTable(c.level+i, t.file.Num())
 		}
 	}
 	sourceSize := int(stats[0].read + stats[1].read)
 	minSeq := db.minSeq()
 	db.logf("table@compaction L%d·%d -> L%d·%d S·%s Q·%d", c.level, len(c.tables[0]), c.level+1, len(c.tables[1]), shortenb(sourceSize), minSeq)
 
-	b := &tableCompactionBuilder{
-		db:        db,
-		s:         db.s,
-		c:         c,
-		rec:       rec,
-		stat1:     &stats[1],
-		minSeq:    minSeq,
-		strict:    db.s.o.GetStrict(opt.StrictCompaction),
-		tableSize: db.s.o.GetCompactionTableSize(c.level + 1),
-	}
-	db.compactionTransact("table@build", b)
+	var snapUkey []byte
+	var snapHasUkey bool
+	var snapSeq uint64
+	var snapIter int
+	var snapDropCnt int
+	var dropCnt int
+	db.compactionTransact("table@build", func(cnt *compactionTransactCounter) (err error) {
+		ukey := append([]byte{}, snapUkey...)
+		hasUkey := snapHasUkey
+		lseq := snapSeq
+		dropCnt = snapDropCnt
+		snapSched := snapIter == 0
+
+		var tw *tWriter
+		finish := func() error {
+			t, err := tw.finish()
+			if err != nil {
+				return err
+			}
+			rec.addTableFile(c.level+1, t)
+			stats[1].write += t.size
+			db.logf("table@build created L%d@%d N·%d S·%s %q:%q", c.level+1, t.file.Num(), tw.tw.EntriesLen(), shortenb(int(t.size)), t.imin, t.imax)
+			return nil
+		}
+
+		defer func() {
+			stats[1].stopTimer()
+			if tw != nil {
+				tw.drop()
+				tw = nil
+			}
+		}()
+
+		stats[1].startTimer()
+		iter := c.newIterator()
+		defer iter.Release()
+		for i := 0; iter.Next(); i++ {
+			// Incr transact counter.
+			cnt.incr()
+
+			// Skip until last state.
+			if i < snapIter {
+				continue
+			}
+
+			ikey := iKey(iter.Key())
+
+			if c.shouldStopBefore(ikey) && tw != nil {
+				err = finish()
+				if err != nil {
+					return
+				}
+				snapSched = true
+				tw = nil
+			}
+
+			// Scheduled for snapshot, snapshot will used to retry compaction
+			// if error occured.
+			if snapSched {
+				snapUkey = append(snapUkey[:0], ukey...)
+				snapHasUkey = hasUkey
+				snapSeq = lseq
+				snapIter = i
+				snapDropCnt = dropCnt
+				snapSched = false
+			}
+
+			if seq, vt, ok := ikey.parseNum(); !ok {
+				// Don't drop error keys
+				ukey = ukey[:0]
+				hasUkey = false
+				lseq = kMaxSeq
+			} else {
+				if !hasUkey || db.s.icmp.uCompare(ikey.ukey(), ukey) != 0 {
+					// First occurrence of this user key
+					ukey = append(ukey[:0], ikey.ukey()...)
+					hasUkey = true
+					lseq = kMaxSeq
+				}
+
+				drop := false
+				if lseq <= minSeq {
+					// Dropped because newer entry for same user key exist
+					drop = true // (A)
+				} else if vt == tDel && seq <= minSeq && c.baseLevelForKey(ukey) {
+					// For this user key:
+					// (1) there is no data in higher levels
+					// (2) data in lower levels will have larger seq numbers
+					// (3) data in layers that are being compacted here and have
+					//     smaller seq numbers will be dropped in the next
+					//     few iterations of this loop (by rule (A) above).
+					// Therefore this deletion marker is obsolete and can be dropped.
+					drop = true
+				}
+
+				lseq = seq
+				if drop {
+					dropCnt++
+					continue
+				}
+			}
+
+			// Create new table if not already
+			if tw == nil {
+				// Check for pause event.
+				select {
+				case ch := <-db.tcompPauseC:
+					db.pauseCompaction(ch)
+				case _, _ = <-db.closeC:
+					db.compactionExitTransact()
+				default:
+				}
+
+				// Create new table.
+				tw, err = db.s.tops.create()
+				if err != nil {
+					return
+				}
+			}
+
+			// Write key/value into table
+			err = tw.append(ikey, iter.Value())
+			if err != nil {
+				return
+			}
+
+			// Finish table if it is big enough
+			if tw.tw.BytesLen() >= kMaxTableSize {
+				err = finish()
+				if err != nil {
+					return
+				}
+				snapSched = true
+				tw = nil
+			}
+		}
+
+		err = iter.Error()
+		if err != nil {
+			return
+		}
+
+		// Finish last table
+		if tw != nil && !tw.empty() {
+			err = finish()
+			if err != nil {
+				return
+			}
+			tw = nil
+		}
+		return
+	}, func() error {
+		for _, r := range rec.addedTables {
+			db.logf("table@build rollback @%d", r.num)
+			f := db.s.getTableFile(r.num)
+			if err := f.Remove(); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 
 	// Commit changes
-	db.compactionTransactFunc("table@commit", func(cnt *compactionTransactCounter) (err error) {
+	db.compactionTransact("table@commit", func(cnt *compactionTransactCounter) (err error) {
 		stats[1].startTimer()
 		defer stats[1].stopTimer()
 		return db.s.commit(rec)
 	}, nil)
 
 	resultSize := int(stats[1].write)
-	db.logf("table@compaction committed F%s S%s Ke·%d D·%d T·%v", sint(len(rec.addedTables)-len(rec.deletedTables)), sshortenb(resultSize-sourceSize), b.kerrCnt, b.dropCnt, stats[1].duration)
+	db.logf("table@compaction commited F%s S%s D·%d T·%v", sint(len(rec.addedTables)-len(rec.deletedTables)), sshortenb(resultSize-sourceSize), dropCnt, stats[1].duration)
 
 	// Save compaction stats
 	for i := range stats {
@@ -619,14 +494,14 @@ func (db *DB) tableRangeCompaction(level int, umin, umax []byte) {
 			db.tableCompaction(c, true)
 		}
 	} else {
-		v := db.s.version()
+		v := db.s.version_NB()
+
 		m := 1
 		for i, t := range v.tables[1:] {
 			if t.overlaps(db.s.icmp, umin, umax, false) {
 				m = i + 1
 			}
 		}
-		v.release()
 
 		for level := 0; level < m; level++ {
 			if c := db.s.getCompactionRange(level, umin, umax); c != nil {
@@ -643,9 +518,7 @@ func (db *DB) tableAutoCompaction() {
 }
 
 func (db *DB) tableNeedCompaction() bool {
-	v := db.s.version()
-	defer v.release()
-	return v.needCompaction()
+	return db.s.version_NB().needCompaction()
 }
 
 func (db *DB) pauseCompaction(ch chan<- struct{}) {
@@ -665,12 +538,7 @@ type cIdle struct {
 }
 
 func (r cIdle) ack(err error) {
-	if r.ackC != nil {
-		defer func() {
-			recover()
-		}()
-		r.ackC <- err
-	}
+	r.ackC <- err
 }
 
 type cRange struct {
@@ -680,45 +548,29 @@ type cRange struct {
 }
 
 func (r cRange) ack(err error) {
+	defer func() {
+		recover()
+	}()
 	if r.ackC != nil {
-		defer func() {
-			recover()
-		}()
 		r.ackC <- err
 	}
 }
 
-// This will trigger auto compation and/or wait for all compaction to be done.
-func (db *DB) compSendIdle(compC chan<- cCmd) (err error) {
+func (db *DB) compSendIdle(compC chan<- cCmd) error {
 	ch := make(chan error)
 	defer close(ch)
 	// Send cmd.
 	select {
 	case compC <- cIdle{ch}:
-	case err = <-db.compErrC:
-		return
+	case err := <-db.compErrC:
+		return err
 	case _, _ = <-db.closeC:
 		return ErrClosed
 	}
 	// Wait cmd.
-	select {
-	case err = <-ch:
-	case err = <-db.compErrC:
-	case _, _ = <-db.closeC:
-		return ErrClosed
-	}
-	return err
+	return <-ch
 }
 
-// This will trigger auto compaction but will not wait for it.
-func (db *DB) compSendTrigger(compC chan<- cCmd) {
-	select {
-	case compC <- cIdle{}:
-	default:
-	}
-}
-
-// Send range compaction request.
 func (db *DB) compSendRange(compC chan<- cCmd, level int, min, max []byte) (err error) {
 	ch := make(chan error)
 	defer close(ch)
@@ -732,14 +584,19 @@ func (db *DB) compSendRange(compC chan<- cCmd, level int, min, max []byte) (err
 	}
 	// Wait cmd.
 	select {
-	case err = <-ch:
 	case err = <-db.compErrC:
-	case _, _ = <-db.closeC:
-		return ErrClosed
+	case err = <-ch:
 	}
 	return err
 }
 
+func (db *DB) compTrigger(compTriggerC chan struct{}) {
+	select {
+	case compTriggerC <- struct{}{}:
+	default:
+	}
+}
+
 func (db *DB) mCompaction() {
 	var x cCmd
 
@@ -758,14 +615,11 @@ func (db *DB) mCompaction() {
 	for {
 		select {
 		case x = <-db.mcompCmdC:
-			switch x.(type) {
-			case cIdle:
-				db.memCompaction()
-				x.ack(nil)
-				x = nil
-			default:
-				panic("leveldb: unknown command")
-			}
+			db.memCompaction()
+			x.ack(nil)
+			x = nil
+		case <-db.mcompTriggerC:
+			db.memCompaction()
 		case _, _ = <-db.closeC:
 			return
 		}
@@ -796,6 +650,7 @@ func (db *DB) tCompaction() {
 		if db.tableNeedCompaction() {
 			select {
 			case x = <-db.tcompCmdC:
+			case <-db.tcompTriggerC:
 			case ch := <-db.tcompPauseC:
 				db.pauseCompaction(ch)
 				continue
@@ -811,6 +666,7 @@ func (db *DB) tCompaction() {
 			ackQ = ackQ[:0]
 			select {
 			case x = <-db.tcompCmdC:
+			case <-db.tcompTriggerC:
 			case ch := <-db.tcompPauseC:
 				db.pauseCompaction(ch)
 				continue
@@ -825,8 +681,6 @@ func (db *DB) tCompaction() {
 			case cRange:
 				db.tableRangeCompaction(cmd.level, cmd.min, cmd.max)
 				x.ack(nil)
-			default:
-				panic("leveldb: unknown command")
 			}
 			x = nil
 		}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_iter.go

@@ -48,7 +48,7 @@ func (db *DB) newRawIterator(slice *util.Range, ro *opt.ReadOptions) iterator.It
 		i = append(i, fmi)
 	}
 	i = append(i, ti...)
-	strict := opt.GetStrict(db.s.o.Options, ro, opt.StrictReader)
+	strict := db.s.o.GetStrict(opt.StrictIterator) || ro.GetStrict(opt.StrictIterator)
 	mi := iterator.NewMergedIterator(i, db.s.icmp, strict)
 	mi.SetReleaser(&versionReleaser{v: v})
 	return mi
@@ -59,10 +59,10 @@ func (db *DB) newIterator(seq uint64, slice *util.Range, ro *opt.ReadOptions) *d
 	if slice != nil {
 		islice = &util.Range{}
 		if slice.Start != nil {
-			islice.Start = newIkey(slice.Start, kMaxSeq, ktSeek)
+			islice.Start = newIKey(slice.Start, kMaxSeq, tSeek)
 		}
 		if slice.Limit != nil {
-			islice.Limit = newIkey(slice.Limit, kMaxSeq, ktSeek)
+			islice.Limit = newIKey(slice.Limit, kMaxSeq, tSeek)
 		}
 	}
 	rawIter := db.newRawIterator(islice, ro)
@@ -71,7 +71,7 @@ func (db *DB) newIterator(seq uint64, slice *util.Range, ro *opt.ReadOptions) *d
 		icmp:   db.s.icmp,
 		iter:   rawIter,
 		seq:    seq,
-		strict: opt.GetStrict(db.s.o.Options, ro, opt.StrictReader),
+		strict: db.s.o.GetStrict(opt.StrictIterator) || ro.GetStrict(opt.StrictIterator),
 		key:    make([]byte, 0),
 		value:  make([]byte, 0),
 	}
@@ -162,7 +162,7 @@ func (i *dbIter) Seek(key []byte) bool {
 		return false
 	}
 
-	ikey := newIkey(key, i.seq, ktSeek)
+	ikey := newIKey(key, i.seq, tSeek)
 	if i.iter.Seek(ikey) {
 		i.dir = dirSOI
 		return i.next()
@@ -174,14 +174,15 @@ func (i *dbIter) Seek(key []byte) bool {
 
 func (i *dbIter) next() bool {
 	for {
-		if ukey, seq, kt, kerr := parseIkey(i.iter.Key()); kerr == nil {
+		ukey, seq, t, ok := parseIkey(i.iter.Key())
+		if ok {
 			if seq <= i.seq {
-				switch kt {
-				case ktDel:
+				switch t {
+				case tDel:
 					// Skip deleted key.
 					i.key = append(i.key[:0], ukey...)
 					i.dir = dirForward
-				case ktVal:
+				case tVal:
 					if i.dir == dirSOI || i.icmp.uCompare(ukey, i.key) > 0 {
 						i.key = append(i.key[:0], ukey...)
 						i.value = append(i.value[:0], i.iter.Value()...)
@@ -191,7 +192,7 @@ func (i *dbIter) next() bool {
 				}
 			}
 		} else if i.strict {
-			i.setErr(kerr)
+			i.setErr(errInvalidIkey)
 			break
 		}
 		if !i.iter.Next() {
@@ -224,19 +225,20 @@ func (i *dbIter) prev() bool {
 	del := true
 	if i.iter.Valid() {
 		for {
-			if ukey, seq, kt, kerr := parseIkey(i.iter.Key()); kerr == nil {
+			ukey, seq, t, ok := parseIkey(i.iter.Key())
+			if ok {
 				if seq <= i.seq {
 					if !del && i.icmp.uCompare(ukey, i.key) < 0 {
 						return true
 					}
-					del = (kt == ktDel)
+					del = (t == tDel)
 					if !del {
 						i.key = append(i.key[:0], ukey...)
 						i.value = append(i.value[:0], i.iter.Value()...)
 					}
 				}
 			} else if i.strict {
-				i.setErr(kerr)
+				i.setErr(errInvalidIkey)
 				return false
 			}
 			if !i.iter.Prev() {
@@ -265,12 +267,13 @@ func (i *dbIter) Prev() bool {
 		return i.Last()
 	case dirForward:
 		for i.iter.Prev() {
-			if ukey, _, _, kerr := parseIkey(i.iter.Key()); kerr == nil {
+			ukey, _, _, ok := parseIkey(i.iter.Key())
+			if ok {
 				if i.icmp.uCompare(ukey, i.key) < 0 {
 					goto cont
 				}
 			} else if i.strict {
-				i.setErr(kerr)
+				i.setErr(errInvalidIkey)
 				return false
 			}
 		}
@@ -318,13 +321,9 @@ func (i *dbIter) Release() {
 }
 
 func (i *dbIter) SetReleaser(releaser util.Releaser) {
-	if i.dir == dirReleased {
-		panic(util.ErrReleased)
+	if i.dir != dirReleased {
+		i.releaser = releaser
 	}
-	if i.releaser != nil && releaser != nil {
-		panic(util.ErrHasReleaser)
-	}
-	i.releaser = releaser
 }
 
 func (i *dbIter) Error() error {

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_snapshot.go

@@ -7,8 +7,6 @@
 package leveldb
 
 import (
-	"container/list"
-	"fmt"
 	"runtime"
 	"sync"
 	"sync/atomic"
@@ -21,41 +19,51 @@ import (
 type snapshotElement struct {
 	seq uint64
 	ref int
-	e   *list.Element
+	// Next and previous pointers in the doubly-linked list of elements.
+	next, prev *snapshotElement
+}
+
+// Initialize the snapshot.
+func (db *DB) initSnapshot() {
+	db.snapsRoot.next = &db.snapsRoot
+	db.snapsRoot.prev = &db.snapsRoot
 }
 
 // Acquires a snapshot, based on latest sequence.
 func (db *DB) acquireSnapshot() *snapshotElement {
 	db.snapsMu.Lock()
-	defer db.snapsMu.Unlock()
-
 	seq := db.getSeq()
-
-	if e := db.snapsList.Back(); e != nil {
-		se := e.Value.(*snapshotElement)
-		if se.seq == seq {
-			se.ref++
-			return se
-		} else if seq < se.seq {
-			panic("leveldb: sequence number is not increasing")
+	elem := db.snapsRoot.prev
+	if elem == &db.snapsRoot || elem.seq != seq {
+		at := db.snapsRoot.prev
+		next := at.next
+		elem = &snapshotElement{
+			seq:  seq,
+			prev: at,
+			next: next,
 		}
+		at.next = elem
+		next.prev = elem
 	}
-	se := &snapshotElement{seq: seq, ref: 1}
-	se.e = db.snapsList.PushBack(se)
-	return se
+	elem.ref++
+	db.snapsMu.Unlock()
+	return elem
 }
 
 // Releases given snapshot element.
-func (db *DB) releaseSnapshot(se *snapshotElement) {
-	db.snapsMu.Lock()
-	defer db.snapsMu.Unlock()
-
-	se.ref--
-	if se.ref == 0 {
-		db.snapsList.Remove(se.e)
-		se.e = nil
-	} else if se.ref < 0 {
-		panic("leveldb: Snapshot: negative element reference")
+func (db *DB) releaseSnapshot(elem *snapshotElement) {
+	if !db.isClosed() {
+		db.snapsMu.Lock()
+		elem.ref--
+		if elem.ref == 0 {
+			elem.prev.next = elem.next
+			elem.next.prev = elem.prev
+			elem.next = nil
+			elem.prev = nil
+		} else if elem.ref < 0 {
+			panic("leveldb: Snapshot: negative element reference")
+		}
+		db.snapsMu.Unlock()
 	}
 }
 
@@ -63,11 +71,10 @@ func (db *DB) releaseSnapshot(se *snapshotElement) {
 func (db *DB) minSeq() uint64 {
 	db.snapsMu.Lock()
 	defer db.snapsMu.Unlock()
-
-	if e := db.snapsList.Front(); e != nil {
-		return e.Value.(*snapshotElement).seq
+	elem := db.snapsRoot.prev
+	if elem != &db.snapsRoot {
+		return elem.seq
 	}
-
 	return db.getSeq()
 }
 
@@ -90,12 +97,8 @@ func (db *DB) newSnapshot() *Snapshot {
 	return snap
 }
 
-func (snap *Snapshot) String() string {
-	return fmt.Sprintf("leveldb.Snapshot{%d}", snap.elem.seq)
-}
-
 // Get gets the value for the given key. It returns ErrNotFound if
-// the DB does not contains the key.
+// the DB does not contain the key.
 //
 // The caller should not modify the contents of the returned slice, but
 // it is safe to modify the contents of the argument after Get returns.
@@ -113,23 +116,6 @@ func (snap *Snapshot) Get(key []byte, ro *opt.ReadOptions) (value []byte, err er
 	return snap.db.get(key, snap.elem.seq, ro)
 }
 
-// Has returns true if the DB does contains the given key.
-//
-// It is safe to modify the contents of the argument after Get returns.
-func (snap *Snapshot) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
-	err = snap.db.ok()
-	if err != nil {
-		return
-	}
-	snap.mu.RLock()
-	defer snap.mu.RUnlock()
-	if snap.released {
-		err = ErrSnapshotReleased
-		return
-	}
-	return snap.db.has(key, snap.elem.seq, ro)
-}
-
 // NewIterator returns an iterator for the snapshot of the uderlying DB.
 // The returned iterator is not goroutine-safe, but it is safe to use
 // multiple iterators concurrently, with each in a dedicated goroutine.

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_util.go

@@ -7,7 +7,8 @@
 package leveldb
 
 import (
-	"github.com/syndtr/goleveldb/leveldb/errors"
+	"errors"
+
 	"github.com/syndtr/goleveldb/leveldb/iterator"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 	"github.com/syndtr/goleveldb/leveldb/storage"
@@ -37,9 +38,7 @@ func (db *DB) logf(format string, v ...interface{}) { db.s.logf(format, v...) }
 
 // Check and clean files.
 func (db *DB) checkAndCleanFiles() error {
-	v := db.s.version()
-	defer v.release()
-
+	v := db.s.version_NB()
 	tablesMap := make(map[uint64]bool)
 	for _, tables := range v.tables {
 		for _, t := range tables {
@@ -79,14 +78,12 @@ func (db *DB) checkAndCleanFiles() error {
 	}
 
 	if nTables != len(tablesMap) {
-		var missing []*storage.FileInfo
 		for num, present := range tablesMap {
 			if !present {
-				missing = append(missing, &storage.FileInfo{Type: storage.TypeTable, Num: num})
 				db.logf("db@janitor table missing @%d", num)
 			}
 		}
-		return errors.NewErrCorrupted(nil, &errors.ErrMissingFiles{Files: missing})
+		return ErrCorrupted{Type: MissingFiles, Err: errors.New("leveldb: table files missing")}
 	}
 
 	db.logf("db@janitor F·%d G·%d", len(files), len(rem))

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_write.go

@@ -59,7 +59,7 @@ func (db *DB) rotateMem(n int) (mem *memDB, err error) {
 	}
 
 	// Schedule memdb compaction.
-	db.compSendTrigger(db.mcompCmdC)
+	db.compTrigger(db.mcompTriggerC)
 	return
 }
 
@@ -77,12 +77,12 @@ func (db *DB) flush(n int) (mem *memDB, nn int, err error) {
 		}()
 		nn = mem.mdb.Free()
 		switch {
-		case v.tLen(0) >= db.s.o.GetWriteL0SlowdownTrigger() && !delayed:
+		case v.tLen(0) >= kL0_SlowdownWritesTrigger && !delayed:
 			delayed = true
 			time.Sleep(time.Millisecond)
 		case nn >= n:
 			return false
-		case v.tLen(0) >= db.s.o.GetWriteL0PauseTrigger():
+		case v.tLen(0) >= kL0_StopWritesTrigger:
 			delayed = true
 			err = db.compSendIdle(db.tcompCmdC)
 			if err != nil {
@@ -109,12 +109,7 @@ func (db *DB) flush(n int) (mem *memDB, nn int, err error) {
 	for flush() {
 	}
 	if delayed {
-		db.writeDelay += time.Since(start)
-		db.writeDelayN++
-	} else if db.writeDelayN > 0 {
-		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
-		db.writeDelay = 0
-		db.writeDelayN = 0
+		db.logf("db@write delayed T·%v", time.Since(start))
 	}
 	return
 }
@@ -125,33 +120,28 @@ func (db *DB) flush(n int) (mem *memDB, nn int, err error) {
 // It is safe to modify the contents of the arguments after Write returns.
 func (db *DB) Write(b *Batch, wo *opt.WriteOptions) (err error) {
 	err = db.ok()
-	if err != nil || b == nil || b.Len() == 0 {
+	if err != nil || b == nil || b.len() == 0 {
 		return
 	}
 
 	b.init(wo.GetSync())
 
 	// The write happen synchronously.
+retry:
 	select {
 	case db.writeC <- b:
 		if <-db.writeMergedC {
 			return <-db.writeAckC
 		}
+		goto retry
 	case db.writeLockC <- struct{}{}:
-	case err = <-db.compPerErrC:
-		return
 	case _, _ = <-db.closeC:
 		return ErrClosed
 	}
 
 	merged := 0
-	danglingMerge := false
 	defer func() {
-		if danglingMerge {
-			db.writeMergedC <- false
-		} else {
-			<-db.writeLockC
-		}
+		<-db.writeLockC
 		for i := 0; i < merged; i++ {
 			db.writeAckC <- err
 		}
@@ -180,7 +170,7 @@ drain:
 				db.writeMergedC <- true
 				merged++
 			} else {
-				danglingMerge = true
+				db.writeMergedC <- false
 				break drain
 			}
 		default:
@@ -195,43 +185,35 @@ drain:
 	if b.size() >= (128 << 10) {
 		// Push the write batch to the journal writer
 		select {
-		case db.journalC <- b:
-			// Write into memdb
-			if berr := b.memReplay(mem.mdb); berr != nil {
-				panic(berr)
-			}
-		case err = <-db.compPerErrC:
-			return
 		case _, _ = <-db.closeC:
 			err = ErrClosed
 			return
+		case db.journalC <- b:
+			// Write into memdb
+			b.memReplay(mem.mdb)
 		}
 		// Wait for journal writer
 		select {
-		case err = <-db.journalAckC:
-			if err != nil {
-				// Revert memdb if error detected
-				if berr := b.revertMemReplay(mem.mdb); berr != nil {
-					panic(berr)
-				}
-				return
-			}
 		case _, _ = <-db.closeC:
 			err = ErrClosed
 			return
+		case err = <-db.journalAckC:
+			if err != nil {
+				// Revert memdb if error detected
+				b.revertMemReplay(mem.mdb)
+				return
+			}
 		}
 	} else {
 		err = db.writeJournal(b)
 		if err != nil {
 			return
 		}
-		if berr := b.memReplay(mem.mdb); berr != nil {
-			panic(berr)
-		}
+		b.memReplay(mem.mdb)
 	}
 
 	// Set last seq number.
-	db.addSeq(uint64(b.Len()))
+	db.addSeq(uint64(b.len()))
 
 	if b.size() >= memFree {
 		db.rotateMem(0)
@@ -280,11 +262,8 @@ func (db *DB) CompactRange(r util.Range) error {
 		return err
 	}
 
-	// Lock writer.
 	select {
 	case db.writeLockC <- struct{}{}:
-	case err := <-db.compPerErrC:
-		return err
 	case _, _ = <-db.closeC:
 		return ErrClosed
 	}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/error.go

@@ -7,12 +7,32 @@
 package leveldb
 
 import (
-	"github.com/syndtr/goleveldb/leveldb/errors"
+	"errors"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
 var (
-	ErrNotFound         = errors.ErrNotFound
+	ErrNotFound         = util.ErrNotFound
 	ErrSnapshotReleased = errors.New("leveldb: snapshot released")
 	ErrIterReleased     = errors.New("leveldb: iterator released")
 	ErrClosed           = errors.New("leveldb: closed")
 )
+
+type CorruptionType int
+
+const (
+	CorruptedManifest CorruptionType = iota
+	MissingFiles
+)
+
+// ErrCorrupted is the type that wraps errors that indicate corruption in
+// the database.
+type ErrCorrupted struct {
+	Type CorruptionType
+	Err  error
+}
+
+func (e ErrCorrupted) Error() string {
+	return e.Err.Error()
+}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/errors/errors.go

@@ -1,76 +0,0 @@
-// 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 errors provides common error types used throughout leveldb.
-package errors
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/syndtr/goleveldb/leveldb/storage"
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-var (
-	ErrNotFound    = New("leveldb: not found")
-	ErrReleased    = util.ErrReleased
-	ErrHasReleaser = util.ErrHasReleaser
-)
-
-// New returns an error that formats as the given text.
-func New(text string) error {
-	return errors.New(text)
-}
-
-// ErrCorrupted is the type that wraps errors that indicate corruption in
-// the database.
-type ErrCorrupted struct {
-	File *storage.FileInfo
-	Err  error
-}
-
-func (e *ErrCorrupted) Error() string {
-	if e.File != nil {
-		return fmt.Sprintf("%v [file=%v]", e.Err, e.File)
-	} else {
-		return e.Err.Error()
-	}
-}
-
-// NewErrCorrupted creates new ErrCorrupted error.
-func NewErrCorrupted(f storage.File, err error) error {
-	return &ErrCorrupted{storage.NewFileInfo(f), err}
-}
-
-// IsCorrupted returns a boolean indicating whether the error is indicating
-// a corruption.
-func IsCorrupted(err error) bool {
-	switch err.(type) {
-	case *ErrCorrupted:
-		return true
-	}
-	return false
-}
-
-// ErrMissingFiles is the type that indicating a corruption due to missing
-// files.
-type ErrMissingFiles struct {
-	Files []*storage.FileInfo
-}
-
-func (e *ErrMissingFiles) Error() string { return "file missing" }
-
-// SetFile sets 'file info' of the given error with the given file.
-// Currently only ErrCorrupted is supported, otherwise will do nothing.
-func SetFile(err error, f storage.File) error {
-	switch x := err.(type) {
-	case *ErrCorrupted:
-		x.File = storage.NewFileInfo(f)
-		return x
-	}
-	return err
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/external_test.go

@@ -17,14 +17,13 @@ import (
 var _ = testutil.Defer(func() {
 	Describe("Leveldb external", func() {
 		o := &opt.Options{
-			DisableBlockCache:      true,
-			BlockRestartInterval:   5,
-			BlockSize:              80,
-			Compression:            opt.NoCompression,
-			OpenFilesCacheCapacity: -1,
-			Strict:                 opt.StrictAll,
-			WriteBuffer:            1000,
-			CompactionTableSize:    2000,
+			BlockCache:           opt.NoCache,
+			BlockRestartInterval: 5,
+			BlockSize:            50,
+			Compression:          opt.NoCompression,
+			MaxOpenFiles:         0,
+			Strict:               opt.StrictAll,
+			WriteBuffer:          1000,
 		}
 
 		Describe("write test", func() {
@@ -41,17 +40,18 @@ var _ = testutil.Defer(func() {
 		})
 
 		Describe("read test", func() {
-			testutil.AllKeyValueTesting(nil, nil, func(kv testutil.KeyValue) testutil.DB {
+			testutil.AllKeyValueTesting(nil, func(kv testutil.KeyValue) testutil.DB {
 				// Building the DB.
 				db := newTestingDB(o, nil, nil)
 				kv.IterateShuffled(nil, func(i int, key, value []byte) {
 					err := db.TestPut(key, value)
 					Expect(err).NotTo(HaveOccurred())
 				})
+				testutil.Defer("teardown", func() {
+					db.TestClose()
+				})
 
 				return db
-			}, func(db testutil.DB) {
-				db.(*testingDB).TestClose()
 			})
 		})
 	})

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/array_iter.go

@@ -40,19 +40,13 @@ type basicArrayIterator struct {
 	util.BasicReleaser
 	array BasicArray
 	pos   int
-	err   error
 }
 
 func (i *basicArrayIterator) Valid() bool {
-	return i.pos >= 0 && i.pos < i.array.Len() && !i.Released()
+	return i.pos >= 0 && i.pos < i.array.Len()
 }
 
 func (i *basicArrayIterator) First() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
-		return false
-	}
-
 	if i.array.Len() == 0 {
 		i.pos = -1
 		return false
@@ -62,11 +56,6 @@ func (i *basicArrayIterator) First() bool {
 }
 
 func (i *basicArrayIterator) Last() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
-		return false
-	}
-
 	n := i.array.Len()
 	if n == 0 {
 		i.pos = 0
@@ -77,11 +66,6 @@ func (i *basicArrayIterator) Last() bool {
 }
 
 func (i *basicArrayIterator) Seek(key []byte) bool {
-	if i.Released() {
-		i.err = ErrIterReleased
-		return false
-	}
-
 	n := i.array.Len()
 	if n == 0 {
 		i.pos = 0
@@ -95,11 +79,6 @@ func (i *basicArrayIterator) Seek(key []byte) bool {
 }
 
 func (i *basicArrayIterator) Next() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
-		return false
-	}
-
 	i.pos++
 	if n := i.array.Len(); i.pos >= n {
 		i.pos = n
@@ -109,11 +88,6 @@ func (i *basicArrayIterator) Next() bool {
 }
 
 func (i *basicArrayIterator) Prev() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
-		return false
-	}
-
 	i.pos--
 	if i.pos < 0 {
 		i.pos = -1
@@ -122,7 +96,7 @@ func (i *basicArrayIterator) Prev() bool {
 	return true
 }
 
-func (i *basicArrayIterator) Error() error { return i.err }
+func (i *basicArrayIterator) Error() error { return nil }
 
 type arrayIterator struct {
 	basicArrayIterator

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter.go

@@ -7,7 +7,6 @@
 package iterator
 
 import (
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
@@ -23,13 +22,13 @@ type IteratorIndexer interface {
 
 type indexedIterator struct {
 	util.BasicReleaser
-	index  IteratorIndexer
-	strict bool
+	index     IteratorIndexer
+	strict    bool
+	strictGet bool
 
-	data   Iterator
-	err    error
-	errf   func(err error)
-	closed bool
+	data Iterator
+	err  error
+	errf func(err error)
 }
 
 func (i *indexedIterator) setData() {
@@ -37,6 +36,11 @@ func (i *indexedIterator) setData() {
 		i.data.Release()
 	}
 	i.data = i.index.Get()
+	if i.strictGet {
+		if err := i.data.Error(); err != nil {
+			i.err = err
+		}
+	}
 }
 
 func (i *indexedIterator) clearData() {
@@ -46,21 +50,14 @@ func (i *indexedIterator) clearData() {
 	i.data = nil
 }
 
-func (i *indexedIterator) indexErr() {
-	if err := i.index.Error(); err != nil {
-		if i.errf != nil {
-			i.errf(err)
-		}
-		i.err = err
-	}
-}
-
 func (i *indexedIterator) dataErr() bool {
-	if err := i.data.Error(); err != nil {
-		if i.errf != nil {
+	if i.errf != nil {
+		if err := i.data.Error(); err != nil {
 			i.errf(err)
 		}
-		if i.strict || !errors.IsCorrupted(err) {
+	}
+	if i.strict {
+		if err := i.data.Error(); err != nil {
 			i.err = err
 			return true
 		}
@@ -75,13 +72,9 @@ func (i *indexedIterator) Valid() bool {
 func (i *indexedIterator) First() bool {
 	if i.err != nil {
 		return false
-	} else if i.Released() {
-		i.err = ErrIterReleased
-		return false
 	}
 
 	if !i.index.First() {
-		i.indexErr()
 		i.clearData()
 		return false
 	}
@@ -92,13 +85,9 @@ func (i *indexedIterator) First() bool {
 func (i *indexedIterator) Last() bool {
 	if i.err != nil {
 		return false
-	} else if i.Released() {
-		i.err = ErrIterReleased
-		return false
 	}
 
 	if !i.index.Last() {
-		i.indexErr()
 		i.clearData()
 		return false
 	}
@@ -116,13 +105,9 @@ func (i *indexedIterator) Last() bool {
 func (i *indexedIterator) Seek(key []byte) bool {
 	if i.err != nil {
 		return false
-	} else if i.Released() {
-		i.err = ErrIterReleased
-		return false
 	}
 
 	if !i.index.Seek(key) {
-		i.indexErr()
 		i.clearData()
 		return false
 	}
@@ -140,9 +125,6 @@ func (i *indexedIterator) Seek(key []byte) bool {
 func (i *indexedIterator) Next() bool {
 	if i.err != nil {
 		return false
-	} else if i.Released() {
-		i.err = ErrIterReleased
-		return false
 	}
 
 	switch {
@@ -154,7 +136,6 @@ func (i *indexedIterator) Next() bool {
 		fallthrough
 	case i.data == nil:
 		if !i.index.Next() {
-			i.indexErr()
 			return false
 		}
 		i.setData()
@@ -166,9 +147,6 @@ func (i *indexedIterator) Next() bool {
 func (i *indexedIterator) Prev() bool {
 	if i.err != nil {
 		return false
-	} else if i.Released() {
-		i.err = ErrIterReleased
-		return false
 	}
 
 	switch {
@@ -180,7 +158,6 @@ func (i *indexedIterator) Prev() bool {
 		fallthrough
 	case i.data == nil:
 		if !i.index.Prev() {
-			i.indexErr()
 			return false
 		}
 		i.setData()
@@ -229,14 +206,16 @@ func (i *indexedIterator) SetErrorCallback(f func(err error)) {
 	i.errf = f
 }
 
-// NewIndexedIterator returns an 'indexed iterator'. An index is iterator
-// that returns another iterator, a 'data iterator'. A 'data iterator' is the
+// NewIndexedIterator returns an indexed iterator. An index is iterator
+// that returns another iterator, a data iterator. A data iterator is the
 // iterator that contains actual key/value pairs.
 //
-// If strict is true the any 'corruption errors' (i.e errors.IsCorrupted(err) == true)
-// won't be ignored and will halt 'indexed iterator', otherwise the iterator will
-// continue to the next 'data iterator'. Corruption on 'index iterator' will not be
-// ignored and will halt the iterator.
-func NewIndexedIterator(index IteratorIndexer, strict bool) Iterator {
-	return &indexedIterator{index: index, strict: strict}
+// If strict is true then error yield by data iterator will halt the indexed
+// iterator, on contrary if strict is false then the indexed iterator will
+// ignore those error and move on to the next index. If strictGet is true and
+// index.Get() yield an 'error iterator' then the indexed iterator will be halted.
+// An 'error iterator' is iterator which its Error() method always return non-nil
+// even before any 'seeks method' is called.
+func NewIndexedIterator(index IteratorIndexer, strict, strictGet bool) Iterator {
+	return &indexedIterator{index: index, strict: strict, strictGet: strictGet}
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/indexed_iter_test.go

@@ -65,7 +65,7 @@ var _ = testutil.Defer(func() {
 					// Test the iterator.
 					t := testutil.IteratorTesting{
 						KeyValue: kv.Clone(),
-						Iter:     NewIndexedIterator(NewArrayIndexer(index), true),
+						Iter:     NewIndexedIterator(NewArrayIndexer(index), true, true),
 					}
 					testutil.DoIteratorTesting(&t)
 					done <- true

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter.go

@@ -14,10 +14,6 @@ import (
 	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
-var (
-	ErrIterReleased = errors.New("leveldb/iterator: iterator released")
-)
-
 // IteratorSeeker is the interface that wraps the 'seeks method'.
 type IteratorSeeker interface {
 	// First moves the iterator to the first key/value pair. If the iterator
@@ -104,13 +100,28 @@ type ErrorCallbackSetter interface {
 }
 
 type emptyIterator struct {
-	util.BasicReleaser
-	err error
+	releaser util.Releaser
+	released bool
+	err      error
 }
 
 func (i *emptyIterator) rErr() {
-	if i.err == nil && i.Released() {
-		i.err = ErrIterReleased
+	if i.err == nil && i.released {
+		i.err = errors.New("leveldb/iterator: iterator released")
+	}
+}
+
+func (i *emptyIterator) Release() {
+	if i.releaser != nil {
+		i.releaser.Release()
+		i.releaser = nil
+	}
+	i.released = true
+}
+
+func (i *emptyIterator) SetReleaser(releaser util.Releaser) {
+	if !i.released {
+		i.releaser = releaser
 	}
 }
 

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/iter_suite_test.go

@@ -3,9 +3,15 @@ package iterator_test
 import (
 	"testing"
 
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
 	"github.com/syndtr/goleveldb/leveldb/testutil"
 )
 
 func TestIterator(t *testing.T) {
-	testutil.RunSuite(t, "Iterator Suite")
+	testutil.RunDefer()
+
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Iterator Suite")
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/iterator/merged_iter.go

@@ -7,11 +7,16 @@
 package iterator
 
 import (
+	"errors"
+
 	"github.com/syndtr/goleveldb/leveldb/comparer"
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
+var (
+	ErrIterReleased = errors.New("leveldb/iterator: iterator released")
+)
+
 type dir int
 
 const (
@@ -43,11 +48,13 @@ func assertKey(key []byte) []byte {
 }
 
 func (i *mergedIterator) iterErr(iter Iterator) bool {
-	if err := iter.Error(); err != nil {
-		if i.errf != nil {
+	if i.errf != nil {
+		if err := iter.Error(); err != nil {
 			i.errf(err)
 		}
-		if i.strict || !errors.IsCorrupted(err) {
+	}
+	if i.strict {
+		if err := iter.Error(); err != nil {
 			i.err = err
 			return true
 		}
@@ -267,13 +274,9 @@ func (i *mergedIterator) Release() {
 }
 
 func (i *mergedIterator) SetReleaser(releaser util.Releaser) {
-	if i.dir == dirReleased {
-		panic(util.ErrReleased)
+	if i.dir != dirReleased {
+		i.releaser = releaser
 	}
-	if i.releaser != nil && releaser != nil {
-		panic(util.ErrHasReleaser)
-	}
-	i.releaser = releaser
 }
 
 func (i *mergedIterator) Error() error {
@@ -291,9 +294,9 @@ func (i *mergedIterator) SetErrorCallback(f func(err error)) {
 // keys: if iters[i] contains a key k then iters[j] will not contain that key k.
 // None of the iters may be nil.
 //
-// If strict is true the any 'corruption errors' (i.e errors.IsCorrupted(err) == true)
-// won't be ignored and will halt 'merged iterator', otherwise the iterator will
-// continue to the next 'input iterator'.
+// If strict is true then error yield by any iterators will halt the merged
+// iterator, on contrary if strict is false then the merged iterator will
+// ignore those error and move on to the next iterator.
 func NewMergedIterator(iters []Iterator, cmp comparer.Comparer, strict bool) Iterator {
 	return &mergedIterator{
 		iters:  iters,

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/journal/journal.go

@@ -79,10 +79,10 @@ package journal
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
@@ -109,7 +109,7 @@ type ErrCorrupted struct {
 	Reason string
 }
 
-func (e *ErrCorrupted) Error() string {
+func (e ErrCorrupted) Error() string {
 	return fmt.Sprintf("leveldb/journal: block/chunk corrupted: %s (%d bytes)", e.Reason, e.Size)
 }
 
@@ -162,10 +162,10 @@ var errSkip = errors.New("leveldb/journal: skipped")
 
 func (r *Reader) corrupt(n int, reason string, skip bool) error {
 	if r.dropper != nil {
-		r.dropper.Drop(&ErrCorrupted{n, reason})
+		r.dropper.Drop(ErrCorrupted{n, reason})
 	}
 	if r.strict && !skip {
-		r.err = errors.NewErrCorrupted(nil, &ErrCorrupted{n, reason})
+		r.err = ErrCorrupted{n, reason}
 		return r.err
 	}
 	return errSkip

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key.go

@@ -9,30 +9,15 @@ package leveldb
 import (
 	"encoding/binary"
 	"fmt"
-
-	"github.com/syndtr/goleveldb/leveldb/errors"
 )
 
-type ErrIkeyCorrupted struct {
-	Ikey   []byte
-	Reason string
-}
+type vType int
 
-func (e *ErrIkeyCorrupted) Error() string {
-	return fmt.Sprintf("leveldb: iKey %q corrupted: %s", e.Ikey, e.Reason)
-}
-
-func newErrIkeyCorrupted(ikey []byte, reason string) error {
-	return errors.NewErrCorrupted(nil, &ErrIkeyCorrupted{append([]byte{}, ikey...), reason})
-}
-
-type kType int
-
-func (kt kType) String() string {
-	switch kt {
-	case ktDel:
+func (t vType) String() string {
+	switch t {
+	case tDel:
 		return "d"
-	case ktVal:
+	case tVal:
 		return "v"
 	}
 	return "x"
@@ -41,16 +26,16 @@ func (kt kType) String() string {
 // Value types encoded as the last component of internal keys.
 // Don't modify; this value are saved to disk.
 const (
-	ktDel kType = iota
-	ktVal
+	tDel vType = iota
+	tVal
 )
 
-// ktSeek defines the kType that should be passed when constructing an
+// tSeek defines the vType that should be passed when constructing an
 // internal key for seeking to a particular sequence number (since we
 // sort sequence numbers in decreasing order and the value type is
 // embedded as the low 8 bits in the sequence number in internal keys,
 // we need to use the highest-numbered ValueType, not the lowest).
-const ktSeek = ktVal
+const tSeek = tVal
 
 const (
 	// Maximum value possible for sequence number; the 8-bits are
@@ -58,7 +43,7 @@ const (
 	// 64-bit integer.
 	kMaxSeq uint64 = (uint64(1) << 56) - 1
 	// Maximum value possible for packed sequence number and type.
-	kMaxNum uint64 = (kMaxSeq << 8) | uint64(ktSeek)
+	kMaxNum uint64 = (kMaxSeq << 8) | uint64(tSeek)
 )
 
 // Maximum number encoded in bytes.
@@ -70,73 +55,85 @@ func init() {
 
 type iKey []byte
 
-func newIkey(ukey []byte, seq uint64, kt kType) iKey {
-	if seq > kMaxSeq {
-		panic("leveldb: invalid sequence number")
-	} else if kt > ktVal {
-		panic("leveldb: invalid type")
+func newIKey(ukey []byte, seq uint64, t vType) iKey {
+	if seq > kMaxSeq || t > tVal {
+		panic("invalid seq number or value type")
 	}
 
-	ik := make(iKey, len(ukey)+8)
-	copy(ik, ukey)
-	binary.LittleEndian.PutUint64(ik[len(ukey):], (seq<<8)|uint64(kt))
-	return ik
+	b := make(iKey, len(ukey)+8)
+	copy(b, ukey)
+	binary.LittleEndian.PutUint64(b[len(ukey):], (seq<<8)|uint64(t))
+	return b
 }
 
-func parseIkey(ik []byte) (ukey []byte, seq uint64, kt kType, err error) {
-	if len(ik) < 8 {
-		return nil, 0, 0, newErrIkeyCorrupted(ik, "invalid length")
+func parseIkey(p []byte) (ukey []byte, seq uint64, t vType, ok bool) {
+	if len(p) < 8 {
+		return
 	}
-	num := binary.LittleEndian.Uint64(ik[len(ik)-8:])
-	seq, kt = uint64(num>>8), kType(num&0xff)
-	if kt > ktVal {
-		return nil, 0, 0, newErrIkeyCorrupted(ik, "invalid type")
+	num := binary.LittleEndian.Uint64(p[len(p)-8:])
+	seq, t = uint64(num>>8), vType(num&0xff)
+	if t > tVal {
+		return
 	}
-	ukey = ik[:len(ik)-8]
+	ukey = p[:len(p)-8]
+	ok = true
 	return
 }
 
-func validIkey(ik []byte) bool {
-	_, _, _, err := parseIkey(ik)
-	return err == nil
+func validIkey(p []byte) bool {
+	_, _, _, ok := parseIkey(p)
+	return ok
 }
 
-func (ik iKey) assert() {
-	if ik == nil {
-		panic("leveldb: nil iKey")
+func (p iKey) assert() {
+	if p == nil {
+		panic("nil iKey")
 	}
-	if len(ik) < 8 {
-		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", []byte(ik), len(ik)))
+	if len(p) < 8 {
+		panic(fmt.Sprintf("invalid iKey %q, len=%d", []byte(p), len(p)))
 	}
 }
 
-func (ik iKey) ukey() []byte {
-	ik.assert()
-	return ik[:len(ik)-8]
-}
-
-func (ik iKey) num() uint64 {
-	ik.assert()
-	return binary.LittleEndian.Uint64(ik[len(ik)-8:])
-}
-
-func (ik iKey) parseNum() (seq uint64, kt kType) {
-	num := ik.num()
-	seq, kt = uint64(num>>8), kType(num&0xff)
-	if kt > ktVal {
-		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", []byte(ik), len(ik), kt))
+func (p iKey) ok() bool {
+	if len(p) < 8 {
+		return false
 	}
+	_, _, ok := p.parseNum()
+	return ok
+}
+
+func (p iKey) ukey() []byte {
+	p.assert()
+	return p[:len(p)-8]
+}
+
+func (p iKey) num() uint64 {
+	p.assert()
+	return binary.LittleEndian.Uint64(p[len(p)-8:])
+}
+
+func (p iKey) parseNum() (seq uint64, t vType, ok bool) {
+	if p == nil {
+		panic("nil iKey")
+	}
+	if len(p) < 8 {
+		return
+	}
+	num := p.num()
+	seq, t = uint64(num>>8), vType(num&0xff)
+	if t > tVal {
+		return 0, 0, false
+	}
+	ok = true
 	return
 }
 
-func (ik iKey) String() string {
-	if ik == nil {
+func (p iKey) String() string {
+	if len(p) == 0 {
 		return "<nil>"
 	}
-
-	if ukey, seq, kt, err := parseIkey(ik); err == nil {
-		return fmt.Sprintf("%s,%s%d", shorten(string(ukey)), kt, seq)
-	} else {
-		return "<invalid>"
+	if seq, t, ok := p.parseNum(); ok {
+		return fmt.Sprintf("%s,%s%d", shorten(string(p.ukey())), t, seq)
 	}
+	return "<invalid>"
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key_test.go

@@ -15,8 +15,8 @@ import (
 
 var defaultIComparer = &iComparer{comparer.DefaultComparer}
 
-func ikey(key string, seq uint64, kt kType) iKey {
-	return newIkey([]byte(key), uint64(seq), kt)
+func ikey(key string, seq uint64, t vType) iKey {
+	return newIKey([]byte(key), uint64(seq), t)
 }
 
 func shortSep(a, b []byte) []byte {
@@ -37,37 +37,27 @@ func shortSuccessor(b []byte) []byte {
 	return dst
 }
 
-func testSingleKey(t *testing.T, key string, seq uint64, kt kType) {
-	ik := ikey(key, seq, kt)
+func testSingleKey(t *testing.T, key string, seq uint64, vt vType) {
+	ik := ikey(key, seq, vt)
 
 	if !bytes.Equal(ik.ukey(), []byte(key)) {
 		t.Errorf("user key does not equal, got %v, want %v", string(ik.ukey()), key)
 	}
 
-	rseq, rt := ik.parseNum()
-	if rseq != seq {
-		t.Errorf("seq number does not equal, got %v, want %v", rseq, seq)
-	}
-	if rt != kt {
-		t.Errorf("type does not equal, got %v, want %v", rt, kt)
-	}
-
-	if rukey, rseq, rt, kerr := parseIkey(ik); kerr == nil {
-		if !bytes.Equal(rukey, []byte(key)) {
-			t.Errorf("user key does not equal, got %v, want %v", string(ik.ukey()), key)
-		}
+	if rseq, rt, ok := ik.parseNum(); ok {
 		if rseq != seq {
 			t.Errorf("seq number does not equal, got %v, want %v", rseq, seq)
 		}
-		if rt != kt {
-			t.Errorf("type does not equal, got %v, want %v", rt, kt)
+
+		if rt != vt {
+			t.Errorf("type does not equal, got %v, want %v", rt, vt)
 		}
 	} else {
-		t.Errorf("key error: %v", kerr)
+		t.Error("cannot parse seq and type")
 	}
 }
 
-func TestIkey_EncodeDecode(t *testing.T) {
+func TestIKey_EncodeDecode(t *testing.T) {
 	keys := []string{"", "k", "hello", "longggggggggggggggggggggg"}
 	seqs := []uint64{
 		1, 2, 3,
@@ -77,8 +67,8 @@ func TestIkey_EncodeDecode(t *testing.T) {
 	}
 	for _, key := range keys {
 		for _, seq := range seqs {
-			testSingleKey(t, key, seq, ktVal)
-			testSingleKey(t, "hello", 1, ktDel)
+			testSingleKey(t, key, seq, tVal)
+			testSingleKey(t, "hello", 1, tDel)
 		}
 	}
 }
@@ -89,45 +79,45 @@ func assertBytes(t *testing.T, want, got []byte) {
 	}
 }
 
-func TestIkeyShortSeparator(t *testing.T) {
+func TestIKeyShortSeparator(t *testing.T) {
 	// When user keys are same
-	assertBytes(t, ikey("foo", 100, ktVal),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("foo", 99, ktVal)))
-	assertBytes(t, ikey("foo", 100, ktVal),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("foo", 101, ktVal)))
-	assertBytes(t, ikey("foo", 100, ktVal),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("foo", 100, ktVal)))
-	assertBytes(t, ikey("foo", 100, ktVal),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("foo", 100, ktDel)))
+	assertBytes(t, ikey("foo", 100, tVal),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("foo", 99, tVal)))
+	assertBytes(t, ikey("foo", 100, tVal),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("foo", 101, tVal)))
+	assertBytes(t, ikey("foo", 100, tVal),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("foo", 100, tVal)))
+	assertBytes(t, ikey("foo", 100, tVal),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("foo", 100, tDel)))
 
 	// When user keys are misordered
-	assertBytes(t, ikey("foo", 100, ktVal),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("bar", 99, ktVal)))
+	assertBytes(t, ikey("foo", 100, tVal),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("bar", 99, tVal)))
 
 	// When user keys are different, but correctly ordered
-	assertBytes(t, ikey("g", uint64(kMaxSeq), ktSeek),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("hello", 200, ktVal)))
+	assertBytes(t, ikey("g", uint64(kMaxSeq), tSeek),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("hello", 200, tVal)))
 
 	// When start user key is prefix of limit user key
-	assertBytes(t, ikey("foo", 100, ktVal),
-		shortSep(ikey("foo", 100, ktVal),
-			ikey("foobar", 200, ktVal)))
+	assertBytes(t, ikey("foo", 100, tVal),
+		shortSep(ikey("foo", 100, tVal),
+			ikey("foobar", 200, tVal)))
 
 	// When limit user key is prefix of start user key
-	assertBytes(t, ikey("foobar", 100, ktVal),
-		shortSep(ikey("foobar", 100, ktVal),
-			ikey("foo", 200, ktVal)))
+	assertBytes(t, ikey("foobar", 100, tVal),
+		shortSep(ikey("foobar", 100, tVal),
+			ikey("foo", 200, tVal)))
 }
 
-func TestIkeyShortestSuccessor(t *testing.T) {
-	assertBytes(t, ikey("g", uint64(kMaxSeq), ktSeek),
-		shortSuccessor(ikey("foo", 100, ktVal)))
-	assertBytes(t, ikey("\xff\xff", 100, ktVal),
-		shortSuccessor(ikey("\xff\xff", 100, ktVal)))
+func TestIKeyShortestSuccessor(t *testing.T) {
+	assertBytes(t, ikey("g", uint64(kMaxSeq), tSeek),
+		shortSuccessor(ikey("foo", 100, tVal)))
+	assertBytes(t, ikey("\xff\xff", 100, tVal),
+		shortSuccessor(ikey("\xff\xff", 100, tVal)))
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/leveldb_suite_test.go

@@ -3,9 +3,18 @@ package leveldb
 import (
 	"testing"
 
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
 	"github.com/syndtr/goleveldb/leveldb/testutil"
 )
 
-func TestLevelDB(t *testing.T) {
-	testutil.RunSuite(t, "LevelDB Suite")
+func TestLeveldb(t *testing.T) {
+	testutil.RunDefer()
+
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Leveldb Suite")
+
+	RegisterTestingT(t)
+	testutil.RunDefer("teardown")
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb.go

@@ -12,14 +12,12 @@ import (
 	"sync"
 
 	"github.com/syndtr/goleveldb/leveldb/comparer"
-	"github.com/syndtr/goleveldb/leveldb/errors"
 	"github.com/syndtr/goleveldb/leveldb/iterator"
 	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
 var (
-	ErrNotFound     = errors.ErrNotFound
-	ErrIterReleased = errors.New("leveldb/memdb: iterator released")
+	ErrNotFound = util.ErrNotFound
 )
 
 const tMaxHeight = 12
@@ -31,7 +29,6 @@ type dbIter struct {
 	node       int
 	forward    bool
 	key, value []byte
-	err        error
 }
 
 func (i *dbIter) fill(checkStart, checkLimit bool) bool {
@@ -62,11 +59,6 @@ func (i *dbIter) Valid() bool {
 }
 
 func (i *dbIter) First() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
-		return false
-	}
-
 	i.forward = true
 	i.p.mu.RLock()
 	defer i.p.mu.RUnlock()
@@ -79,11 +71,9 @@ func (i *dbIter) First() bool {
 }
 
 func (i *dbIter) Last() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
+	if i.p == nil {
 		return false
 	}
-
 	i.forward = false
 	i.p.mu.RLock()
 	defer i.p.mu.RUnlock()
@@ -96,11 +86,9 @@ func (i *dbIter) Last() bool {
 }
 
 func (i *dbIter) Seek(key []byte) bool {
-	if i.Released() {
-		i.err = ErrIterReleased
+	if i.p == nil {
 		return false
 	}
-
 	i.forward = true
 	i.p.mu.RLock()
 	defer i.p.mu.RUnlock()
@@ -112,11 +100,9 @@ func (i *dbIter) Seek(key []byte) bool {
 }
 
 func (i *dbIter) Next() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
+	if i.p == nil {
 		return false
 	}
-
 	if i.node == 0 {
 		if !i.forward {
 			return i.First()
@@ -131,11 +117,9 @@ func (i *dbIter) Next() bool {
 }
 
 func (i *dbIter) Prev() bool {
-	if i.Released() {
-		i.err = ErrIterReleased
+	if i.p == nil {
 		return false
 	}
-
 	if i.node == 0 {
 		if i.forward {
 			return i.Last()
@@ -157,10 +141,10 @@ func (i *dbIter) Value() []byte {
 	return i.value
 }
 
-func (i *dbIter) Error() error { return i.err }
+func (i *dbIter) Error() error { return nil }
 
 func (i *dbIter) Release() {
-	if !i.Released() {
+	if i.p != nil {
 		i.p = nil
 		i.node = 0
 		i.key = nil

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_suite_test.go

@@ -3,9 +3,15 @@ package memdb
 import (
 	"testing"
 
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
 	"github.com/syndtr/goleveldb/leveldb/testutil"
 )
 
-func TestMemDB(t *testing.T) {
-	testutil.RunSuite(t, "MemDB Suite")
+func TestMemdb(t *testing.T) {
+	testutil.RunDefer()
+
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Memdb Suite")
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/memdb/memdb_test.go

@@ -129,7 +129,7 @@ var _ = testutil.Defer(func() {
 				}
 
 				return db
-			}, nil, nil)
+			})
 		})
 	})
 })

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt/options.go

@@ -11,7 +11,6 @@ import (
 	"github.com/syndtr/goleveldb/leveldb/cache"
 	"github.com/syndtr/goleveldb/leveldb/comparer"
 	"github.com/syndtr/goleveldb/leveldb/filter"
-	"math"
 )
 
 const (
@@ -20,56 +19,31 @@ const (
 	GiB = MiB * 1024
 )
 
-var (
-	DefaultBlockCacher                   = LRUCacher
-	DefaultBlockCacheCapacity            = 8 * MiB
-	DefaultBlockRestartInterval          = 16
-	DefaultBlockSize                     = 4 * KiB
-	DefaultCompactionExpandLimitFactor   = 25
-	DefaultCompactionGPOverlapsFactor    = 10
-	DefaultCompactionL0Trigger           = 4
-	DefaultCompactionSourceLimitFactor   = 1
-	DefaultCompactionTableSize           = 2 * MiB
-	DefaultCompactionTableSizeMultiplier = 1.0
-	DefaultCompactionTotalSize           = 10 * MiB
-	DefaultCompactionTotalSizeMultiplier = 10.0
-	DefaultCompressionType               = SnappyCompression
-	DefaultOpenFilesCacher               = LRUCacher
-	DefaultOpenFilesCacheCapacity        = 500
-	DefaultMaxMemCompationLevel          = 2
-	DefaultNumLevel                      = 7
-	DefaultWriteBuffer                   = 4 * MiB
-	DefaultWriteL0PauseTrigger           = 12
-	DefaultWriteL0SlowdownTrigger        = 8
+const (
+	DefaultBlockCacheSize       = 8 * MiB
+	DefaultBlockRestartInterval = 16
+	DefaultBlockSize            = 4 * KiB
+	DefaultCompressionType      = SnappyCompression
+	DefaultMaxOpenFiles         = 1000
+	DefaultWriteBuffer          = 4 * MiB
 )
 
-// Cacher is a caching algorithm.
-type Cacher interface {
-	New(capacity int) cache.Cacher
-}
+type noCache struct{}
 
-type CacherFunc struct {
-	NewFunc func(capacity int) cache.Cacher
-}
+func (noCache) SetCapacity(capacity int)                     {}
+func (noCache) Capacity() int                                { return 0 }
+func (noCache) Used() int                                    { return 0 }
+func (noCache) Size() int                                    { return 0 }
+func (noCache) NumObjects() int                              { return 0 }
+func (noCache) GetNamespace(id uint64) cache.Namespace       { return nil }
+func (noCache) PurgeNamespace(id uint64, fin cache.PurgeFin) {}
+func (noCache) ZapNamespace(id uint64)                       {}
+func (noCache) Purge(fin cache.PurgeFin)                     {}
+func (noCache) Zap()                                         {}
 
-func (f *CacherFunc) New(capacity int) cache.Cacher {
-	if f.NewFunc != nil {
-		return f.NewFunc(capacity)
-	}
-	return nil
-}
+var NoCache cache.Cache = noCache{}
 
-func noCacher(int) cache.Cacher { return nil }
-
-var (
-	// LRUCacher is the LRU-cache algorithm.
-	LRUCacher = &CacherFunc{cache.NewLRU}
-
-	// NoCacher is the value to disable caching algorithm.
-	NoCacher = &CacherFunc{}
-)
-
-// Compression is the 'sorted table' block compression algorithm to use.
+// Compression is the per-block compression algorithm to use.
 type Compression uint
 
 func (c Compression) String() string {
@@ -91,47 +65,34 @@ const (
 	nCompression
 )
 
-// Strict is the DB 'strict level'.
+// Strict is the DB strict level.
 type Strict uint
 
 const (
 	// If present then a corrupted or invalid chunk or block in manifest
-	// journal will cause an error instead of being dropped.
-	// This will prevent database with corrupted manifest to be opened.
+	// journal will cause an error istead of being dropped.
 	StrictManifest Strict = 1 << iota
 
+	// If present then a corrupted or invalid chunk or block in journal
+	// will cause an error istead of being dropped.
+	StrictJournal
+
 	// If present then journal chunk checksum will be verified.
 	StrictJournalChecksum
 
-	// If present then a corrupted or invalid chunk or block in journal
-	// will cause an error instead of being dropped.
-	// This will prevent database with corrupted journal to be opened.
-	StrictJournal
+	// If present then an invalid key/value pair will cause an error
+	// instead of being skipped.
+	StrictIterator
 
 	// If present then 'sorted table' block checksum will be verified.
-	// This has effect on both 'read operation' and compaction.
 	StrictBlockChecksum
 
-	// If present then a corrupted 'sorted table' will fails compaction.
-	// The database will enter read-only mode.
-	StrictCompaction
-
-	// If present then a corrupted 'sorted table' will halts 'read operation'.
-	StrictReader
-
-	// If present then leveldb.Recover will drop corrupted 'sorted table'.
-	StrictRecovery
-
-	// This only applicable for ReadOptions, if present then this ReadOptions
-	// 'strict level' will override global ones.
-	StrictOverride
-
 	// StrictAll enables all strict flags.
-	StrictAll = StrictManifest | StrictJournalChecksum | StrictJournal | StrictBlockChecksum | StrictCompaction | StrictReader | StrictRecovery
+	StrictAll = StrictManifest | StrictJournal | StrictJournalChecksum | StrictIterator | StrictBlockChecksum
 
 	// DefaultStrict is the default strict flags. Specify any strict flags
 	// will override default strict flags as whole (i.e. not OR'ed).
-	DefaultStrict = StrictJournalChecksum | StrictBlockChecksum | StrictCompaction | StrictReader
+	DefaultStrict = StrictJournalChecksum | StrictBlockChecksum
 
 	// NoStrict disables all strict flags. Override default strict flags.
 	NoStrict = ^StrictAll
@@ -146,17 +107,11 @@ type Options struct {
 	// The default value is nil
 	AltFilters []filter.Filter
 
-	// BlockCacher provides cache algorithm for LevelDB 'sorted table' block caching.
-	// Specify NoCacher to disable caching algorithm.
+	// BlockCache provides per-block caching for LevelDB. Specify NoCache to
+	// disable block caching.
 	//
-	// The default value is LRUCacher.
-	BlockCacher Cacher
-
-	// BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
-	// Use -1 for zero, this has same effect with specifying NoCacher to BlockCacher.
-	//
-	// The default value is 8MiB.
-	BlockCacheCapacity int
+	// By default LevelDB will create LRU-cache with capacity of 8MiB.
+	BlockCache cache.Cache
 
 	// BlockRestartInterval is the number of keys between restart points for
 	// delta encoding of keys.
@@ -170,73 +125,6 @@ type Options struct {
 	// The default value is 4KiB.
 	BlockSize int
 
-	// CompactionExpandLimitFactor limits compaction size after expanded.
-	// This will be multiplied by table size limit at compaction target level.
-	//
-	// The default value is 25.
-	CompactionExpandLimitFactor int
-
-	// CompactionGPOverlapsFactor limits overlaps in grandparent (Level + 2) that a
-	// single 'sorted table' generates.
-	// This will be multiplied by table size limit at grandparent level.
-	//
-	// The default value is 10.
-	CompactionGPOverlapsFactor int
-
-	// CompactionL0Trigger defines number of 'sorted table' at level-0 that will
-	// trigger compaction.
-	//
-	// The default value is 4.
-	CompactionL0Trigger int
-
-	// CompactionSourceLimitFactor limits compaction source size. This doesn't apply to
-	// level-0.
-	// This will be multiplied by table size limit at compaction target level.
-	//
-	// The default value is 1.
-	CompactionSourceLimitFactor int
-
-	// CompactionTableSize limits size of 'sorted table' that compaction generates.
-	// The limits for each level will be calculated as:
-	//   CompactionTableSize * (CompactionTableSizeMultiplier ^ Level)
-	// The multiplier for each level can also fine-tuned using CompactionTableSizeMultiplierPerLevel.
-	//
-	// The default value is 2MiB.
-	CompactionTableSize int
-
-	// CompactionTableSizeMultiplier defines multiplier for CompactionTableSize.
-	//
-	// The default value is 1.
-	CompactionTableSizeMultiplier float64
-
-	// CompactionTableSizeMultiplierPerLevel defines per-level multiplier for
-	// CompactionTableSize.
-	// Use zero to skip a level.
-	//
-	// The default value is nil.
-	CompactionTableSizeMultiplierPerLevel []float64
-
-	// CompactionTotalSize limits total size of 'sorted table' for each level.
-	// The limits for each level will be calculated as:
-	//   CompactionTotalSize * (CompactionTotalSizeMultiplier ^ Level)
-	// The multiplier for each level can also fine-tuned using
-	// CompactionTotalSizeMultiplierPerLevel.
-	//
-	// The default value is 10MiB.
-	CompactionTotalSize int
-
-	// CompactionTotalSizeMultiplier defines multiplier for CompactionTotalSize.
-	//
-	// The default value is 10.
-	CompactionTotalSizeMultiplier float64
-
-	// CompactionTotalSizeMultiplierPerLevel defines per-level multiplier for
-	// CompactionTotalSize.
-	// Use zero to skip a level.
-	//
-	// The default value is nil.
-	CompactionTotalSizeMultiplierPerLevel []float64
-
 	// Comparer defines a total ordering over the space of []byte keys: a 'less
 	// than' relationship. The same comparison algorithm must be used for reads
 	// and writes over the lifetime of the DB.
@@ -244,22 +132,11 @@ type Options struct {
 	// The default value uses the same ordering as bytes.Compare.
 	Comparer comparer.Comparer
 
-	// Compression defines the 'sorted table' block compression to use.
+	// Compression defines the per-block compression to use.
 	//
 	// The default value (DefaultCompression) uses snappy compression.
 	Compression Compression
 
-	// DisableBlockCache allows disable use of cache.Cache functionality on
-	// 'sorted table' block.
-	//
-	// The default value is false.
-	DisableBlockCache bool
-
-	// DisableCompactionBackoff allows disable compaction retry backoff.
-	//
-	// The default value is false.
-	DisableCompactionBackoff bool
-
 	// ErrorIfExist defines whether an error should returned if the DB already
 	// exist.
 	//
@@ -288,30 +165,12 @@ type Options struct {
 	// The default value is nil.
 	Filter filter.Filter
 
-	// MaxMemCompationLevel defines maximum level a newly compacted 'memdb'
-	// will be pushed into if doesn't creates overlap. This should less than
-	// NumLevel. Use -1 for level-0.
+	// MaxOpenFiles defines maximum number of open files to kept around
+	// (cached). This is not an hard limit, actual open files may exceed
+	// the defined value.
 	//
-	// The default is 2.
-	MaxMemCompationLevel int
-
-	// NumLevel defines number of database level. The level shouldn't changed
-	// between opens, or the database will panic.
-	//
-	// The default is 7.
-	NumLevel int
-
-	// OpenFilesCacher provides cache algorithm for open files caching.
-	// Specify NoCacher to disable caching algorithm.
-	//
-	// The default value is LRUCacher.
-	OpenFilesCacher Cacher
-
-	// OpenFilesCacheCapacity defines the capacity of the open files caching.
-	// Use -1 for zero, this has same effect with specifying NoCacher to OpenFilesCacher.
-	//
-	// The default value is 500.
-	OpenFilesCacheCapacity int
+	// The default value is 1000.
+	MaxOpenFiles int
 
 	// Strict defines the DB strict level.
 	Strict Strict
@@ -324,18 +183,6 @@ type Options struct {
 	//
 	// The default value is 4MiB.
 	WriteBuffer int
-
-	// WriteL0StopTrigger defines number of 'sorted table' at level-0 that will
-	// pause write.
-	//
-	// The default value is 12.
-	WriteL0PauseTrigger int
-
-	// WriteL0SlowdownTrigger defines number of 'sorted table' at level-0 that
-	// will trigger write slowdown.
-	//
-	// The default value is 8.
-	WriteL0SlowdownTrigger int
 }
 
 func (o *Options) GetAltFilters() []filter.Filter {
@@ -345,22 +192,11 @@ func (o *Options) GetAltFilters() []filter.Filter {
 	return o.AltFilters
 }
 
-func (o *Options) GetBlockCacher() Cacher {
-	if o == nil || o.BlockCacher == nil {
-		return DefaultBlockCacher
-	} else if o.BlockCacher == NoCacher {
+func (o *Options) GetBlockCache() cache.Cache {
+	if o == nil {
 		return nil
 	}
-	return o.BlockCacher
-}
-
-func (o *Options) GetBlockCacheCapacity() int {
-	if o == nil || o.BlockCacheCapacity <= 0 {
-		return DefaultBlockCacheCapacity
-	} else if o.BlockCacheCapacity == -1 {
-		return 0
-	}
-	return o.BlockCacheCapacity
+	return o.BlockCache
 }
 
 func (o *Options) GetBlockRestartInterval() int {
@@ -377,79 +213,6 @@ func (o *Options) GetBlockSize() int {
 	return o.BlockSize
 }
 
-func (o *Options) GetCompactionExpandLimit(level int) int {
-	factor := DefaultCompactionExpandLimitFactor
-	if o != nil && o.CompactionExpandLimitFactor > 0 {
-		factor = o.CompactionExpandLimitFactor
-	}
-	return o.GetCompactionTableSize(level+1) * factor
-}
-
-func (o *Options) GetCompactionGPOverlaps(level int) int {
-	factor := DefaultCompactionGPOverlapsFactor
-	if o != nil && o.CompactionGPOverlapsFactor > 0 {
-		factor = o.CompactionGPOverlapsFactor
-	}
-	return o.GetCompactionTableSize(level+2) * factor
-}
-
-func (o *Options) GetCompactionL0Trigger() int {
-	if o == nil || o.CompactionL0Trigger == 0 {
-		return DefaultCompactionL0Trigger
-	}
-	return o.CompactionL0Trigger
-}
-
-func (o *Options) GetCompactionSourceLimit(level int) int {
-	factor := DefaultCompactionSourceLimitFactor
-	if o != nil && o.CompactionSourceLimitFactor > 0 {
-		factor = o.CompactionSourceLimitFactor
-	}
-	return o.GetCompactionTableSize(level+1) * factor
-}
-
-func (o *Options) GetCompactionTableSize(level int) int {
-	var (
-		base = DefaultCompactionTableSize
-		mult float64
-	)
-	if o != nil {
-		if o.CompactionTableSize > 0 {
-			base = o.CompactionTableSize
-		}
-		if len(o.CompactionTableSizeMultiplierPerLevel) > level && o.CompactionTableSizeMultiplierPerLevel[level] > 0 {
-			mult = o.CompactionTableSizeMultiplierPerLevel[level]
-		} else if o.CompactionTableSizeMultiplier > 0 {
-			mult = math.Pow(o.CompactionTableSizeMultiplier, float64(level))
-		}
-	}
-	if mult == 0 {
-		mult = math.Pow(DefaultCompactionTableSizeMultiplier, float64(level))
-	}
-	return int(float64(base) * mult)
-}
-
-func (o *Options) GetCompactionTotalSize(level int) int64 {
-	var (
-		base = DefaultCompactionTotalSize
-		mult float64
-	)
-	if o != nil {
-		if o.CompactionTotalSize > 0 {
-			base = o.CompactionTotalSize
-		}
-		if len(o.CompactionTotalSizeMultiplierPerLevel) > level && o.CompactionTotalSizeMultiplierPerLevel[level] > 0 {
-			mult = o.CompactionTotalSizeMultiplierPerLevel[level]
-		} else if o.CompactionTotalSizeMultiplier > 0 {
-			mult = math.Pow(o.CompactionTotalSizeMultiplier, float64(level))
-		}
-	}
-	if mult == 0 {
-		mult = math.Pow(DefaultCompactionTotalSizeMultiplier, float64(level))
-	}
-	return int64(float64(base) * mult)
-}
-
 func (o *Options) GetComparer() comparer.Comparer {
 	if o == nil || o.Comparer == nil {
 		return comparer.DefaultComparer
@@ -464,13 +227,6 @@ func (o *Options) GetCompression() Compression {
 	return o.Compression
 }
 
-func (o *Options) GetDisableCompactionBackoff() bool {
-	if o == nil {
-		return false
-	}
-	return o.DisableCompactionBackoff
-}
-
 func (o *Options) GetErrorIfExist() bool {
 	if o == nil {
 		return false
@@ -492,45 +248,11 @@ func (o *Options) GetFilter() filter.Filter {
 	return o.Filter
 }
 
-func (o *Options) GetMaxMemCompationLevel() int {
-	level := DefaultMaxMemCompationLevel
-	if o != nil {
-		if o.MaxMemCompationLevel > 0 {
-			level = o.MaxMemCompationLevel
-		} else if o.MaxMemCompationLevel == -1 {
-			level = 0
-		}
+func (o *Options) GetMaxOpenFiles() int {
+	if o == nil || o.MaxOpenFiles <= 0 {
+		return DefaultMaxOpenFiles
 	}
-	if level >= o.GetNumLevel() {
-		return o.GetNumLevel() - 1
-	}
-	return level
-}
-
-func (o *Options) GetNumLevel() int {
-	if o == nil || o.NumLevel <= 0 {
-		return DefaultNumLevel
-	}
-	return o.NumLevel
-}
-
-func (o *Options) GetOpenFilesCacher() Cacher {
-	if o == nil || o.OpenFilesCacher == nil {
-		return DefaultOpenFilesCacher
-	}
-	if o.OpenFilesCacher == NoCacher {
-		return nil
-	}
-	return o.OpenFilesCacher
-}
-
-func (o *Options) GetOpenFilesCacheCapacity() int {
-	if o == nil || o.OpenFilesCacheCapacity <= 0 {
-		return DefaultOpenFilesCacheCapacity
-	} else if o.OpenFilesCacheCapacity == -1 {
-		return 0
-	}
-	return o.OpenFilesCacheCapacity
+	return o.MaxOpenFiles
 }
 
 func (o *Options) GetStrict(strict Strict) bool {
@@ -547,20 +269,6 @@ func (o *Options) GetWriteBuffer() int {
 	return o.WriteBuffer
 }
 
-func (o *Options) GetWriteL0PauseTrigger() int {
-	if o == nil || o.WriteL0PauseTrigger == 0 {
-		return DefaultWriteL0PauseTrigger
-	}
-	return o.WriteL0PauseTrigger
-}
-
-func (o *Options) GetWriteL0SlowdownTrigger() int {
-	if o == nil || o.WriteL0SlowdownTrigger == 0 {
-		return DefaultWriteL0SlowdownTrigger
-	}
-	return o.WriteL0SlowdownTrigger
-}
-
 // ReadOptions holds the optional parameters for 'read operation'. The
 // 'read operation' includes Get, Find and NewIterator.
 type ReadOptions struct {
@@ -571,8 +279,8 @@ type ReadOptions struct {
 	// The default value is false.
 	DontFillCache bool
 
-	// Strict will be OR'ed with global DB 'strict level' unless StrictOverride
-	// is present. Currently only StrictReader that has effect here.
+	// Strict overrides global DB strict level. Only StrictIterator and
+	// StrictBlockChecksum that does have effects here.
 	Strict Strict
 }
 
@@ -614,11 +322,3 @@ func (wo *WriteOptions) GetSync() bool {
 	}
 	return wo.Sync
 }
-
-func GetStrict(o *Options, ro *ReadOptions, strict Strict) bool {
-	if ro.GetStrict(StrictOverride) {
-		return ro.GetStrict(strict)
-	} else {
-		return o.GetStrict(strict) || ro.GetStrict(strict)
-	}
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/options.go

@@ -7,86 +7,35 @@
 package leveldb
 
 import (
+	"github.com/syndtr/goleveldb/leveldb/cache"
 	"github.com/syndtr/goleveldb/leveldb/filter"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 )
 
-func dupOptions(o *opt.Options) *opt.Options {
-	newo := &opt.Options{}
-	if o != nil {
-		*newo = *o
-	}
-	if newo.Strict == 0 {
-		newo.Strict = opt.DefaultStrict
-	}
-	return newo
-}
-
 func (s *session) setOptions(o *opt.Options) {
-	no := dupOptions(o)
+	s.o = &opt.Options{}
+	if o != nil {
+		*s.o = *o
+	}
 	// Alternative filters.
 	if filters := o.GetAltFilters(); len(filters) > 0 {
-		no.AltFilters = make([]filter.Filter, len(filters))
+		s.o.AltFilters = make([]filter.Filter, len(filters))
 		for i, filter := range filters {
-			no.AltFilters[i] = &iFilter{filter}
+			s.o.AltFilters[i] = &iFilter{filter}
 		}
 	}
+	// Block cache.
+	switch o.GetBlockCache() {
+	case nil:
+		s.o.BlockCache = cache.NewLRUCache(opt.DefaultBlockCacheSize)
+	case opt.NoCache:
+		s.o.BlockCache = nil
+	}
 	// Comparer.
 	s.icmp = &iComparer{o.GetComparer()}
-	no.Comparer = s.icmp
+	s.o.Comparer = s.icmp
 	// Filter.
 	if filter := o.GetFilter(); filter != nil {
-		no.Filter = &iFilter{filter}
-	}
-
-	s.o = &cachedOptions{Options: no}
-	s.o.cache()
-}
-
-type cachedOptions struct {
-	*opt.Options
-
-	compactionExpandLimit []int
-	compactionGPOverlaps  []int
-	compactionSourceLimit []int
-	compactionTableSize   []int
-	compactionTotalSize   []int64
-}
-
-func (co *cachedOptions) cache() {
-	numLevel := co.Options.GetNumLevel()
-
-	co.compactionExpandLimit = make([]int, numLevel)
-	co.compactionGPOverlaps = make([]int, numLevel)
-	co.compactionSourceLimit = make([]int, numLevel)
-	co.compactionTableSize = make([]int, numLevel)
-	co.compactionTotalSize = make([]int64, numLevel)
-
-	for level := 0; level < numLevel; level++ {
-		co.compactionExpandLimit[level] = co.Options.GetCompactionExpandLimit(level)
-		co.compactionGPOverlaps[level] = co.Options.GetCompactionGPOverlaps(level)
-		co.compactionSourceLimit[level] = co.Options.GetCompactionSourceLimit(level)
-		co.compactionTableSize[level] = co.Options.GetCompactionTableSize(level)
-		co.compactionTotalSize[level] = co.Options.GetCompactionTotalSize(level)
+		s.o.Filter = &iFilter{filter}
 	}
 }
-
-func (co *cachedOptions) GetCompactionExpandLimit(level int) int {
-	return co.compactionExpandLimit[level]
-}
-
-func (co *cachedOptions) GetCompactionGPOverlaps(level int) int {
-	return co.compactionGPOverlaps[level]
-}
-
-func (co *cachedOptions) GetCompactionSourceLimit(level int) int {
-	return co.compactionSourceLimit[level]
-}
-
-func (co *cachedOptions) GetCompactionTableSize(level int) int {
-	return co.compactionTableSize[level]
-}
-
-func (co *cachedOptions) GetCompactionTotalSize(level int) int64 {
-	return co.compactionTotalSize[level]
-}