From 49da7b655670f937858816c2ef8a7a43cce36362 Mon Sep 17 00:00:00 2001 From: Xiang Li Date: Wed, 27 May 2015 09:24:49 -0700 Subject: [PATCH] storage: add boltdb as dependency --- Godeps/Godeps.json | 7 +- .../src/github.com/boltdb/bolt/.gitignore | 3 + .../src/github.com/boltdb/bolt/LICENSE | 20 + .../src/github.com/boltdb/bolt/Makefile | 54 + .../src/github.com/boltdb/bolt/README.md | 591 +++++++ .../src/github.com/boltdb/bolt/batch.go | 135 ++ .../boltdb/bolt/batch_benchmark_test.go | 170 ++ .../boltdb/bolt/batch_example_test.go | 148 ++ .../src/github.com/boltdb/bolt/batch_test.go | 167 ++ .../src/github.com/boltdb/bolt/bolt_386.go | 7 + .../src/github.com/boltdb/bolt/bolt_amd64.go | 7 + .../src/github.com/boltdb/bolt/bolt_arm.go | 7 + .../src/github.com/boltdb/bolt/bolt_linux.go | 12 + .../github.com/boltdb/bolt/bolt_openbsd.go | 29 + .../src/github.com/boltdb/bolt/bolt_test.go | 36 + .../src/github.com/boltdb/bolt/bolt_unix.go | 80 + .../github.com/boltdb/bolt/bolt_windows.go | 74 + .../github.com/boltdb/bolt/boltsync_unix.go | 10 + .../src/github.com/boltdb/bolt/bucket.go | 743 ++++++++ .../src/github.com/boltdb/bolt/bucket_test.go | 1153 +++++++++++++ .../src/github.com/boltdb/bolt/cmd/bolt/bolt | Bin 0 -> 3031824 bytes .../github.com/boltdb/bolt/cmd/bolt/main.go | 1529 +++++++++++++++++ .../boltdb/bolt/cmd/bolt/main_test.go | 145 ++ .../src/github.com/boltdb/bolt/cmd/bolt/p.out | Bin 0 -> 45272 bytes .../src/github.com/boltdb/bolt/cursor.go | 384 +++++ .../src/github.com/boltdb/bolt/cursor_test.go | 511 ++++++ .../src/github.com/boltdb/bolt/db.go | 732 ++++++++ .../src/github.com/boltdb/bolt/db_test.go | 790 +++++++++ .../src/github.com/boltdb/bolt/doc.go | 44 + .../src/github.com/boltdb/bolt/errors.go | 66 + .../src/github.com/boltdb/bolt/freelist.go | 241 +++ .../github.com/boltdb/bolt/freelist_test.go | 129 ++ .../src/github.com/boltdb/bolt/node.go | 627 +++++++ .../src/github.com/boltdb/bolt/node_test.go | 156 ++ .../src/github.com/boltdb/bolt/page.go | 134 ++ .../src/github.com/boltdb/bolt/page_test.go | 29 + .../src/github.com/boltdb/bolt/quick_test.go | 79 + .../github.com/boltdb/bolt/simulation_test.go | 327 ++++ .../src/github.com/boltdb/bolt/tx.go | 585 +++++++ .../src/github.com/boltdb/bolt/tx_test.go | 424 +++++ storage/backend/backend.go | 2 +- storage/backend/batch_tx.go | 2 +- 42 files changed, 10386 insertions(+), 3 deletions(-) create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/.gitignore create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/LICENSE create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/Makefile create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/README.md create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/batch.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/batch_benchmark_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/batch_example_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/batch_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_386.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_amd64.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_arm.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_linux.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_openbsd.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_unix.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bolt_windows.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/boltsync_unix.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bucket.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/bucket_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/bolt create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/p.out create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/cursor.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/cursor_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/db.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/db_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/doc.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/errors.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/freelist.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/freelist_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/node.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/node_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/page.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/page_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/quick_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/simulation_test.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/tx.go create mode 100644 Godeps/_workspace/src/github.com/boltdb/bolt/tx_test.go diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 93c0ff11f..9d0064116 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -1,6 +1,6 @@ { "ImportPath": "github.com/coreos/etcd", - "GoVersion": "go1.4.2", + "GoVersion": "go1.4.1", "Packages": [ "./..." ], @@ -10,6 +10,11 @@ "Comment": "go.r60-163", "Rev": "9352842ae63ee1d7e74e074ce7bb10370c4b6b9e" }, + { + "ImportPath": "github.com/boltdb/bolt", + "Comment": "v1.0-71-g71f28ea", + "Rev": "71f28eaecbebd00604d87bb1de0dae8fcfa54bbd" + }, { "ImportPath": "github.com/codegangsta/cli", "Comment": "1.2.0-26-gf7ebb76", diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/.gitignore b/Godeps/_workspace/src/github.com/boltdb/bolt/.gitignore new file mode 100644 index 000000000..b2bb382bd --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/.gitignore @@ -0,0 +1,3 @@ +*.prof +*.test +/bin/ diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/LICENSE b/Godeps/_workspace/src/github.com/boltdb/bolt/LICENSE new file mode 100644 index 000000000..004e77fe5 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/LICENSE @@ -0,0 +1,20 @@ +The MIT License (MIT) + +Copyright (c) 2013 Ben Johnson + +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. diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/Makefile b/Godeps/_workspace/src/github.com/boltdb/bolt/Makefile new file mode 100644 index 000000000..cfbed514b --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/Makefile @@ -0,0 +1,54 @@ +TEST=. +BENCH=. +COVERPROFILE=/tmp/c.out +BRANCH=`git rev-parse --abbrev-ref HEAD` +COMMIT=`git rev-parse --short HEAD` +GOLDFLAGS="-X main.branch $(BRANCH) -X main.commit $(COMMIT)" + +default: build + +bench: + go test -v -test.run=NOTHINCONTAINSTHIS -test.bench=$(BENCH) + +# http://cloc.sourceforge.net/ +cloc: + @cloc --not-match-f='Makefile|_test.go' . + +cover: fmt + go test -coverprofile=$(COVERPROFILE) -test.run=$(TEST) $(COVERFLAG) . + go tool cover -html=$(COVERPROFILE) + rm $(COVERPROFILE) + +cpuprofile: fmt + @go test -c + @./bolt.test -test.v -test.run=$(TEST) -test.cpuprofile cpu.prof + +# go get github.com/kisielk/errcheck +errcheck: + @echo "=== errcheck ===" + @errcheck github.com/boltdb/bolt + +fmt: + @go fmt ./... + +get: + @go get -d ./... + +build: get + @mkdir -p bin + @go build -ldflags=$(GOLDFLAGS) -a -o bin/bolt ./cmd/bolt + +test: fmt + @go get github.com/stretchr/testify/assert + @echo "=== TESTS ===" + @go test -v -cover -test.run=$(TEST) + @echo "" + @echo "" + @echo "=== CLI ===" + @go test -v -test.run=$(TEST) ./cmd/bolt + @echo "" + @echo "" + @echo "=== RACE DETECTOR ===" + @go test -v -race -test.run="TestSimulate_(100op|1000op)" + +.PHONY: bench cloc cover cpuprofile fmt memprofile test diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/README.md b/Godeps/_workspace/src/github.com/boltdb/bolt/README.md new file mode 100644 index 000000000..401a757c3 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/README.md @@ -0,0 +1,591 @@ +Bolt [![Build Status](https://drone.io/github.com/boltdb/bolt/status.png)](https://drone.io/github.com/boltdb/bolt/latest) [![Coverage Status](https://coveralls.io/repos/boltdb/bolt/badge.png?branch=master)](https://coveralls.io/r/boltdb/bolt?branch=master) [![GoDoc](https://godoc.org/github.com/boltdb/bolt?status.png)](https://godoc.org/github.com/boltdb/bolt) ![Version](http://img.shields.io/badge/version-1.0-green.png) +==== + +Bolt is a pure Go key/value store inspired by [Howard Chu's][hyc_symas] and +the [LMDB project][lmdb]. The goal of the project is to provide a simple, +fast, and reliable database for projects that don't require a full database +server such as Postgres or MySQL. + +Since Bolt is meant to be used as such a low-level piece of functionality, +simplicity is key. The API will be small and only focus on getting values +and setting values. That's it. + +[hyc_symas]: https://twitter.com/hyc_symas +[lmdb]: http://symas.com/mdb/ + + +## Project Status + +Bolt is stable and the API is fixed. Full unit test coverage and randomized +black box testing are used to ensure database consistency and thread safety. +Bolt is currently in high-load production environments serving databases as +large as 1TB. Many companies such as Shopify and Heroku use Bolt-backed +services every day. + + +## Getting Started + +### Installing + +To start using Bolt, install Go and run `go get`: + +```sh +$ go get github.com/boltdb/bolt/... +``` + +This will retrieve the library and install the `bolt` command line utility into +your `$GOBIN` path. + + +### Opening a database + +The top-level object in Bolt is a `DB`. It is represented as a single file on +your disk and represents a consistent snapshot of your data. + +To open your database, simply use the `bolt.Open()` function: + +```go +package main + +import ( + "log" + + "github.com/boltdb/bolt" +) + +func main() { + // Open the my.db data file in your current directory. + // It will be created if it doesn't exist. + db, err := bolt.Open("my.db", 0600, nil) + if err != nil { + log.Fatal(err) + } + defer db.Close() + + ... +} +``` + +Please note that Bolt obtains a file lock on the data file so multiple processes +cannot open the same database at the same time. Opening an already open Bolt +database will cause it to hang until the other process closes it. To prevent +an indefinite wait you can pass a timeout option to the `Open()` function: + +```go +db, err := bolt.Open("my.db", 0600, &bolt.Options{Timeout: 1 * time.Second}) +``` + + +### Transactions + +Bolt allows only one read-write transaction at a time but allows as many +read-only transactions as you want at a time. Each transaction has a consistent +view of the data as it existed when the transaction started. + +Individual transactions and all objects created from them (e.g. buckets, keys) +are not thread safe. To work with data in multiple goroutines you must start +a transaction for each one or use locking to ensure only one goroutine accesses +a transaction at a time. Creating transaction from the `DB` is thread safe. + + +#### Read-write transactions + +To start a read-write transaction, you can use the `DB.Update()` function: + +```go +err := db.Update(func(tx *bolt.Tx) error { + ... + return nil +}) +``` + +Inside the closure, you have a consistent view of the database. You commit the +transaction by returning `nil` at the end. You can also rollback the transaction +at any point by returning an error. All database operations are allowed inside +a read-write transaction. + +Always check the return error as it will report any disk failures that can cause +your transaction to not complete. If you return an error within your closure +it will be passed through. + + +#### Read-only transactions + +To start a read-only transaction, you can use the `DB.View()` function: + +```go +err := db.View(func(tx *bolt.Tx) error { + ... + return nil +}) +``` + +You also get a consistent view of the database within this closure, however, +no mutating operations are allowed within a read-only transaction. You can only +retrieve buckets, retrieve values, and copy the database within a read-only +transaction. + + +#### Batch read-write transactions + +Each `DB.Update()` waits for disk to commit the writes. This overhead +can be minimized by combining multiple updates with the `DB.Batch()` +function: + +```go +err := db.Batch(func(tx *bolt.Tx) error { + ... + return nil +}) +``` + +Concurrent Batch calls are opportunistically combined into larger +transactions. Batch is only useful when there are multiple goroutines +calling it. + +The trade-off is that `Batch` can call the given +function multiple times, if parts of the transaction fail. The +function must be idempotent and side effects must take effect only +after a successful return from `DB.Batch()`. + +For example: don't display messages from inside the function, instead +set variables in the enclosing scope: + +```go +var id uint64 +err := db.Batch(func(tx *bolt.Tx) error { + // Find last key in bucket, decode as bigendian uint64, increment + // by one, encode back to []byte, and add new key. + ... + id = newValue + return nil +}) +if err != nil { + return ... +} +fmt.Println("Allocated ID %d", id) +``` + + +#### Managing transactions manually + +The `DB.View()` and `DB.Update()` functions are wrappers around the `DB.Begin()` +function. These helper functions will start the transaction, execute a function, +and then safely close your transaction if an error is returned. This is the +recommended way to use Bolt transactions. + +However, sometimes you may want to manually start and end your transactions. +You can use the `Tx.Begin()` function directly but _please_ be sure to close the +transaction. + +```go +// Start a writable transaction. +tx, err := db.Begin(true) +if err != nil { + return err +} +defer tx.Rollback() + +// Use the transaction... +_, err := tx.CreateBucket([]byte("MyBucket")) +if err != nil { + return err +} + +// Commit the transaction and check for error. +if err := tx.Commit(); err != nil { + return err +} +``` + +The first argument to `DB.Begin()` is a boolean stating if the transaction +should be writable. + + +### Using buckets + +Buckets are collections of key/value pairs within the database. All keys in a +bucket must be unique. You can create a bucket using the `DB.CreateBucket()` +function: + +```go +db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("MyBucket")) + if err != nil { + return fmt.Errorf("create bucket: %s", err) + } + return nil +}) +``` + +You can also create a bucket only if it doesn't exist by using the +`Tx.CreateBucketIfNotExists()` function. It's a common pattern to call this +function for all your top-level buckets after you open your database so you can +guarantee that they exist for future transactions. + +To delete a bucket, simply call the `Tx.DeleteBucket()` function. + + +### Using key/value pairs + +To save a key/value pair to a bucket, use the `Bucket.Put()` function: + +```go +db.Update(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("MyBucket")) + err := b.Put([]byte("answer"), []byte("42")) + return err +}) +``` + +This will set the value of the `"answer"` key to `"42"` in the `MyBucket` +bucket. To retrieve this value, we can use the `Bucket.Get()` function: + +```go +db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("MyBucket")) + v := b.Get([]byte("answer")) + fmt.Printf("The answer is: %s\n", v) + return nil +}) +``` + +The `Get()` function does not return an error because its operation is +guarenteed to work (unless there is some kind of system failure). If the key +exists then it will return its byte slice value. If it doesn't exist then it +will return `nil`. It's important to note that you can have a zero-length value +set to a key which is different than the key not existing. + +Use the `Bucket.Delete()` function to delete a key from the bucket. + +Please note that values returned from `Get()` are only valid while the +transaction is open. If you need to use a value outside of the transaction +then you must use `copy()` to copy it to another byte slice. + + +### Iterating over keys + +Bolt stores its keys in byte-sorted order within a bucket. This makes sequential +iteration over these keys extremely fast. To iterate over keys we'll use a +`Cursor`: + +```go +db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("MyBucket")) + c := b.Cursor() + + for k, v := c.First(); k != nil; k, v = c.Next() { + fmt.Printf("key=%s, value=%s\n", k, v) + } + + return nil +}) +``` + +The cursor allows you to move to a specific point in the list of keys and move +forward or backward through the keys one at a time. + +The following functions are available on the cursor: + +``` +First() Move to the first key. +Last() Move to the last key. +Seek() Move to a specific key. +Next() Move to the next key. +Prev() Move to the previous key. +``` + +When you have iterated to the end of the cursor then `Next()` will return `nil`. +You must seek to a position using `First()`, `Last()`, or `Seek()` before +calling `Next()` or `Prev()`. If you do not seek to a position then these +functions will return `nil`. + + +#### Prefix scans + +To iterate over a key prefix, you can combine `Seek()` and `bytes.HasPrefix()`: + +```go +db.View(func(tx *bolt.Tx) error { + c := tx.Bucket([]byte("MyBucket")).Cursor() + + prefix := []byte("1234") + for k, v := c.Seek(prefix); bytes.HasPrefix(k, prefix); k, v = c.Next() { + fmt.Printf("key=%s, value=%s\n", k, v) + } + + return nil +}) +``` + +#### Range scans + +Another common use case is scanning over a range such as a time range. If you +use a sortable time encoding such as RFC3339 then you can query a specific +date range like this: + +```go +db.View(func(tx *bolt.Tx) error { + // Assume our events bucket has RFC3339 encoded time keys. + c := tx.Bucket([]byte("Events")).Cursor() + + // Our time range spans the 90's decade. + min := []byte("1990-01-01T00:00:00Z") + max := []byte("2000-01-01T00:00:00Z") + + // Iterate over the 90's. + for k, v := c.Seek(min); k != nil && bytes.Compare(k, max) <= 0; k, v = c.Next() { + fmt.Printf("%s: %s\n", k, v) + } + + return nil +}) +``` + + +#### ForEach() + +You can also use the function `ForEach()` if you know you'll be iterating over +all the keys in a bucket: + +```go +db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("MyBucket")) + b.ForEach(func(k, v []byte) error { + fmt.Printf("key=%s, value=%s\n", k, v) + return nil + }) + return nil +}) +``` + + +### Nested buckets + +You can also store a bucket in a key to create nested buckets. The API is the +same as the bucket management API on the `DB` object: + +```go +func (*Bucket) CreateBucket(key []byte) (*Bucket, error) +func (*Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error) +func (*Bucket) DeleteBucket(key []byte) error +``` + + +### Database backups + +Bolt is a single file so it's easy to backup. You can use the `Tx.WriteTo()` +function to write a consistent view of the database to a writer. If you call +this from a read-only transaction, it will perform a hot backup and not block +your other database reads and writes. It will also use `O_DIRECT` when available +to prevent page cache trashing. + +One common use case is to backup over HTTP so you can use tools like `cURL` to +do database backups: + +```go +func BackupHandleFunc(w http.ResponseWriter, req *http.Request) { + err := db.View(func(tx *bolt.Tx) error { + w.Header().Set("Content-Type", "application/octet-stream") + w.Header().Set("Content-Disposition", `attachment; filename="my.db"`) + w.Header().Set("Content-Length", strconv.Itoa(int(tx.Size()))) + _, err := tx.WriteTo(w) + return err + }) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + } +} +``` + +Then you can backup using this command: + +```sh +$ curl http://localhost/backup > my.db +``` + +Or you can open your browser to `http://localhost/backup` and it will download +automatically. + +If you want to backup to another file you can use the `Tx.CopyFile()` helper +function. + + +### Statistics + +The database keeps a running count of many of the internal operations it +performs so you can better understand what's going on. By grabbing a snapshot +of these stats at two points in time we can see what operations were performed +in that time range. + +For example, we could start a goroutine to log stats every 10 seconds: + +```go +go func() { + // Grab the initial stats. + prev := db.Stats() + + for { + // Wait for 10s. + time.Sleep(10 * time.Second) + + // Grab the current stats and diff them. + stats := db.Stats() + diff := stats.Sub(&prev) + + // Encode stats to JSON and print to STDERR. + json.NewEncoder(os.Stderr).Encode(diff) + + // Save stats for the next loop. + prev = stats + } +}() +``` + +It's also useful to pipe these stats to a service such as statsd for monitoring +or to provide an HTTP endpoint that will perform a fixed-length sample. + + +## Resources + +For more information on getting started with Bolt, check out the following articles: + +* [Intro to BoltDB: Painless Performant Persistence](http://npf.io/2014/07/intro-to-boltdb-painless-performant-persistence/) by [Nate Finch](https://github.com/natefinch). +* [Bolt -- an embedded key/value database for Go](https://www.progville.com/go/bolt-embedded-db-golang/) by Progville + + +## Comparison with other databases + +### Postgres, MySQL, & other relational databases + +Relational databases structure data into rows and are only accessible through +the use of SQL. This approach provides flexibility in how you store and query +your data but also incurs overhead in parsing and planning SQL statements. Bolt +accesses all data by a byte slice key. This makes Bolt fast to read and write +data by key but provides no built-in support for joining values together. + +Most relational databases (with the exception of SQLite) are standalone servers +that run separately from your application. This gives your systems +flexibility to connect multiple application servers to a single database +server but also adds overhead in serializing and transporting data over the +network. Bolt runs as a library included in your application so all data access +has to go through your application's process. This brings data closer to your +application but limits multi-process access to the data. + + +### LevelDB, RocksDB + +LevelDB and its derivatives (RocksDB, HyperLevelDB) are similar to Bolt in that +they are libraries bundled into the application, however, their underlying +structure is a log-structured merge-tree (LSM tree). An LSM tree optimizes +random writes by using a write ahead log and multi-tiered, sorted files called +SSTables. Bolt uses a B+tree internally and only a single file. Both approaches +have trade offs. + +If you require a high random write throughput (>10,000 w/sec) or you need to use +spinning disks then LevelDB could be a good choice. If your application is +read-heavy or does a lot of range scans then Bolt could be a good choice. + +One other important consideration is that LevelDB does not have transactions. +It supports batch writing of key/values pairs and it supports read snapshots +but it will not give you the ability to do a compare-and-swap operation safely. +Bolt supports fully serializable ACID transactions. + + +### LMDB + +Bolt was originally a port of LMDB so it is architecturally similar. Both use +a B+tree, have ACID semantics with fully serializable transactions, and support +lock-free MVCC using a single writer and multiple readers. + +The two projects have somewhat diverged. LMDB heavily focuses on raw performance +while Bolt has focused on simplicity and ease of use. For example, LMDB allows +several unsafe actions such as direct writes for the sake of performance. Bolt +opts to disallow actions which can leave the database in a corrupted state. The +only exception to this in Bolt is `DB.NoSync`. + +There are also a few differences in API. LMDB requires a maximum mmap size when +opening an `mdb_env` whereas Bolt will handle incremental mmap resizing +automatically. LMDB overloads the getter and setter functions with multiple +flags whereas Bolt splits these specialized cases into their own functions. + + +## Caveats & Limitations + +It's important to pick the right tool for the job and Bolt is no exception. +Here are a few things to note when evaluating and using Bolt: + +* Bolt is good for read intensive workloads. Sequential write performance is + also fast but random writes can be slow. You can add a write-ahead log or + [transaction coalescer](https://github.com/boltdb/coalescer) in front of Bolt + to mitigate this issue. + +* Bolt uses a B+tree internally so there can be a lot of random page access. + SSDs provide a significant performance boost over spinning disks. + +* Try to avoid long running read transactions. Bolt uses copy-on-write so + old pages cannot be reclaimed while an old transaction is using them. + +* Byte slices returned from Bolt are only valid during a transaction. Once the + transaction has been committed or rolled back then the memory they point to + can be reused by a new page or can be unmapped from virtual memory and you'll + see an `unexpected fault address` panic when accessing it. + +* Be careful when using `Bucket.FillPercent`. Setting a high fill percent for + buckets that have random inserts will cause your database to have very poor + page utilization. + +* Use larger buckets in general. Smaller buckets causes poor page utilization + once they become larger than the page size (typically 4KB). + +* Bulk loading a lot of random writes into a new bucket can be slow as the + page will not split until the transaction is committed. Randomly inserting + more than 100,000 key/value pairs into a single new bucket in a single + transaction is not advised. + +* Bolt uses a memory-mapped file so the underlying operating system handles the + caching of the data. Typically, the OS will cache as much of the file as it + can in memory and will release memory as needed to other processes. This means + that Bolt can show very high memory usage when working with large databases. + However, this is expected and the OS will release memory as needed. Bolt can + handle databases much larger than the available physical RAM. + +* Because of the way pages are laid out on disk, Bolt cannot truncate data files + and return free pages back to the disk. Instead, Bolt maintains a free list + of unused pages within its data file. These free pages can be reused by later + transactions. This works well for many use cases as databases generally tend + to grow. However, it's important to note that deleting large chunks of data + will not allow you to reclaim that space on disk. + + For more information on page allocation, [see this comment][page-allocation]. + +[page-allocation]: https://github.com/boltdb/bolt/issues/308#issuecomment-74811638 + + +## Other Projects Using Bolt + +Below is a list of public, open source projects that use Bolt: + +* [Operation Go: A Routine Mission](http://gocode.io) - An online programming game for Golang using Bolt for user accounts and a leaderboard. +* [Bazil](https://github.com/bazillion/bazil) - A file system that lets your data reside where it is most convenient for it to reside. +* [DVID](https://github.com/janelia-flyem/dvid) - Added Bolt as optional storage engine and testing it against Basho-tuned leveldb. +* [Skybox Analytics](https://github.com/skybox/skybox) - A standalone funnel analysis tool for web analytics. +* [Scuttlebutt](https://github.com/benbjohnson/scuttlebutt) - Uses Bolt to store and process all Twitter mentions of GitHub projects. +* [Wiki](https://github.com/peterhellberg/wiki) - A tiny wiki using Goji, BoltDB and Blackfriday. +* [ChainStore](https://github.com/nulayer/chainstore) - Simple key-value interface to a variety of storage engines organized as a chain of operations. +* [MetricBase](https://github.com/msiebuhr/MetricBase) - Single-binary version of Graphite. +* [Gitchain](https://github.com/gitchain/gitchain) - Decentralized, peer-to-peer Git repositories aka "Git meets Bitcoin". +* [event-shuttle](https://github.com/sclasen/event-shuttle) - A Unix system service to collect and reliably deliver messages to Kafka. +* [ipxed](https://github.com/kelseyhightower/ipxed) - Web interface and api for ipxed. +* [BoltStore](https://github.com/yosssi/boltstore) - Session store using Bolt. +* [photosite/session](http://godoc.org/bitbucket.org/kardianos/photosite/session) - Sessions for a photo viewing site. +* [LedisDB](https://github.com/siddontang/ledisdb) - A high performance NoSQL, using Bolt as optional storage. +* [ipLocator](https://github.com/AndreasBriese/ipLocator) - A fast ip-geo-location-server using bolt with bloom filters. +* [cayley](https://github.com/google/cayley) - Cayley is an open-source graph database using Bolt as optional backend. +* [bleve](http://www.blevesearch.com/) - A pure Go search engine similar to ElasticSearch that uses Bolt as the default storage backend. +* [tentacool](https://github.com/optiflows/tentacool) - REST api server to manage system stuff (IP, DNS, Gateway...) on a linux server. +* [SkyDB](https://github.com/skydb/sky) - Behavioral analytics database. +* [Seaweed File System](https://github.com/chrislusf/weed-fs) - Highly scalable distributed key~file system with O(1) disk read. +* [InfluxDB](http://influxdb.com) - Scalable datastore for metrics, events, and real-time analytics. + +If you are using Bolt in a project please send a pull request to add it to the list. diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/batch.go b/Godeps/_workspace/src/github.com/boltdb/bolt/batch.go new file mode 100644 index 000000000..bef1f4aa2 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/batch.go @@ -0,0 +1,135 @@ +package bolt + +import ( + "errors" + "fmt" + "sync" + "time" +) + +// Batch calls fn as part of a batch. It behaves similar to Update, +// except: +// +// 1. concurrent Batch calls can be combined into a single Bolt +// transaction. +// +// 2. the function passed to Batch may be called multiple times, +// regardless of whether it returns error or not. +// +// This means that Batch function side effects must be idempotent and +// take permanent effect only after a successful return is seen in +// caller. +// +// Batch is only useful when there are multiple goroutines calling it. +func (db *DB) Batch(fn func(*Tx) error) error { + errCh := make(chan error, 1) + + db.batchMu.Lock() + if (db.batch == nil) || (db.batch != nil && len(db.batch.calls) >= db.MaxBatchSize) { + // There is no existing batch, or the existing batch is full; start a new one. + db.batch = &batch{ + db: db, + } + db.batch.timer = time.AfterFunc(db.MaxBatchDelay, db.batch.trigger) + } + db.batch.calls = append(db.batch.calls, call{fn: fn, err: errCh}) + if len(db.batch.calls) >= db.MaxBatchSize { + // wake up batch, it's ready to run + go db.batch.trigger() + } + db.batchMu.Unlock() + + err := <-errCh + if err == trySolo { + err = db.Update(fn) + } + return err +} + +type call struct { + fn func(*Tx) error + err chan<- error +} + +type batch struct { + db *DB + timer *time.Timer + start sync.Once + calls []call +} + +// trigger runs the batch if it hasn't already been run. +func (b *batch) trigger() { + b.start.Do(b.run) +} + +// run performs the transactions in the batch and communicates results +// back to DB.Batch. +func (b *batch) run() { + b.db.batchMu.Lock() + b.timer.Stop() + // Make sure no new work is added to this batch, but don't break + // other batches. + if b.db.batch == b { + b.db.batch = nil + } + b.db.batchMu.Unlock() + +retry: + for len(b.calls) > 0 { + var failIdx = -1 + err := b.db.Update(func(tx *Tx) error { + for i, c := range b.calls { + if err := safelyCall(c.fn, tx); err != nil { + failIdx = i + return err + } + } + return nil + }) + + if failIdx >= 0 { + // take the failing transaction out of the batch. it's + // safe to shorten b.calls here because db.batch no longer + // points to us, and we hold the mutex anyway. + c := b.calls[failIdx] + b.calls[failIdx], b.calls = b.calls[len(b.calls)-1], b.calls[:len(b.calls)-1] + // tell the submitter re-run it solo, continue with the rest of the batch + c.err <- trySolo + continue retry + } + + // pass success, or bolt internal errors, to all callers + for _, c := range b.calls { + if c.err != nil { + c.err <- err + } + } + break retry + } +} + +// trySolo is a special sentinel error value used for signaling that a +// transaction function should be re-run. It should never be seen by +// callers. +var trySolo = errors.New("batch function returned an error and should be re-run solo") + +type panicked struct { + reason interface{} +} + +func (p panicked) Error() string { + if err, ok := p.reason.(error); ok { + return err.Error() + } + return fmt.Sprintf("panic: %v", p.reason) +} + +func safelyCall(fn func(*Tx) error, tx *Tx) (err error) { + defer func() { + if p := recover(); p != nil { + err = panicked{p} + } + }() + return fn(tx) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/batch_benchmark_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/batch_benchmark_test.go new file mode 100644 index 000000000..f6b8c1834 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/batch_benchmark_test.go @@ -0,0 +1,170 @@ +package bolt_test + +import ( + "bytes" + "encoding/binary" + "errors" + "hash/fnv" + "sync" + "testing" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +func validateBatchBench(b *testing.B, db *TestDB) { + var rollback = errors.New("sentinel error to cause rollback") + validate := func(tx *bolt.Tx) error { + bucket := tx.Bucket([]byte("bench")) + h := fnv.New32a() + buf := make([]byte, 4) + for id := uint32(0); id < 1000; id++ { + binary.LittleEndian.PutUint32(buf, id) + h.Reset() + h.Write(buf[:]) + k := h.Sum(nil) + v := bucket.Get(k) + if v == nil { + b.Errorf("not found id=%d key=%x", id, k) + continue + } + if g, e := v, []byte("filler"); !bytes.Equal(g, e) { + b.Errorf("bad value for id=%d key=%x: %s != %q", id, k, g, e) + } + if err := bucket.Delete(k); err != nil { + return err + } + } + // should be empty now + c := bucket.Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + b.Errorf("unexpected key: %x = %q", k, v) + } + return rollback + } + if err := db.Update(validate); err != nil && err != rollback { + b.Error(err) + } +} + +func BenchmarkDBBatchAutomatic(b *testing.B) { + db := NewTestDB() + defer db.Close() + db.MustCreateBucket([]byte("bench")) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + start := make(chan struct{}) + var wg sync.WaitGroup + + for round := 0; round < 1000; round++ { + wg.Add(1) + + go func(id uint32) { + defer wg.Done() + <-start + + h := fnv.New32a() + buf := make([]byte, 4) + binary.LittleEndian.PutUint32(buf, id) + h.Write(buf[:]) + k := h.Sum(nil) + insert := func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("bench")) + return b.Put(k, []byte("filler")) + } + if err := db.Batch(insert); err != nil { + b.Error(err) + return + } + }(uint32(round)) + } + close(start) + wg.Wait() + } + + b.StopTimer() + validateBatchBench(b, db) +} + +func BenchmarkDBBatchSingle(b *testing.B) { + db := NewTestDB() + defer db.Close() + db.MustCreateBucket([]byte("bench")) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + start := make(chan struct{}) + var wg sync.WaitGroup + + for round := 0; round < 1000; round++ { + wg.Add(1) + go func(id uint32) { + defer wg.Done() + <-start + + h := fnv.New32a() + buf := make([]byte, 4) + binary.LittleEndian.PutUint32(buf, id) + h.Write(buf[:]) + k := h.Sum(nil) + insert := func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("bench")) + return b.Put(k, []byte("filler")) + } + if err := db.Update(insert); err != nil { + b.Error(err) + return + } + }(uint32(round)) + } + close(start) + wg.Wait() + } + + b.StopTimer() + validateBatchBench(b, db) +} + +func BenchmarkDBBatchManual10x100(b *testing.B) { + db := NewTestDB() + defer db.Close() + db.MustCreateBucket([]byte("bench")) + + b.ResetTimer() + for i := 0; i < b.N; i++ { + start := make(chan struct{}) + var wg sync.WaitGroup + + for major := 0; major < 10; major++ { + wg.Add(1) + go func(id uint32) { + defer wg.Done() + <-start + + insert100 := func(tx *bolt.Tx) error { + h := fnv.New32a() + buf := make([]byte, 4) + for minor := uint32(0); minor < 100; minor++ { + binary.LittleEndian.PutUint32(buf, uint32(id*100+minor)) + h.Reset() + h.Write(buf[:]) + k := h.Sum(nil) + b := tx.Bucket([]byte("bench")) + if err := b.Put(k, []byte("filler")); err != nil { + return err + } + } + return nil + } + if err := db.Update(insert100); err != nil { + b.Fatal(err) + } + }(uint32(major)) + } + close(start) + wg.Wait() + } + + b.StopTimer() + validateBatchBench(b, db) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/batch_example_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/batch_example_test.go new file mode 100644 index 000000000..b0d00935a --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/batch_example_test.go @@ -0,0 +1,148 @@ +package bolt_test + +import ( + "encoding/binary" + "fmt" + "io/ioutil" + "log" + "math/rand" + "net/http" + "net/http/httptest" + "os" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +// Set this to see how the counts are actually updated. +const verbose = false + +// Counter updates a counter in Bolt for every URL path requested. +type counter struct { + db *bolt.DB +} + +func (c counter) ServeHTTP(rw http.ResponseWriter, req *http.Request) { + // Communicates the new count from a successful database + // transaction. + var result uint64 + + increment := func(tx *bolt.Tx) error { + b, err := tx.CreateBucketIfNotExists([]byte("hits")) + if err != nil { + return err + } + key := []byte(req.URL.String()) + // Decode handles key not found for us. + count := decode(b.Get(key)) + 1 + b.Put(key, encode(count)) + // All good, communicate new count. + result = count + return nil + } + if err := c.db.Batch(increment); err != nil { + http.Error(rw, err.Error(), 500) + return + } + + if verbose { + log.Printf("server: %s: %d", req.URL.String(), result) + } + + rw.Header().Set("Content-Type", "application/octet-stream") + fmt.Fprintf(rw, "%d\n", result) +} + +func client(id int, base string, paths []string) error { + // Process paths in random order. + rng := rand.New(rand.NewSource(int64(id))) + permutation := rng.Perm(len(paths)) + + for i := range paths { + path := paths[permutation[i]] + resp, err := http.Get(base + path) + if err != nil { + return err + } + defer resp.Body.Close() + buf, err := ioutil.ReadAll(resp.Body) + if err != nil { + return err + } + if verbose { + log.Printf("client: %s: %s", path, buf) + } + } + return nil +} + +func ExampleDB_Batch() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Start our web server + count := counter{db} + srv := httptest.NewServer(count) + defer srv.Close() + + // Decrease the batch size to make things more interesting. + db.MaxBatchSize = 3 + + // Get every path multiple times concurrently. + const clients = 10 + paths := []string{ + "/foo", + "/bar", + "/baz", + "/quux", + "/thud", + "/xyzzy", + } + errors := make(chan error, clients) + for i := 0; i < clients; i++ { + go func(id int) { + errors <- client(id, srv.URL, paths) + }(i) + } + // Check all responses to make sure there's no error. + for i := 0; i < clients; i++ { + if err := <-errors; err != nil { + fmt.Printf("client error: %v", err) + return + } + } + + // Check the final result + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("hits")) + c := b.Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + fmt.Printf("hits to %s: %d\n", k, decode(v)) + } + return nil + }) + + // Output: + // hits to /bar: 10 + // hits to /baz: 10 + // hits to /foo: 10 + // hits to /quux: 10 + // hits to /thud: 10 + // hits to /xyzzy: 10 +} + +// encode marshals a counter. +func encode(n uint64) []byte { + buf := make([]byte, 8) + binary.BigEndian.PutUint64(buf, n) + return buf +} + +// decode unmarshals a counter. Nil buffers are decoded as 0. +func decode(buf []byte) uint64 { + if buf == nil { + return 0 + } + return binary.BigEndian.Uint64(buf) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/batch_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/batch_test.go new file mode 100644 index 000000000..05230a9aa --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/batch_test.go @@ -0,0 +1,167 @@ +package bolt_test + +import ( + "testing" + "time" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +// Ensure two functions can perform updates in a single batch. +func TestDB_Batch(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.MustCreateBucket([]byte("widgets")) + + // Iterate over multiple updates in separate goroutines. + n := 2 + ch := make(chan error) + for i := 0; i < n; i++ { + go func(i int) { + ch <- db.Batch(func(tx *bolt.Tx) error { + return tx.Bucket([]byte("widgets")).Put(u64tob(uint64(i)), []byte{}) + }) + }(i) + } + + // Check all responses to make sure there's no error. + for i := 0; i < n; i++ { + if err := <-ch; err != nil { + t.Fatal(err) + } + } + + // Ensure data is correct. + db.MustView(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for i := 0; i < n; i++ { + if v := b.Get(u64tob(uint64(i))); v == nil { + t.Errorf("key not found: %d", i) + } + } + return nil + }) +} + +func TestDB_Batch_Panic(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var sentinel int + var bork = &sentinel + var problem interface{} + var err error + + // Execute a function inside a batch that panics. + func() { + defer func() { + if p := recover(); p != nil { + problem = p + } + }() + err = db.Batch(func(tx *bolt.Tx) error { + panic(bork) + }) + }() + + // Verify there is no error. + if g, e := err, error(nil); g != e { + t.Fatalf("wrong error: %v != %v", g, e) + } + // Verify the panic was captured. + if g, e := problem, bork; g != e { + t.Fatalf("wrong error: %v != %v", g, e) + } +} + +func TestDB_BatchFull(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.MustCreateBucket([]byte("widgets")) + + const size = 3 + // buffered so we never leak goroutines + ch := make(chan error, size) + put := func(i int) { + ch <- db.Batch(func(tx *bolt.Tx) error { + return tx.Bucket([]byte("widgets")).Put(u64tob(uint64(i)), []byte{}) + }) + } + + db.MaxBatchSize = size + // high enough to never trigger here + db.MaxBatchDelay = 1 * time.Hour + + go put(1) + go put(2) + + // Give the batch a chance to exhibit bugs. + time.Sleep(10 * time.Millisecond) + + // not triggered yet + select { + case <-ch: + t.Fatalf("batch triggered too early") + default: + } + + go put(3) + + // Check all responses to make sure there's no error. + for i := 0; i < size; i++ { + if err := <-ch; err != nil { + t.Fatal(err) + } + } + + // Ensure data is correct. + db.MustView(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for i := 1; i <= size; i++ { + if v := b.Get(u64tob(uint64(i))); v == nil { + t.Errorf("key not found: %d", i) + } + } + return nil + }) +} + +func TestDB_BatchTime(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.MustCreateBucket([]byte("widgets")) + + const size = 1 + // buffered so we never leak goroutines + ch := make(chan error, size) + put := func(i int) { + ch <- db.Batch(func(tx *bolt.Tx) error { + return tx.Bucket([]byte("widgets")).Put(u64tob(uint64(i)), []byte{}) + }) + } + + db.MaxBatchSize = 1000 + db.MaxBatchDelay = 0 + + go put(1) + + // Batch must trigger by time alone. + + // Check all responses to make sure there's no error. + for i := 0; i < size; i++ { + if err := <-ch; err != nil { + t.Fatal(err) + } + } + + // Ensure data is correct. + db.MustView(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for i := 1; i <= size; i++ { + if v := b.Get(u64tob(uint64(i))); v == nil { + t.Errorf("key not found: %d", i) + } + } + return nil + }) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_386.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_386.go new file mode 100644 index 000000000..e659bfb91 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_386.go @@ -0,0 +1,7 @@ +package bolt + +// maxMapSize represents the largest mmap size supported by Bolt. +const maxMapSize = 0x7FFFFFFF // 2GB + +// maxAllocSize is the size used when creating array pointers. +const maxAllocSize = 0xFFFFFFF diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_amd64.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_amd64.go new file mode 100644 index 000000000..cca6b7eb7 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_amd64.go @@ -0,0 +1,7 @@ +package bolt + +// maxMapSize represents the largest mmap size supported by Bolt. +const maxMapSize = 0xFFFFFFFFFFFF // 256TB + +// maxAllocSize is the size used when creating array pointers. +const maxAllocSize = 0x7FFFFFFF diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_arm.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_arm.go new file mode 100644 index 000000000..e659bfb91 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_arm.go @@ -0,0 +1,7 @@ +package bolt + +// maxMapSize represents the largest mmap size supported by Bolt. +const maxMapSize = 0x7FFFFFFF // 2GB + +// maxAllocSize is the size used when creating array pointers. +const maxAllocSize = 0xFFFFFFF diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_linux.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_linux.go new file mode 100644 index 000000000..e9d1c907b --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_linux.go @@ -0,0 +1,12 @@ +package bolt + +import ( + "syscall" +) + +var odirect = syscall.O_DIRECT + +// fdatasync flushes written data to a file descriptor. +func fdatasync(db *DB) error { + return syscall.Fdatasync(int(db.file.Fd())) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_openbsd.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_openbsd.go new file mode 100644 index 000000000..7c1bef1a4 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_openbsd.go @@ -0,0 +1,29 @@ +package bolt + +import ( + "syscall" + "unsafe" +) + +const ( + msAsync = 1 << iota // perform asynchronous writes + msSync // perform synchronous writes + msInvalidate // invalidate cached data +) + +var odirect int + +func msync(db *DB) error { + _, _, errno := syscall.Syscall(syscall.SYS_MSYNC, uintptr(unsafe.Pointer(db.data)), uintptr(db.datasz), msInvalidate) + if errno != 0 { + return errno + } + return nil +} + +func fdatasync(db *DB) error { + if db.data != nil { + return msync(db) + } + return db.file.Sync() +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_test.go new file mode 100644 index 000000000..b7bea1fc5 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_test.go @@ -0,0 +1,36 @@ +package bolt_test + +import ( + "fmt" + "path/filepath" + "reflect" + "runtime" + "testing" +) + +// assert fails the test if the condition is false. +func assert(tb testing.TB, condition bool, msg string, v ...interface{}) { + if !condition { + _, file, line, _ := runtime.Caller(1) + fmt.Printf("\033[31m%s:%d: "+msg+"\033[39m\n\n", append([]interface{}{filepath.Base(file), line}, v...)...) + tb.FailNow() + } +} + +// ok fails the test if an err is not nil. +func ok(tb testing.TB, err error) { + if err != nil { + _, file, line, _ := runtime.Caller(1) + fmt.Printf("\033[31m%s:%d: unexpected error: %s\033[39m\n\n", filepath.Base(file), line, err.Error()) + tb.FailNow() + } +} + +// equals fails the test if exp is not equal to act. +func equals(tb testing.TB, exp, act interface{}) { + if !reflect.DeepEqual(exp, act) { + _, file, line, _ := runtime.Caller(1) + fmt.Printf("\033[31m%s:%d:\n\n\texp: %#v\n\n\tgot: %#v\033[39m\n\n", filepath.Base(file), line, exp, act) + tb.FailNow() + } +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_unix.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_unix.go new file mode 100644 index 000000000..e222cfdcc --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_unix.go @@ -0,0 +1,80 @@ +// +build !windows,!plan9 + +package bolt + +import ( + "fmt" + "os" + "syscall" + "time" + "unsafe" +) + +// flock acquires an advisory lock on a file descriptor. +func flock(f *os.File, timeout time.Duration) error { + var t time.Time + for { + // If we're beyond our timeout then return an error. + // This can only occur after we've attempted a flock once. + if t.IsZero() { + t = time.Now() + } else if timeout > 0 && time.Since(t) > timeout { + return ErrTimeout + } + + // Otherwise attempt to obtain an exclusive lock. + err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB) + if err == nil { + return nil + } else if err != syscall.EWOULDBLOCK { + return err + } + + // Wait for a bit and try again. + time.Sleep(50 * time.Millisecond) + } +} + +// funlock releases an advisory lock on a file descriptor. +func funlock(f *os.File) error { + return syscall.Flock(int(f.Fd()), syscall.LOCK_UN) +} + +// mmap memory maps a DB's data file. +func mmap(db *DB, sz int) error { + // Truncate and fsync to ensure file size metadata is flushed. + // https://github.com/boltdb/bolt/issues/284 + if err := db.file.Truncate(int64(sz)); err != nil { + return fmt.Errorf("file resize error: %s", err) + } + if err := db.file.Sync(); err != nil { + return fmt.Errorf("file sync error: %s", err) + } + + // Map the data file to memory. + b, err := syscall.Mmap(int(db.file.Fd()), 0, sz, syscall.PROT_READ, syscall.MAP_SHARED) + if err != nil { + return err + } + + // Save the original byte slice and convert to a byte array pointer. + db.dataref = b + db.data = (*[maxMapSize]byte)(unsafe.Pointer(&b[0])) + db.datasz = sz + return nil +} + +// munmap unmaps a DB's data file from memory. +func munmap(db *DB) error { + // Ignore the unmap if we have no mapped data. + if db.dataref == nil { + return nil + } + + // Unmap using the original byte slice. + err := syscall.Munmap(db.dataref) + db.dataref = nil + db.data = nil + db.datasz = 0 + return err +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_windows.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_windows.go new file mode 100644 index 000000000..c8539d40b --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bolt_windows.go @@ -0,0 +1,74 @@ +package bolt + +import ( + "fmt" + "os" + "syscall" + "time" + "unsafe" +) + +var odirect int + +// fdatasync flushes written data to a file descriptor. +func fdatasync(db *DB) error { + return db.file.Sync() +} + +// flock acquires an advisory lock on a file descriptor. +func flock(f *os.File, _ time.Duration) error { + return nil +} + +// funlock releases an advisory lock on a file descriptor. +func funlock(f *os.File) error { + return nil +} + +// mmap memory maps a DB's data file. +// Based on: https://github.com/edsrzf/mmap-go +func mmap(db *DB, sz int) error { + // Truncate the database to the size of the mmap. + if err := db.file.Truncate(int64(sz)); err != nil { + return fmt.Errorf("truncate: %s", err) + } + + // Open a file mapping handle. + sizelo := uint32(sz >> 32) + sizehi := uint32(sz) & 0xffffffff + h, errno := syscall.CreateFileMapping(syscall.Handle(db.file.Fd()), nil, syscall.PAGE_READONLY, sizelo, sizehi, nil) + if h == 0 { + return os.NewSyscallError("CreateFileMapping", errno) + } + + // Create the memory map. + addr, errno := syscall.MapViewOfFile(h, syscall.FILE_MAP_READ, 0, 0, uintptr(sz)) + if addr == 0 { + return os.NewSyscallError("MapViewOfFile", errno) + } + + // Close mapping handle. + if err := syscall.CloseHandle(syscall.Handle(h)); err != nil { + return os.NewSyscallError("CloseHandle", err) + } + + // Convert to a byte array. + db.data = ((*[maxMapSize]byte)(unsafe.Pointer(addr))) + db.datasz = sz + + return nil +} + +// munmap unmaps a pointer from a file. +// Based on: https://github.com/edsrzf/mmap-go +func munmap(db *DB) error { + if db.data == nil { + return nil + } + + addr := (uintptr)(unsafe.Pointer(&db.data[0])) + if err := syscall.UnmapViewOfFile(addr); err != nil { + return os.NewSyscallError("UnmapViewOfFile", err) + } + return nil +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/boltsync_unix.go b/Godeps/_workspace/src/github.com/boltdb/bolt/boltsync_unix.go new file mode 100644 index 000000000..8db89776f --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/boltsync_unix.go @@ -0,0 +1,10 @@ +// +build !windows,!plan9,!linux,!openbsd + +package bolt + +var odirect int + +// fdatasync flushes written data to a file descriptor. +func fdatasync(db *DB) error { + return db.file.Sync() +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bucket.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bucket.go new file mode 100644 index 000000000..676699210 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bucket.go @@ -0,0 +1,743 @@ +package bolt + +import ( + "bytes" + "fmt" + "unsafe" +) + +const ( + // MaxKeySize is the maximum length of a key, in bytes. + MaxKeySize = 32768 + + // MaxValueSize is the maximum length of a value, in bytes. + MaxValueSize = 4294967295 +) + +const ( + maxUint = ^uint(0) + minUint = 0 + maxInt = int(^uint(0) >> 1) + minInt = -maxInt - 1 +) + +const bucketHeaderSize = int(unsafe.Sizeof(bucket{})) + +const ( + minFillPercent = 0.1 + maxFillPercent = 1.0 +) + +// DefaultFillPercent is the percentage that split pages are filled. +// This value can be changed by setting Bucket.FillPercent. +const DefaultFillPercent = 0.5 + +// Bucket represents a collection of key/value pairs inside the database. +type Bucket struct { + *bucket + tx *Tx // the associated transaction + buckets map[string]*Bucket // subbucket cache + page *page // inline page reference + rootNode *node // materialized node for the root page. + nodes map[pgid]*node // node cache + + // Sets the threshold for filling nodes when they split. By default, + // the bucket will fill to 50% but it can be useful to increase this + // amount if you know that your write workloads are mostly append-only. + // + // This is non-persisted across transactions so it must be set in every Tx. + FillPercent float64 +} + +// bucket represents the on-file representation of a bucket. +// This is stored as the "value" of a bucket key. If the bucket is small enough, +// then its root page can be stored inline in the "value", after the bucket +// header. In the case of inline buckets, the "root" will be 0. +type bucket struct { + root pgid // page id of the bucket's root-level page + sequence uint64 // monotonically incrementing, used by NextSequence() +} + +// newBucket returns a new bucket associated with a transaction. +func newBucket(tx *Tx) Bucket { + var b = Bucket{tx: tx, FillPercent: DefaultFillPercent} + if tx.writable { + b.buckets = make(map[string]*Bucket) + b.nodes = make(map[pgid]*node) + } + return b +} + +// Tx returns the tx of the bucket. +func (b *Bucket) Tx() *Tx { + return b.tx +} + +// Root returns the root of the bucket. +func (b *Bucket) Root() pgid { + return b.root +} + +// Writable returns whether the bucket is writable. +func (b *Bucket) Writable() bool { + return b.tx.writable +} + +// Cursor creates a cursor associated with the bucket. +// The cursor is only valid as long as the transaction is open. +// Do not use a cursor after the transaction is closed. +func (b *Bucket) Cursor() *Cursor { + // Update transaction statistics. + b.tx.stats.CursorCount++ + + // Allocate and return a cursor. + return &Cursor{ + bucket: b, + stack: make([]elemRef, 0), + } +} + +// Bucket retrieves a nested bucket by name. +// Returns nil if the bucket does not exist. +func (b *Bucket) Bucket(name []byte) *Bucket { + if b.buckets != nil { + if child := b.buckets[string(name)]; child != nil { + return child + } + } + + // Move cursor to key. + c := b.Cursor() + k, v, flags := c.seek(name) + + // Return nil if the key doesn't exist or it is not a bucket. + if !bytes.Equal(name, k) || (flags&bucketLeafFlag) == 0 { + return nil + } + + // Otherwise create a bucket and cache it. + var child = b.openBucket(v) + if b.buckets != nil { + b.buckets[string(name)] = child + } + + return child +} + +// Helper method that re-interprets a sub-bucket value +// from a parent into a Bucket +func (b *Bucket) openBucket(value []byte) *Bucket { + var child = newBucket(b.tx) + + // If this is a writable transaction then we need to copy the bucket entry. + // Read-only transactions can point directly at the mmap entry. + if b.tx.writable { + child.bucket = &bucket{} + *child.bucket = *(*bucket)(unsafe.Pointer(&value[0])) + } else { + child.bucket = (*bucket)(unsafe.Pointer(&value[0])) + } + + // Save a reference to the inline page if the bucket is inline. + if child.root == 0 { + child.page = (*page)(unsafe.Pointer(&value[bucketHeaderSize])) + } + + return &child +} + +// CreateBucket creates a new bucket at the given key and returns the new bucket. +// Returns an error if the key already exists, if the bucket name is blank, or if the bucket name is too long. +func (b *Bucket) CreateBucket(key []byte) (*Bucket, error) { + if b.tx.db == nil { + return nil, ErrTxClosed + } else if !b.tx.writable { + return nil, ErrTxNotWritable + } else if len(key) == 0 { + return nil, ErrBucketNameRequired + } + + // Move cursor to correct position. + c := b.Cursor() + k, _, flags := c.seek(key) + + // Return an error if there is an existing key. + if bytes.Equal(key, k) { + if (flags & bucketLeafFlag) != 0 { + return nil, ErrBucketExists + } else { + return nil, ErrIncompatibleValue + } + } + + // Create empty, inline bucket. + var bucket = Bucket{ + bucket: &bucket{}, + rootNode: &node{isLeaf: true}, + FillPercent: DefaultFillPercent, + } + var value = bucket.write() + + // Insert into node. + key = cloneBytes(key) + c.node().put(key, key, value, 0, bucketLeafFlag) + + // Since subbuckets are not allowed on inline buckets, we need to + // dereference the inline page, if it exists. This will cause the bucket + // to be treated as a regular, non-inline bucket for the rest of the tx. + b.page = nil + + return b.Bucket(key), nil +} + +// CreateBucketIfNotExists creates a new bucket if it doesn't already exist and returns a reference to it. +// Returns an error if the bucket name is blank, or if the bucket name is too long. +func (b *Bucket) CreateBucketIfNotExists(key []byte) (*Bucket, error) { + child, err := b.CreateBucket(key) + if err == ErrBucketExists { + return b.Bucket(key), nil + } else if err != nil { + return nil, err + } + return child, nil +} + +// DeleteBucket deletes a bucket at the given key. +// Returns an error if the bucket does not exists, or if the key represents a non-bucket value. +func (b *Bucket) DeleteBucket(key []byte) error { + if b.tx.db == nil { + return ErrTxClosed + } else if !b.Writable() { + return ErrTxNotWritable + } + + // Move cursor to correct position. + c := b.Cursor() + k, _, flags := c.seek(key) + + // Return an error if bucket doesn't exist or is not a bucket. + if !bytes.Equal(key, k) { + return ErrBucketNotFound + } else if (flags & bucketLeafFlag) == 0 { + return ErrIncompatibleValue + } + + // Recursively delete all child buckets. + child := b.Bucket(key) + err := child.ForEach(func(k, v []byte) error { + if v == nil { + if err := child.DeleteBucket(k); err != nil { + return fmt.Errorf("delete bucket: %s", err) + } + } + return nil + }) + if err != nil { + return err + } + + // Remove cached copy. + delete(b.buckets, string(key)) + + // Release all bucket pages to freelist. + child.nodes = nil + child.rootNode = nil + child.free() + + // Delete the node if we have a matching key. + c.node().del(key) + + return nil +} + +// Get retrieves the value for a key in the bucket. +// Returns a nil value if the key does not exist or if the key is a nested bucket. +// The returned value is only valid for the life of the transaction. +func (b *Bucket) Get(key []byte) []byte { + k, v, flags := b.Cursor().seek(key) + + // Return nil if this is a bucket. + if (flags & bucketLeafFlag) != 0 { + return nil + } + + // If our target node isn't the same key as what's passed in then return nil. + if !bytes.Equal(key, k) { + return nil + } + return v +} + +// Put sets the value for a key in the bucket. +// If the key exist then its previous value will be overwritten. +// Returns an error if the bucket was created from a read-only transaction, if the key is blank, if the key is too large, or if the value is too large. +func (b *Bucket) Put(key []byte, value []byte) error { + if b.tx.db == nil { + return ErrTxClosed + } else if !b.Writable() { + return ErrTxNotWritable + } else if len(key) == 0 { + return ErrKeyRequired + } else if len(key) > MaxKeySize { + return ErrKeyTooLarge + } else if int64(len(value)) > MaxValueSize { + return ErrValueTooLarge + } + + // Move cursor to correct position. + c := b.Cursor() + k, _, flags := c.seek(key) + + // Return an error if there is an existing key with a bucket value. + if bytes.Equal(key, k) && (flags&bucketLeafFlag) != 0 { + return ErrIncompatibleValue + } + + // Insert into node. + key = cloneBytes(key) + c.node().put(key, key, value, 0, 0) + + return nil +} + +// Delete removes a key from the bucket. +// If the key does not exist then nothing is done and a nil error is returned. +// Returns an error if the bucket was created from a read-only transaction. +func (b *Bucket) Delete(key []byte) error { + if b.tx.db == nil { + return ErrTxClosed + } else if !b.Writable() { + return ErrTxNotWritable + } + + // Move cursor to correct position. + c := b.Cursor() + _, _, flags := c.seek(key) + + // Return an error if there is already existing bucket value. + if (flags & bucketLeafFlag) != 0 { + return ErrIncompatibleValue + } + + // Delete the node if we have a matching key. + c.node().del(key) + + return nil +} + +// NextSequence returns an autoincrementing integer for the bucket. +func (b *Bucket) NextSequence() (uint64, error) { + if b.tx.db == nil { + return 0, ErrTxClosed + } else if !b.Writable() { + return 0, ErrTxNotWritable + } + + // Materialize the root node if it hasn't been already so that the + // bucket will be saved during commit. + if b.rootNode == nil { + _ = b.node(b.root, nil) + } + + // Increment and return the sequence. + b.bucket.sequence++ + return b.bucket.sequence, nil +} + +// ForEach executes a function for each key/value pair in a bucket. +// If the provided function returns an error then the iteration is stopped and +// the error is returned to the caller. +func (b *Bucket) ForEach(fn func(k, v []byte) error) error { + if b.tx.db == nil { + return ErrTxClosed + } + c := b.Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + if err := fn(k, v); err != nil { + return err + } + } + return nil +} + +// Stat returns stats on a bucket. +func (b *Bucket) Stats() BucketStats { + var s, subStats BucketStats + pageSize := b.tx.db.pageSize + s.BucketN += 1 + if b.root == 0 { + s.InlineBucketN += 1 + } + b.forEachPage(func(p *page, depth int) { + if (p.flags & leafPageFlag) != 0 { + s.KeyN += int(p.count) + + // used totals the used bytes for the page + used := pageHeaderSize + + if p.count != 0 { + // If page has any elements, add all element headers. + used += leafPageElementSize * int(p.count-1) + + // Add all element key, value sizes. + // The computation takes advantage of the fact that the position + // of the last element's key/value equals to the total of the sizes + // of all previous elements' keys and values. + // It also includes the last element's header. + lastElement := p.leafPageElement(p.count - 1) + used += int(lastElement.pos + lastElement.ksize + lastElement.vsize) + } + + if b.root == 0 { + // For inlined bucket just update the inline stats + s.InlineBucketInuse += used + } else { + // For non-inlined bucket update all the leaf stats + s.LeafPageN++ + s.LeafInuse += used + s.LeafOverflowN += int(p.overflow) + + // Collect stats from sub-buckets. + // Do that by iterating over all element headers + // looking for the ones with the bucketLeafFlag. + for i := uint16(0); i < p.count; i++ { + e := p.leafPageElement(i) + if (e.flags & bucketLeafFlag) != 0 { + // For any bucket element, open the element value + // and recursively call Stats on the contained bucket. + subStats.Add(b.openBucket(e.value()).Stats()) + } + } + } + } else if (p.flags & branchPageFlag) != 0 { + s.BranchPageN++ + lastElement := p.branchPageElement(p.count - 1) + + // used totals the used bytes for the page + // Add header and all element headers. + used := pageHeaderSize + (branchPageElementSize * int(p.count-1)) + + // Add size of all keys and values. + // Again, use the fact that last element's position equals to + // the total of key, value sizes of all previous elements. + used += int(lastElement.pos + lastElement.ksize) + s.BranchInuse += used + s.BranchOverflowN += int(p.overflow) + } + + // Keep track of maximum page depth. + if depth+1 > s.Depth { + s.Depth = (depth + 1) + } + }) + + // Alloc stats can be computed from page counts and pageSize. + s.BranchAlloc = (s.BranchPageN + s.BranchOverflowN) * pageSize + s.LeafAlloc = (s.LeafPageN + s.LeafOverflowN) * pageSize + + // Add the max depth of sub-buckets to get total nested depth. + s.Depth += subStats.Depth + // Add the stats for all sub-buckets + s.Add(subStats) + return s +} + +// forEachPage iterates over every page in a bucket, including inline pages. +func (b *Bucket) forEachPage(fn func(*page, int)) { + // If we have an inline page then just use that. + if b.page != nil { + fn(b.page, 0) + return + } + + // Otherwise traverse the page hierarchy. + b.tx.forEachPage(b.root, 0, fn) +} + +// forEachPageNode iterates over every page (or node) in a bucket. +// This also includes inline pages. +func (b *Bucket) forEachPageNode(fn func(*page, *node, int)) { + // If we have an inline page or root node then just use that. + if b.page != nil { + fn(b.page, nil, 0) + return + } + b._forEachPageNode(b.root, 0, fn) +} + +func (b *Bucket) _forEachPageNode(pgid pgid, depth int, fn func(*page, *node, int)) { + var p, n = b.pageNode(pgid) + + // Execute function. + fn(p, n, depth) + + // Recursively loop over children. + if p != nil { + if (p.flags & branchPageFlag) != 0 { + for i := 0; i < int(p.count); i++ { + elem := p.branchPageElement(uint16(i)) + b._forEachPageNode(elem.pgid, depth+1, fn) + } + } + } else { + if !n.isLeaf { + for _, inode := range n.inodes { + b._forEachPageNode(inode.pgid, depth+1, fn) + } + } + } +} + +// spill writes all the nodes for this bucket to dirty pages. +func (b *Bucket) spill() error { + // Spill all child buckets first. + for name, child := range b.buckets { + // If the child bucket is small enough and it has no child buckets then + // write it inline into the parent bucket's page. Otherwise spill it + // like a normal bucket and make the parent value a pointer to the page. + var value []byte + if child.inlineable() { + child.free() + value = child.write() + } else { + if err := child.spill(); err != nil { + return err + } + + // Update the child bucket header in this bucket. + value = make([]byte, unsafe.Sizeof(bucket{})) + var bucket = (*bucket)(unsafe.Pointer(&value[0])) + *bucket = *child.bucket + } + + // Skip writing the bucket if there are no materialized nodes. + if child.rootNode == nil { + continue + } + + // Update parent node. + var c = b.Cursor() + k, _, flags := c.seek([]byte(name)) + if !bytes.Equal([]byte(name), k) { + panic(fmt.Sprintf("misplaced bucket header: %x -> %x", []byte(name), k)) + } + if flags&bucketLeafFlag == 0 { + panic(fmt.Sprintf("unexpected bucket header flag: %x", flags)) + } + c.node().put([]byte(name), []byte(name), value, 0, bucketLeafFlag) + } + + // Ignore if there's not a materialized root node. + if b.rootNode == nil { + return nil + } + + // Spill nodes. + if err := b.rootNode.spill(); err != nil { + return err + } + b.rootNode = b.rootNode.root() + + // Update the root node for this bucket. + if b.rootNode.pgid >= b.tx.meta.pgid { + panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", b.rootNode.pgid, b.tx.meta.pgid)) + } + b.root = b.rootNode.pgid + + return nil +} + +// inlineable returns true if a bucket is small enough to be written inline +// and if it contains no subbuckets. Otherwise returns false. +func (b *Bucket) inlineable() bool { + var n = b.rootNode + + // Bucket must only contain a single leaf node. + if n == nil || !n.isLeaf { + return false + } + + // Bucket is not inlineable if it contains subbuckets or if it goes beyond + // our threshold for inline bucket size. + var size = pageHeaderSize + for _, inode := range n.inodes { + size += leafPageElementSize + len(inode.key) + len(inode.value) + + if inode.flags&bucketLeafFlag != 0 { + return false + } else if size > b.maxInlineBucketSize() { + return false + } + } + + return true +} + +// Returns the maximum total size of a bucket to make it a candidate for inlining. +func (b *Bucket) maxInlineBucketSize() int { + return b.tx.db.pageSize / 4 +} + +// write allocates and writes a bucket to a byte slice. +func (b *Bucket) write() []byte { + // Allocate the appropriate size. + var n = b.rootNode + var value = make([]byte, bucketHeaderSize+n.size()) + + // Write a bucket header. + var bucket = (*bucket)(unsafe.Pointer(&value[0])) + *bucket = *b.bucket + + // Convert byte slice to a fake page and write the root node. + var p = (*page)(unsafe.Pointer(&value[bucketHeaderSize])) + n.write(p) + + return value +} + +// rebalance attempts to balance all nodes. +func (b *Bucket) rebalance() { + for _, n := range b.nodes { + n.rebalance() + } + for _, child := range b.buckets { + child.rebalance() + } +} + +// node creates a node from a page and associates it with a given parent. +func (b *Bucket) node(pgid pgid, parent *node) *node { + _assert(b.nodes != nil, "nodes map expected") + + // Retrieve node if it's already been created. + if n := b.nodes[pgid]; n != nil { + return n + } + + // Otherwise create a node and cache it. + n := &node{bucket: b, parent: parent} + if parent == nil { + b.rootNode = n + } else { + parent.children = append(parent.children, n) + } + + // Use the inline page if this is an inline bucket. + var p = b.page + if p == nil { + p = b.tx.page(pgid) + } + + // Read the page into the node and cache it. + n.read(p) + b.nodes[pgid] = n + + // Update statistics. + b.tx.stats.NodeCount++ + + return n +} + +// free recursively frees all pages in the bucket. +func (b *Bucket) free() { + if b.root == 0 { + return + } + + var tx = b.tx + b.forEachPageNode(func(p *page, n *node, _ int) { + if p != nil { + tx.db.freelist.free(tx.meta.txid, p) + } else { + n.free() + } + }) + b.root = 0 +} + +// dereference removes all references to the old mmap. +func (b *Bucket) dereference() { + if b.rootNode != nil { + b.rootNode.root().dereference() + } + + for _, child := range b.buckets { + child.dereference() + } +} + +// pageNode returns the in-memory node, if it exists. +// Otherwise returns the underlying page. +func (b *Bucket) pageNode(id pgid) (*page, *node) { + // Inline buckets have a fake page embedded in their value so treat them + // differently. We'll return the rootNode (if available) or the fake page. + if b.root == 0 { + if id != 0 { + panic(fmt.Sprintf("inline bucket non-zero page access(2): %d != 0", id)) + } + if b.rootNode != nil { + return nil, b.rootNode + } + return b.page, nil + } + + // Check the node cache for non-inline buckets. + if b.nodes != nil { + if n := b.nodes[id]; n != nil { + return nil, n + } + } + + // Finally lookup the page from the transaction if no node is materialized. + return b.tx.page(id), nil +} + +// BucketStats records statistics about resources used by a bucket. +type BucketStats struct { + // Page count statistics. + BranchPageN int // number of logical branch pages + BranchOverflowN int // number of physical branch overflow pages + LeafPageN int // number of logical leaf pages + LeafOverflowN int // number of physical leaf overflow pages + + // Tree statistics. + KeyN int // number of keys/value pairs + Depth int // number of levels in B+tree + + // Page size utilization. + BranchAlloc int // bytes allocated for physical branch pages + BranchInuse int // bytes actually used for branch data + LeafAlloc int // bytes allocated for physical leaf pages + LeafInuse int // bytes actually used for leaf data + + // Bucket statistics + BucketN int // total number of buckets including the top bucket + InlineBucketN int // total number on inlined buckets + InlineBucketInuse int // bytes used for inlined buckets (also accounted for in LeafInuse) +} + +func (s *BucketStats) Add(other BucketStats) { + s.BranchPageN += other.BranchPageN + s.BranchOverflowN += other.BranchOverflowN + s.LeafPageN += other.LeafPageN + s.LeafOverflowN += other.LeafOverflowN + s.KeyN += other.KeyN + if s.Depth < other.Depth { + s.Depth = other.Depth + } + s.BranchAlloc += other.BranchAlloc + s.BranchInuse += other.BranchInuse + s.LeafAlloc += other.LeafAlloc + s.LeafInuse += other.LeafInuse + + s.BucketN += other.BucketN + s.InlineBucketN += other.InlineBucketN + s.InlineBucketInuse += other.InlineBucketInuse +} + +// cloneBytes returns a copy of a given slice. +func cloneBytes(v []byte) []byte { + var clone = make([]byte, len(v)) + copy(clone, v) + return clone +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/bucket_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/bucket_test.go new file mode 100644 index 000000000..7ceb6f536 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/bucket_test.go @@ -0,0 +1,1153 @@ +package bolt_test + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "math/rand" + "os" + "strconv" + "strings" + "testing" + "testing/quick" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +// Ensure that a bucket that gets a non-existent key returns nil. +func TestBucket_Get_NonExistent(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + assert(t, value == nil, "") + return nil + }) +} + +// Ensure that a bucket can read a value that is not flushed yet. +func TestBucket_Get_FromNode(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + b.Put([]byte("foo"), []byte("bar")) + value := b.Get([]byte("foo")) + equals(t, []byte("bar"), value) + return nil + }) +} + +// Ensure that a bucket retrieved via Get() returns a nil. +func TestBucket_Get_IncompatibleValue(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")) + ok(t, err) + assert(t, tx.Bucket([]byte("widgets")).Get([]byte("foo")) == nil, "") + return nil + }) +} + +// Ensure that a bucket can write a key/value. +func TestBucket_Put(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + err := tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + ok(t, err) + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + equals(t, value, []byte("bar")) + return nil + }) +} + +// Ensure that a bucket can rewrite a key in the same transaction. +func TestBucket_Put_Repeat(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + ok(t, b.Put([]byte("foo"), []byte("bar"))) + ok(t, b.Put([]byte("foo"), []byte("baz"))) + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + equals(t, value, []byte("baz")) + return nil + }) +} + +// Ensure that a bucket can write a bunch of large values. +func TestBucket_Put_Large(t *testing.T) { + db := NewTestDB() + defer db.Close() + + count, factor := 100, 200 + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + for i := 1; i < count; i++ { + ok(t, b.Put([]byte(strings.Repeat("0", i*factor)), []byte(strings.Repeat("X", (count-i)*factor)))) + } + return nil + }) + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for i := 1; i < count; i++ { + value := b.Get([]byte(strings.Repeat("0", i*factor))) + equals(t, []byte(strings.Repeat("X", (count-i)*factor)), value) + } + return nil + }) +} + +// Ensure that a database can perform multiple large appends safely. +func TestDB_Put_VeryLarge(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + n, batchN := 400000, 200000 + ksize, vsize := 8, 500 + + db := NewTestDB() + defer db.Close() + + for i := 0; i < n; i += batchN { + err := db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists([]byte("widgets")) + for j := 0; j < batchN; j++ { + k, v := make([]byte, ksize), make([]byte, vsize) + binary.BigEndian.PutUint32(k, uint32(i+j)) + ok(t, b.Put(k, v)) + } + return nil + }) + ok(t, err) + } +} + +// Ensure that a setting a value on a key with a bucket value returns an error. +func TestBucket_Put_IncompatibleValue(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")) + ok(t, err) + equals(t, bolt.ErrIncompatibleValue, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))) + return nil + }) +} + +// Ensure that a setting a value while the transaction is closed returns an error. +func TestBucket_Put_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + tx.Rollback() + equals(t, bolt.ErrTxClosed, b.Put([]byte("foo"), []byte("bar"))) +} + +// Ensure that setting a value on a read-only bucket returns an error. +func TestBucket_Put_ReadOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + return nil + }) + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + err := b.Put([]byte("foo"), []byte("bar")) + equals(t, err, bolt.ErrTxNotWritable) + return nil + }) +} + +// Ensure that a bucket can delete an existing key. +func TestBucket_Delete(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + err := tx.Bucket([]byte("widgets")).Delete([]byte("foo")) + ok(t, err) + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + assert(t, value == nil, "") + return nil + }) +} + +// Ensure that deleting a large set of keys will work correctly. +func TestBucket_Delete_Large(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + var b, _ = tx.CreateBucket([]byte("widgets")) + for i := 0; i < 100; i++ { + ok(t, b.Put([]byte(strconv.Itoa(i)), []byte(strings.Repeat("*", 1024)))) + } + return nil + }) + db.Update(func(tx *bolt.Tx) error { + var b = tx.Bucket([]byte("widgets")) + for i := 0; i < 100; i++ { + ok(t, b.Delete([]byte(strconv.Itoa(i)))) + } + return nil + }) + db.View(func(tx *bolt.Tx) error { + var b = tx.Bucket([]byte("widgets")) + for i := 0; i < 100; i++ { + assert(t, b.Get([]byte(strconv.Itoa(i))) == nil, "") + } + return nil + }) +} + +// Deleting a very large list of keys will cause the freelist to use overflow. +func TestBucket_Delete_FreelistOverflow(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + db := NewTestDB() + defer db.Close() + k := make([]byte, 16) + for i := uint64(0); i < 10000; i++ { + err := db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucketIfNotExists([]byte("0")) + if err != nil { + t.Fatalf("bucket error: %s", err) + } + + for j := uint64(0); j < 1000; j++ { + binary.BigEndian.PutUint64(k[:8], i) + binary.BigEndian.PutUint64(k[8:], j) + if err := b.Put(k, nil); err != nil { + t.Fatalf("put error: %s", err) + } + } + + return nil + }) + + if err != nil { + t.Fatalf("update error: %s", err) + } + } + + // Delete all of them in one large transaction + err := db.Update(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("0")) + c := b.Cursor() + for k, _ := c.First(); k != nil; k, _ = c.Next() { + b.Delete(k) + } + return nil + }) + + // Check that a freelist overflow occurred. + ok(t, err) +} + +// Ensure that accessing and updating nested buckets is ok across transactions. +func TestBucket_Nested(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + // Create a widgets bucket. + b, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + + // Create a widgets/foo bucket. + _, err = b.CreateBucket([]byte("foo")) + ok(t, err) + + // Create a widgets/bar key. + ok(t, b.Put([]byte("bar"), []byte("0000"))) + + return nil + }) + db.MustCheck() + + // Update widgets/bar. + db.Update(func(tx *bolt.Tx) error { + var b = tx.Bucket([]byte("widgets")) + ok(t, b.Put([]byte("bar"), []byte("xxxx"))) + return nil + }) + db.MustCheck() + + // Cause a split. + db.Update(func(tx *bolt.Tx) error { + var b = tx.Bucket([]byte("widgets")) + for i := 0; i < 10000; i++ { + ok(t, b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i)))) + } + return nil + }) + db.MustCheck() + + // Insert into widgets/foo/baz. + db.Update(func(tx *bolt.Tx) error { + var b = tx.Bucket([]byte("widgets")) + ok(t, b.Bucket([]byte("foo")).Put([]byte("baz"), []byte("yyyy"))) + return nil + }) + db.MustCheck() + + // Verify. + db.View(func(tx *bolt.Tx) error { + var b = tx.Bucket([]byte("widgets")) + equals(t, []byte("yyyy"), b.Bucket([]byte("foo")).Get([]byte("baz"))) + equals(t, []byte("xxxx"), b.Get([]byte("bar"))) + for i := 0; i < 10000; i++ { + equals(t, []byte(strconv.Itoa(i)), b.Get([]byte(strconv.Itoa(i)))) + } + return nil + }) +} + +// Ensure that deleting a bucket using Delete() returns an error. +func TestBucket_Delete_Bucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + _, err := b.CreateBucket([]byte("foo")) + ok(t, err) + equals(t, bolt.ErrIncompatibleValue, b.Delete([]byte("foo"))) + return nil + }) +} + +// Ensure that deleting a key on a read-only bucket returns an error. +func TestBucket_Delete_ReadOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + return nil + }) + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + err := b.Delete([]byte("foo")) + equals(t, err, bolt.ErrTxNotWritable) + return nil + }) +} + +// Ensure that a deleting value while the transaction is closed returns an error. +func TestBucket_Delete_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + tx.Rollback() + equals(t, bolt.ErrTxClosed, b.Delete([]byte("foo"))) +} + +// Ensure that deleting a bucket causes nested buckets to be deleted. +func TestBucket_DeleteBucket_Nested(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")) + ok(t, err) + _, err = tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).CreateBucket([]byte("bar")) + ok(t, err) + ok(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")).Put([]byte("baz"), []byte("bat"))) + ok(t, tx.Bucket([]byte("widgets")).DeleteBucket([]byte("foo"))) + return nil + }) +} + +// Ensure that deleting a bucket causes nested buckets to be deleted after they have been committed. +func TestBucket_DeleteBucket_Nested2(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + _, err := tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")) + ok(t, err) + _, err = tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).CreateBucket([]byte("bar")) + ok(t, err) + ok(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")).Put([]byte("baz"), []byte("bat"))) + return nil + }) + db.Update(func(tx *bolt.Tx) error { + assert(t, tx.Bucket([]byte("widgets")) != nil, "") + assert(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")) != nil, "") + assert(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")) != nil, "") + equals(t, []byte("bat"), tx.Bucket([]byte("widgets")).Bucket([]byte("foo")).Bucket([]byte("bar")).Get([]byte("baz"))) + ok(t, tx.DeleteBucket([]byte("widgets"))) + return nil + }) + db.View(func(tx *bolt.Tx) error { + assert(t, tx.Bucket([]byte("widgets")) == nil, "") + return nil + }) +} + +// Ensure that deleting a child bucket with multiple pages causes all pages to get collected. +func TestBucket_DeleteBucket_Large(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + _, err = tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")) + ok(t, err) + b := tx.Bucket([]byte("widgets")).Bucket([]byte("foo")) + for i := 0; i < 1000; i++ { + ok(t, b.Put([]byte(fmt.Sprintf("%d", i)), []byte(fmt.Sprintf("%0100d", i)))) + } + return nil + }) + db.Update(func(tx *bolt.Tx) error { + ok(t, tx.DeleteBucket([]byte("widgets"))) + return nil + }) + + // NOTE: Consistency check in TestDB.Close() will panic if pages not freed properly. +} + +// Ensure that a simple value retrieved via Bucket() returns a nil. +func TestBucket_Bucket_IncompatibleValue(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))) + assert(t, tx.Bucket([]byte("widgets")).Bucket([]byte("foo")) == nil, "") + return nil + }) +} + +// Ensure that creating a bucket on an existing non-bucket key returns an error. +func TestBucket_CreateBucket_IncompatibleValue(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))) + _, err = tx.Bucket([]byte("widgets")).CreateBucket([]byte("foo")) + equals(t, bolt.ErrIncompatibleValue, err) + return nil + }) +} + +// Ensure that deleting a bucket on an existing non-bucket key returns an error. +func TestBucket_DeleteBucket_IncompatibleValue(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))) + equals(t, bolt.ErrIncompatibleValue, tx.Bucket([]byte("widgets")).DeleteBucket([]byte("foo"))) + return nil + }) +} + +// Ensure that a bucket can return an autoincrementing sequence. +func TestBucket_NextSequence(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.CreateBucket([]byte("woojits")) + + // Make sure sequence increments. + seq, err := tx.Bucket([]byte("widgets")).NextSequence() + ok(t, err) + equals(t, seq, uint64(1)) + seq, err = tx.Bucket([]byte("widgets")).NextSequence() + ok(t, err) + equals(t, seq, uint64(2)) + + // Buckets should be separate. + seq, err = tx.Bucket([]byte("woojits")).NextSequence() + ok(t, err) + equals(t, seq, uint64(1)) + return nil + }) +} + +// Ensure that a bucket will persist an autoincrementing sequence even if its +// the only thing updated on the bucket. +// https://github.com/boltdb/bolt/issues/296 +func TestBucket_NextSequence_Persist(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, _ = tx.CreateBucket([]byte("widgets")) + return nil + }) + + db.Update(func(tx *bolt.Tx) error { + _, _ = tx.Bucket([]byte("widgets")).NextSequence() + return nil + }) + + db.Update(func(tx *bolt.Tx) error { + seq, err := tx.Bucket([]byte("widgets")).NextSequence() + if err != nil { + t.Fatalf("unexpected error: %s", err) + } else if seq != 2 { + t.Fatalf("unexpected sequence: %d", seq) + } + return nil + }) +} + +// Ensure that retrieving the next sequence on a read-only bucket returns an error. +func TestBucket_NextSequence_ReadOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + return nil + }) + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + i, err := b.NextSequence() + equals(t, i, uint64(0)) + equals(t, err, bolt.ErrTxNotWritable) + return nil + }) +} + +// Ensure that retrieving the next sequence for a bucket on a closed database return an error. +func TestBucket_NextSequence_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + tx.Rollback() + _, err := b.NextSequence() + equals(t, bolt.ErrTxClosed, err) +} + +// Ensure a user can loop over all key/value pairs in a bucket. +func TestBucket_ForEach(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("0000")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("0001")) + tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte("0002")) + + var index int + err := tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error { + switch index { + case 0: + equals(t, k, []byte("bar")) + equals(t, v, []byte("0002")) + case 1: + equals(t, k, []byte("baz")) + equals(t, v, []byte("0001")) + case 2: + equals(t, k, []byte("foo")) + equals(t, v, []byte("0000")) + } + index++ + return nil + }) + ok(t, err) + equals(t, index, 3) + return nil + }) +} + +// Ensure a database can stop iteration early. +func TestBucket_ForEach_ShortCircuit(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte("0000")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("0000")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("0000")) + + var index int + err := tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error { + index++ + if bytes.Equal(k, []byte("baz")) { + return errors.New("marker") + } + return nil + }) + equals(t, errors.New("marker"), err) + equals(t, 2, index) + return nil + }) +} + +// Ensure that looping over a bucket on a closed database returns an error. +func TestBucket_ForEach_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + tx.Rollback() + err := b.ForEach(func(k, v []byte) error { return nil }) + equals(t, bolt.ErrTxClosed, err) +} + +// Ensure that an error is returned when inserting with an empty key. +func TestBucket_Put_EmptyKey(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + err := tx.Bucket([]byte("widgets")).Put([]byte(""), []byte("bar")) + equals(t, err, bolt.ErrKeyRequired) + err = tx.Bucket([]byte("widgets")).Put(nil, []byte("bar")) + equals(t, err, bolt.ErrKeyRequired) + return nil + }) +} + +// Ensure that an error is returned when inserting with a key that's too large. +func TestBucket_Put_KeyTooLarge(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + err := tx.Bucket([]byte("widgets")).Put(make([]byte, 32769), []byte("bar")) + equals(t, err, bolt.ErrKeyTooLarge) + return nil + }) +} + +// Ensure a bucket can calculate stats. +func TestBucket_Stats(t *testing.T) { + db := NewTestDB() + defer db.Close() + + // Add bucket with fewer keys but one big value. + big_key := []byte("really-big-value") + for i := 0; i < 500; i++ { + db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists([]byte("woojits")) + return b.Put([]byte(fmt.Sprintf("%03d", i)), []byte(strconv.Itoa(i))) + }) + } + db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists([]byte("woojits")) + return b.Put(big_key, []byte(strings.Repeat("*", 10000))) + }) + + db.MustCheck() + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("woojits")) + stats := b.Stats() + equals(t, 1, stats.BranchPageN) + equals(t, 0, stats.BranchOverflowN) + equals(t, 7, stats.LeafPageN) + equals(t, 2, stats.LeafOverflowN) + equals(t, 501, stats.KeyN) + equals(t, 2, stats.Depth) + + branchInuse := 16 // branch page header + branchInuse += 7 * 16 // branch elements + branchInuse += 7 * 3 // branch keys (6 3-byte keys) + equals(t, branchInuse, stats.BranchInuse) + + leafInuse := 7 * 16 // leaf page header + leafInuse += 501 * 16 // leaf elements + leafInuse += 500*3 + len(big_key) // leaf keys + leafInuse += 1*10 + 2*90 + 3*400 + 10000 // leaf values + equals(t, leafInuse, stats.LeafInuse) + + if os.Getpagesize() == 4096 { + // Incompatible page size + equals(t, 4096, stats.BranchAlloc) + equals(t, 36864, stats.LeafAlloc) + } + + equals(t, 1, stats.BucketN) + equals(t, 0, stats.InlineBucketN) + equals(t, 0, stats.InlineBucketInuse) + return nil + }) +} + +// Ensure a bucket with random insertion utilizes fill percentage correctly. +func TestBucket_Stats_RandomFill(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } else if os.Getpagesize() != 4096 { + t.Skip("invalid page size for test") + } + + db := NewTestDB() + defer db.Close() + + // Add a set of values in random order. It will be the same random + // order so we can maintain consistency between test runs. + var count int + r := rand.New(rand.NewSource(42)) + for _, i := range r.Perm(1000) { + db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists([]byte("woojits")) + b.FillPercent = 0.9 + for _, j := range r.Perm(100) { + index := (j * 10000) + i + b.Put([]byte(fmt.Sprintf("%d000000000000000", index)), []byte("0000000000")) + count++ + } + return nil + }) + } + db.MustCheck() + + db.View(func(tx *bolt.Tx) error { + s := tx.Bucket([]byte("woojits")).Stats() + equals(t, 100000, s.KeyN) + + equals(t, 98, s.BranchPageN) + equals(t, 0, s.BranchOverflowN) + equals(t, 130984, s.BranchInuse) + equals(t, 401408, s.BranchAlloc) + + equals(t, 3412, s.LeafPageN) + equals(t, 0, s.LeafOverflowN) + equals(t, 4742482, s.LeafInuse) + equals(t, 13975552, s.LeafAlloc) + return nil + }) +} + +// Ensure a bucket can calculate stats. +func TestBucket_Stats_Small(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + // Add a bucket that fits on a single root leaf. + b, err := tx.CreateBucket([]byte("whozawhats")) + ok(t, err) + b.Put([]byte("foo"), []byte("bar")) + + return nil + }) + db.MustCheck() + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("whozawhats")) + stats := b.Stats() + equals(t, 0, stats.BranchPageN) + equals(t, 0, stats.BranchOverflowN) + equals(t, 0, stats.LeafPageN) + equals(t, 0, stats.LeafOverflowN) + equals(t, 1, stats.KeyN) + equals(t, 1, stats.Depth) + equals(t, 0, stats.BranchInuse) + equals(t, 0, stats.LeafInuse) + if os.Getpagesize() == 4096 { + // Incompatible page size + equals(t, 0, stats.BranchAlloc) + equals(t, 0, stats.LeafAlloc) + } + equals(t, 1, stats.BucketN) + equals(t, 1, stats.InlineBucketN) + equals(t, 16+16+6, stats.InlineBucketInuse) + return nil + }) +} + +func TestBucket_Stats_EmptyBucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + // Add a bucket that fits on a single root leaf. + _, err := tx.CreateBucket([]byte("whozawhats")) + ok(t, err) + return nil + }) + db.MustCheck() + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("whozawhats")) + stats := b.Stats() + equals(t, 0, stats.BranchPageN) + equals(t, 0, stats.BranchOverflowN) + equals(t, 0, stats.LeafPageN) + equals(t, 0, stats.LeafOverflowN) + equals(t, 0, stats.KeyN) + equals(t, 1, stats.Depth) + equals(t, 0, stats.BranchInuse) + equals(t, 0, stats.LeafInuse) + if os.Getpagesize() == 4096 { + // Incompatible page size + equals(t, 0, stats.BranchAlloc) + equals(t, 0, stats.LeafAlloc) + } + equals(t, 1, stats.BucketN) + equals(t, 1, stats.InlineBucketN) + equals(t, 16, stats.InlineBucketInuse) + return nil + }) +} + +// Ensure a bucket can calculate stats. +func TestBucket_Stats_Nested(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("foo")) + ok(t, err) + for i := 0; i < 100; i++ { + b.Put([]byte(fmt.Sprintf("%02d", i)), []byte(fmt.Sprintf("%02d", i))) + } + bar, err := b.CreateBucket([]byte("bar")) + ok(t, err) + for i := 0; i < 10; i++ { + bar.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))) + } + baz, err := bar.CreateBucket([]byte("baz")) + ok(t, err) + for i := 0; i < 10; i++ { + baz.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))) + } + return nil + }) + + db.MustCheck() + + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("foo")) + stats := b.Stats() + equals(t, 0, stats.BranchPageN) + equals(t, 0, stats.BranchOverflowN) + equals(t, 2, stats.LeafPageN) + equals(t, 0, stats.LeafOverflowN) + equals(t, 122, stats.KeyN) + equals(t, 3, stats.Depth) + equals(t, 0, stats.BranchInuse) + + foo := 16 // foo (pghdr) + foo += 101 * 16 // foo leaf elements + foo += 100*2 + 100*2 // foo leaf key/values + foo += 3 + 16 // foo -> bar key/value + + bar := 16 // bar (pghdr) + bar += 11 * 16 // bar leaf elements + bar += 10 + 10 // bar leaf key/values + bar += 3 + 16 // bar -> baz key/value + + baz := 16 // baz (inline) (pghdr) + baz += 10 * 16 // baz leaf elements + baz += 10 + 10 // baz leaf key/values + + equals(t, foo+bar+baz, stats.LeafInuse) + if os.Getpagesize() == 4096 { + // Incompatible page size + equals(t, 0, stats.BranchAlloc) + equals(t, 8192, stats.LeafAlloc) + } + equals(t, 3, stats.BucketN) + equals(t, 1, stats.InlineBucketN) + equals(t, baz, stats.InlineBucketInuse) + return nil + }) +} + +// Ensure a large bucket can calculate stats. +func TestBucket_Stats_Large(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + db := NewTestDB() + defer db.Close() + + var index int + for i := 0; i < 100; i++ { + db.Update(func(tx *bolt.Tx) error { + // Add bucket with lots of keys. + b, _ := tx.CreateBucketIfNotExists([]byte("widgets")) + for i := 0; i < 1000; i++ { + b.Put([]byte(strconv.Itoa(index)), []byte(strconv.Itoa(index))) + index++ + } + return nil + }) + } + db.MustCheck() + + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + stats := b.Stats() + equals(t, 13, stats.BranchPageN) + equals(t, 0, stats.BranchOverflowN) + equals(t, 1196, stats.LeafPageN) + equals(t, 0, stats.LeafOverflowN) + equals(t, 100000, stats.KeyN) + equals(t, 3, stats.Depth) + equals(t, 25257, stats.BranchInuse) + equals(t, 2596916, stats.LeafInuse) + if os.Getpagesize() == 4096 { + // Incompatible page size + equals(t, 53248, stats.BranchAlloc) + equals(t, 4898816, stats.LeafAlloc) + } + equals(t, 1, stats.BucketN) + equals(t, 0, stats.InlineBucketN) + equals(t, 0, stats.InlineBucketInuse) + return nil + }) +} + +// Ensure that a bucket can write random keys and values across multiple transactions. +func TestBucket_Put_Single(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + index := 0 + f := func(items testdata) bool { + db := NewTestDB() + defer db.Close() + + m := make(map[string][]byte) + + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + for _, item := range items { + db.Update(func(tx *bolt.Tx) error { + if err := tx.Bucket([]byte("widgets")).Put(item.Key, item.Value); err != nil { + panic("put error: " + err.Error()) + } + m[string(item.Key)] = item.Value + return nil + }) + + // Verify all key/values so far. + db.View(func(tx *bolt.Tx) error { + i := 0 + for k, v := range m { + value := tx.Bucket([]byte("widgets")).Get([]byte(k)) + if !bytes.Equal(value, v) { + t.Logf("value mismatch [run %d] (%d of %d):\nkey: %x\ngot: %x\nexp: %x", index, i, len(m), []byte(k), value, v) + db.CopyTempFile() + t.FailNow() + } + i++ + } + return nil + }) + } + + index++ + return true + } + if err := quick.Check(f, qconfig()); err != nil { + t.Error(err) + } +} + +// Ensure that a transaction can insert multiple key/value pairs at once. +func TestBucket_Put_Multiple(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + f := func(items testdata) bool { + db := NewTestDB() + defer db.Close() + // Bulk insert all values. + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + err := db.Update(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for _, item := range items { + ok(t, b.Put(item.Key, item.Value)) + } + return nil + }) + ok(t, err) + + // Verify all items exist. + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for _, item := range items { + value := b.Get(item.Key) + if !bytes.Equal(item.Value, value) { + db.CopyTempFile() + t.Fatalf("exp=%x; got=%x", item.Value, value) + } + } + return nil + }) + return true + } + if err := quick.Check(f, qconfig()); err != nil { + t.Error(err) + } +} + +// Ensure that a transaction can delete all key/value pairs and return to a single leaf page. +func TestBucket_Delete_Quick(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + f := func(items testdata) bool { + db := NewTestDB() + defer db.Close() + // Bulk insert all values. + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + err := db.Update(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + for _, item := range items { + ok(t, b.Put(item.Key, item.Value)) + } + return nil + }) + ok(t, err) + + // Remove items one at a time and check consistency. + for _, item := range items { + err := db.Update(func(tx *bolt.Tx) error { + return tx.Bucket([]byte("widgets")).Delete(item.Key) + }) + ok(t, err) + } + + // Anything before our deletion index should be nil. + db.View(func(tx *bolt.Tx) error { + tx.Bucket([]byte("widgets")).ForEach(func(k, v []byte) error { + t.Fatalf("bucket should be empty; found: %06x", trunc(k, 3)) + return nil + }) + return nil + }) + return true + } + if err := quick.Check(f, qconfig()); err != nil { + t.Error(err) + } +} + +func ExampleBucket_Put() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Start a write transaction. + db.Update(func(tx *bolt.Tx) error { + // Create a bucket. + tx.CreateBucket([]byte("widgets")) + + // Set the value "bar" for the key "foo". + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + return nil + }) + + // Read value back in a different read-only transaction. + db.View(func(tx *bolt.Tx) error { + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + fmt.Printf("The value of 'foo' is: %s\n", value) + return nil + }) + + // Output: + // The value of 'foo' is: bar +} + +func ExampleBucket_Delete() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Start a write transaction. + db.Update(func(tx *bolt.Tx) error { + // Create a bucket. + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + + // Set the value "bar" for the key "foo". + b.Put([]byte("foo"), []byte("bar")) + + // Retrieve the key back from the database and verify it. + value := b.Get([]byte("foo")) + fmt.Printf("The value of 'foo' was: %s\n", value) + return nil + }) + + // Delete the key in a different write transaction. + db.Update(func(tx *bolt.Tx) error { + return tx.Bucket([]byte("widgets")).Delete([]byte("foo")) + }) + + // Retrieve the key again. + db.View(func(tx *bolt.Tx) error { + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + if value == nil { + fmt.Printf("The value of 'foo' is now: nil\n") + } + return nil + }) + + // Output: + // The value of 'foo' was: bar + // The value of 'foo' is now: nil +} + +func ExampleBucket_ForEach() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Insert data into a bucket. + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("animals")) + b := tx.Bucket([]byte("animals")) + b.Put([]byte("dog"), []byte("fun")) + b.Put([]byte("cat"), []byte("lame")) + b.Put([]byte("liger"), []byte("awesome")) + + // Iterate over items in sorted key order. + b.ForEach(func(k, v []byte) error { + fmt.Printf("A %s is %s.\n", k, v) + return nil + }) + return nil + }) + + // Output: + // A cat is lame. + // A dog is fun. + // A liger is awesome. +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/bolt b/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/bolt new file mode 100644 index 0000000000000000000000000000000000000000..fa30da00f09ebff4b4586e8e4b901749495beb4b GIT binary patch literal 3031824 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%0ARBrr}GJ1|x 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%0DlI;L{a)97=g^dt5El= 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඗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%0D_%UXuDpQa+WEjr*n4ljRq;`=_G@ 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

KCY5l# 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 literal 0 HcmV?d00001 diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main.go b/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main.go new file mode 100644 index 000000000..5a7ae8e4e --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main.go @@ -0,0 +1,1529 @@ +package main + +import ( + "bytes" + "encoding/binary" + "errors" + "flag" + "fmt" + "io" + "io/ioutil" + "math/rand" + "os" + "runtime" + "runtime/pprof" + "strconv" + "strings" + "time" + "unicode" + "unicode/utf8" + "unsafe" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +var ( + // ErrUsage is returned when a usage message was printed and the process + // should simply exit with an error. + ErrUsage = errors.New("usage") + + // ErrUnknownCommand is returned when a CLI command is not specified. + ErrUnknownCommand = errors.New("unknown command") + + // ErrPathRequired is returned when the path to a Bolt database is not specified. + ErrPathRequired = errors.New("path required") + + // ErrFileNotFound is returned when a Bolt database does not exist. + ErrFileNotFound = errors.New("file not found") + + // ErrInvalidValue is returned when a benchmark reads an unexpected value. + ErrInvalidValue = errors.New("invalid value") + + // ErrCorrupt is returned when a checking a data file finds errors. + ErrCorrupt = errors.New("invalid value") + + // ErrNonDivisibleBatchSize is returned when the batch size can't be evenly + // divided by the iteration count. + ErrNonDivisibleBatchSize = errors.New("number of iterations must be divisible by the batch size") + + // ErrPageIDRequired is returned when a required page id is not specified. + ErrPageIDRequired = errors.New("page id required") + + // ErrPageNotFound is returned when specifying a page above the high water mark. + ErrPageNotFound = errors.New("page not found") + + // ErrPageFreed is returned when reading a page that has already been freed. + ErrPageFreed = errors.New("page freed") +) + +// PageHeaderSize represents the size of the bolt.page header. +const PageHeaderSize = 16 + +func main() { + m := NewMain() + if err := m.Run(os.Args[1:]...); err == ErrUsage { + os.Exit(2) + } else if err != nil { + fmt.Println(err.Error()) + os.Exit(1) + } +} + +// Main represents the main program execution. +type Main struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// NewMain returns a new instance of Main connect to the standard input/output. +func NewMain() *Main { + return &Main{ + Stdin: os.Stdin, + Stdout: os.Stdout, + Stderr: os.Stderr, + } +} + +// Run executes the program. +func (m *Main) Run(args ...string) error { + // Require a command at the beginning. + if len(args) == 0 || strings.HasPrefix(args[0], "-") { + fmt.Fprintln(m.Stderr, m.Usage()) + return ErrUsage + } + + // Execute command. + switch args[0] { + case "help": + fmt.Fprintln(m.Stderr, m.Usage()) + return ErrUsage + case "bench": + return newBenchCommand(m).Run(args[1:]...) + case "check": + return newCheckCommand(m).Run(args[1:]...) + case "dump": + return newDumpCommand(m).Run(args[1:]...) + case "info": + return newInfoCommand(m).Run(args[1:]...) + case "page": + return newPageCommand(m).Run(args[1:]...) + case "pages": + return newPagesCommand(m).Run(args[1:]...) + case "stats": + return newStatsCommand(m).Run(args[1:]...) + default: + return ErrUnknownCommand + } +} + +// Usage returns the help message. +func (m *Main) Usage() string { + return strings.TrimLeft(` +Bolt is a tool for inspecting bolt databases. + +Usage: + + bolt command [arguments] + +The commands are: + + bench run synthetic benchmark against bolt + check verifies integrity of bolt database + info print basic info + help print this screen + pages print list of pages with their types + stats iterate over all pages and generate usage stats + +Use "bolt [command] -h" for more information about a command. +`, "\n") +} + +// CheckCommand represents the "check" command execution. +type CheckCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// NewCheckCommand returns a CheckCommand. +func newCheckCommand(m *Main) *CheckCommand { + return &CheckCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the command. +func (cmd *CheckCommand) Run(args ...string) error { + // Parse flags. + fs := flag.NewFlagSet("", flag.ContinueOnError) + help := fs.Bool("h", false, "") + if err := fs.Parse(args); err != nil { + return err + } else if *help { + fmt.Fprintln(cmd.Stderr, cmd.Usage()) + return ErrUsage + } + + // Require database path. + path := fs.Arg(0) + if path == "" { + return ErrPathRequired + } else if _, err := os.Stat(path); os.IsNotExist(err) { + return ErrFileNotFound + } + + // Open database. + db, err := bolt.Open(path, 0666, nil) + if err != nil { + return err + } + defer db.Close() + + // Perform consistency check. + return db.View(func(tx *bolt.Tx) error { + var count int + ch := tx.Check() + loop: + for { + select { + case err, ok := <-ch: + if !ok { + break loop + } + fmt.Fprintln(cmd.Stdout, err) + count++ + } + } + + // Print summary of errors. + if count > 0 { + fmt.Fprintf(cmd.Stdout, "%d errors found\n", count) + return ErrCorrupt + } + + // Notify user that database is valid. + fmt.Fprintln(cmd.Stdout, "OK") + return nil + }) +} + +// Usage returns the help message. +func (cmd *CheckCommand) Usage() string { + return strings.TrimLeft(` +usage: bolt check PATH + +Check opens a database at PATH and runs an exhaustive check to verify that +all pages are accessible or are marked as freed. It also verifies that no +pages are double referenced. + +Verification errors will stream out as they are found and the process will +return after all pages have been checked. +`, "\n") +} + +// InfoCommand represents the "info" command execution. +type InfoCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// NewInfoCommand returns a InfoCommand. +func newInfoCommand(m *Main) *InfoCommand { + return &InfoCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the command. +func (cmd *InfoCommand) Run(args ...string) error { + // Parse flags. + fs := flag.NewFlagSet("", flag.ContinueOnError) + help := fs.Bool("h", false, "") + if err := fs.Parse(args); err != nil { + return err + } else if *help { + fmt.Fprintln(cmd.Stderr, cmd.Usage()) + return ErrUsage + } + + // Require database path. + path := fs.Arg(0) + if path == "" { + return ErrPathRequired + } else if _, err := os.Stat(path); os.IsNotExist(err) { + return ErrFileNotFound + } + + // Open the database. + db, err := bolt.Open(path, 0666, nil) + if err != nil { + return err + } + defer db.Close() + + // Print basic database info. + info := db.Info() + fmt.Fprintf(cmd.Stdout, "Page Size: %d\n", info.PageSize) + + return nil +} + +// Usage returns the help message. +func (cmd *InfoCommand) Usage() string { + return strings.TrimLeft(` +usage: bolt info PATH + +Info prints basic information about the Bolt database at PATH. +`, "\n") +} + +// DumpCommand represents the "dump" command execution. +type DumpCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// newDumpCommand returns a DumpCommand. +func newDumpCommand(m *Main) *DumpCommand { + return &DumpCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the command. +func (cmd *DumpCommand) Run(args ...string) error { + // Parse flags. + fs := flag.NewFlagSet("", flag.ContinueOnError) + help := fs.Bool("h", false, "") + if err := fs.Parse(args); err != nil { + return err + } else if *help { + fmt.Fprintln(cmd.Stderr, cmd.Usage()) + return ErrUsage + } + + // Require database path and page id. + path := fs.Arg(0) + if path == "" { + return ErrPathRequired + } else if _, err := os.Stat(path); os.IsNotExist(err) { + return ErrFileNotFound + } + + // Read page ids. + pageIDs, err := atois(fs.Args()[1:]) + if err != nil { + return err + } else if len(pageIDs) == 0 { + return ErrPageIDRequired + } + + // Open database to retrieve page size. + pageSize, err := ReadPageSize(path) + if err != nil { + return err + } + + // Open database file handler. + f, err := os.Open(path) + if err != nil { + return err + } + defer func() { _ = f.Close() }() + + // Print each page listed. + for i, pageID := range pageIDs { + // Print a separator. + if i > 0 { + fmt.Fprintln(cmd.Stdout, "===============================================\n") + } + + // Print page to stdout. + if err := cmd.PrintPage(cmd.Stdout, f, pageID, pageSize); err != nil { + return err + } + } + + return nil +} + +// PrintPage prints a given page as hexidecimal. +func (cmd *DumpCommand) PrintPage(w io.Writer, r io.ReaderAt, pageID int, pageSize int) error { + const bytesPerLineN = 16 + + // Read page into buffer. + buf := make([]byte, pageSize) + addr := pageID * pageSize + if n, err := r.ReadAt(buf, int64(addr)); err != nil { + return err + } else if n != pageSize { + return io.ErrUnexpectedEOF + } + + // Write out to writer in 16-byte lines. + var prev []byte + var skipped bool + for offset := 0; offset < pageSize; offset += bytesPerLineN { + // Retrieve current 16-byte line. + line := buf[offset : offset+bytesPerLineN] + isLastLine := (offset == (pageSize - bytesPerLineN)) + + // If it's the same as the previous line then print a skip. + if bytes.Equal(line, prev) && !isLastLine { + if !skipped { + fmt.Fprintf(w, "%07x *\n", addr+offset) + skipped = true + } + } else { + // Print line as hexadecimal in 2-byte groups. + fmt.Fprintf(w, "%07x %04x %04x %04x %04x %04x %04x %04x %04x\n", addr+offset, + line[0:2], line[2:4], line[4:6], line[6:8], + line[8:10], line[10:12], line[12:14], line[14:16], + ) + + skipped = false + } + + // Save the previous line. + prev = line + } + fmt.Fprint(w, "\n") + + return nil +} + +// Usage returns the help message. +func (cmd *DumpCommand) Usage() string { + return strings.TrimLeft(` +usage: bolt dump -page PAGEID PATH + +Dump prints a hexidecimal dump of a single page. +`, "\n") +} + +// PageCommand represents the "page" command execution. +type PageCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// newPageCommand returns a PageCommand. +func newPageCommand(m *Main) *PageCommand { + return &PageCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the command. +func (cmd *PageCommand) Run(args ...string) error { + // Parse flags. + fs := flag.NewFlagSet("", flag.ContinueOnError) + help := fs.Bool("h", false, "") + if err := fs.Parse(args); err != nil { + return err + } else if *help { + fmt.Fprintln(cmd.Stderr, cmd.Usage()) + return ErrUsage + } + + // Require database path and page id. + path := fs.Arg(0) + if path == "" { + return ErrPathRequired + } else if _, err := os.Stat(path); os.IsNotExist(err) { + return ErrFileNotFound + } + + // Read page ids. + pageIDs, err := atois(fs.Args()[1:]) + if err != nil { + return err + } else if len(pageIDs) == 0 { + return ErrPageIDRequired + } + + // Open database file handler. + f, err := os.Open(path) + if err != nil { + return err + } + defer func() { _ = f.Close() }() + + // Print each page listed. + for i, pageID := range pageIDs { + // Print a separator. + if i > 0 { + fmt.Fprintln(cmd.Stdout, "===============================================\n") + } + + // Retrieve page info and page size. + p, buf, err := ReadPage(path, pageID) + if err != nil { + return err + } + + // Print basic page info. + fmt.Fprintf(cmd.Stdout, "Page ID: %d\n", p.id) + fmt.Fprintf(cmd.Stdout, "Page Type: %s\n", p.Type()) + fmt.Fprintf(cmd.Stdout, "Total Size: %d bytes\n", len(buf)) + + // Print type-specific data. + switch p.Type() { + case "meta": + err = cmd.PrintMeta(cmd.Stdout, buf) + case "leaf": + err = cmd.PrintLeaf(cmd.Stdout, buf) + case "branch": + err = cmd.PrintBranch(cmd.Stdout, buf) + case "freelist": + err = cmd.PrintFreelist(cmd.Stdout, buf) + } + if err != nil { + return err + } + } + + return nil +} + +// PrintMeta prints the data from the meta page. +func (cmd *PageCommand) PrintMeta(w io.Writer, buf []byte) error { + m := (*meta)(unsafe.Pointer(&buf[PageHeaderSize])) + fmt.Fprintf(w, "Version: %d\n", m.version) + fmt.Fprintf(w, "Page Size: %d bytes\n", m.pageSize) + fmt.Fprintf(w, "Flags: %08x\n", m.flags) + fmt.Fprintf(w, "Root: \n", m.root.root) + fmt.Fprintf(w, "Freelist: \n", m.freelist) + fmt.Fprintf(w, "HWM: \n", m.pgid) + fmt.Fprintf(w, "Txn ID: %d\n", m.txid) + fmt.Fprintf(w, "Checksum: %016x\n", m.checksum) + fmt.Fprintf(w, "\n") + return nil +} + +// PrintLeaf prints the data for a leaf page. +func (cmd *PageCommand) PrintLeaf(w io.Writer, buf []byte) error { + p := (*page)(unsafe.Pointer(&buf[0])) + + // Print number of items. + fmt.Fprintf(w, "Item Count: %d\n", p.count) + fmt.Fprintf(w, "\n") + + // Print each key/value. + for i := uint16(0); i < p.count; i++ { + e := p.leafPageElement(i) + + // Format key as string. + var k string + if isPrintable(string(e.key())) { + k = fmt.Sprintf("%q", string(e.key())) + } else { + k = fmt.Sprintf("%x", string(e.key())) + } + + // Format value as string. + var v string + if (e.flags & uint32(bucketLeafFlag)) != 0 { + b := (*bucket)(unsafe.Pointer(&e.value()[0])) + v = fmt.Sprintf("", b.root, b.sequence) + } else if isPrintable(string(e.value())) { + k = fmt.Sprintf("%q", string(e.value())) + } else { + k = fmt.Sprintf("%x", string(e.value())) + } + + fmt.Fprintf(w, "%s: %s\n", k, v) + } + fmt.Fprintf(w, "\n") + return nil +} + +// PrintBranch prints the data for a leaf page. +func (cmd *PageCommand) PrintBranch(w io.Writer, buf []byte) error { + p := (*page)(unsafe.Pointer(&buf[0])) + + // Print number of items. + fmt.Fprintf(w, "Item Count: %d\n", p.count) + fmt.Fprintf(w, "\n") + + // Print each key/value. + for i := uint16(0); i < p.count; i++ { + e := p.branchPageElement(i) + + // Format key as string. + var k string + if isPrintable(string(e.key())) { + k = fmt.Sprintf("%q", string(e.key())) + } else { + k = fmt.Sprintf("%x", string(e.key())) + } + + fmt.Fprintf(w, "%s: \n", k, e.pgid) + } + fmt.Fprintf(w, "\n") + return nil +} + +// PrintFreelist prints the data for a freelist page. +func (cmd *PageCommand) PrintFreelist(w io.Writer, buf []byte) error { + p := (*page)(unsafe.Pointer(&buf[0])) + + // Print number of items. + fmt.Fprintf(w, "Item Count: %d\n", p.count) + fmt.Fprintf(w, "\n") + + // Print each page in the freelist. + ids := (*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)) + for i := uint16(0); i < p.count; i++ { + fmt.Fprintf(w, "%d\n", ids[i]) + } + fmt.Fprintf(w, "\n") + return nil +} + +// PrintPage prints a given page as hexidecimal. +func (cmd *PageCommand) PrintPage(w io.Writer, r io.ReaderAt, pageID int, pageSize int) error { + const bytesPerLineN = 16 + + // Read page into buffer. + buf := make([]byte, pageSize) + addr := pageID * pageSize + if n, err := r.ReadAt(buf, int64(addr)); err != nil { + return err + } else if n != pageSize { + return io.ErrUnexpectedEOF + } + + // Write out to writer in 16-byte lines. + var prev []byte + var skipped bool + for offset := 0; offset < pageSize; offset += bytesPerLineN { + // Retrieve current 16-byte line. + line := buf[offset : offset+bytesPerLineN] + isLastLine := (offset == (pageSize - bytesPerLineN)) + + // If it's the same as the previous line then print a skip. + if bytes.Equal(line, prev) && !isLastLine { + if !skipped { + fmt.Fprintf(w, "%07x *\n", addr+offset) + skipped = true + } + } else { + // Print line as hexadecimal in 2-byte groups. + fmt.Fprintf(w, "%07x %04x %04x %04x %04x %04x %04x %04x %04x\n", addr+offset, + line[0:2], line[2:4], line[4:6], line[6:8], + line[8:10], line[10:12], line[12:14], line[14:16], + ) + + skipped = false + } + + // Save the previous line. + prev = line + } + fmt.Fprint(w, "\n") + + return nil +} + +// Usage returns the help message. +func (cmd *PageCommand) Usage() string { + return strings.TrimLeft(` +usage: bolt page -page PATH pageid [pageid...] + +Page prints one or more pages in human readable format. +`, "\n") +} + +// PagesCommand represents the "pages" command execution. +type PagesCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// NewPagesCommand returns a PagesCommand. +func newPagesCommand(m *Main) *PagesCommand { + return &PagesCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the command. +func (cmd *PagesCommand) Run(args ...string) error { + // Parse flags. + fs := flag.NewFlagSet("", flag.ContinueOnError) + help := fs.Bool("h", false, "") + if err := fs.Parse(args); err != nil { + return err + } else if *help { + fmt.Fprintln(cmd.Stderr, cmd.Usage()) + return ErrUsage + } + + // Require database path. + path := fs.Arg(0) + if path == "" { + return ErrPathRequired + } else if _, err := os.Stat(path); os.IsNotExist(err) { + return ErrFileNotFound + } + + // Open database. + db, err := bolt.Open(path, 0666, nil) + if err != nil { + return err + } + defer func() { _ = db.Close() }() + + // Write header. + fmt.Fprintln(cmd.Stdout, "ID TYPE ITEMS OVRFLW") + fmt.Fprintln(cmd.Stdout, "======== ========== ====== ======") + + return db.Update(func(tx *bolt.Tx) error { + var id int + for { + p, err := tx.Page(id) + if err != nil { + return &PageError{ID: id, Err: err} + } else if p == nil { + break + } + + // Only display count and overflow if this is a non-free page. + var count, overflow string + if p.Type != "free" { + count = strconv.Itoa(p.Count) + if p.OverflowCount > 0 { + overflow = strconv.Itoa(p.OverflowCount) + } + } + + // Print table row. + fmt.Fprintf(cmd.Stdout, "%-8d %-10s %-6s %-6s\n", p.ID, p.Type, count, overflow) + + // Move to the next non-overflow page. + id += 1 + if p.Type != "free" { + id += p.OverflowCount + } + } + return nil + }) +} + +// Usage returns the help message. +func (cmd *PagesCommand) Usage() string { + return strings.TrimLeft(` +usage: bolt pages PATH + +Pages prints a table of pages with their type (meta, leaf, branch, freelist). +Leaf and branch pages will show a key count in the "items" column while the +freelist will show the number of free pages in the "items" column. + +The "overflow" column shows the number of blocks that the page spills over +into. Normally there is no overflow but large keys and values can cause +a single page to take up multiple blocks. +`, "\n") +} + +// StatsCommand represents the "stats" command execution. +type StatsCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// NewStatsCommand returns a StatsCommand. +func newStatsCommand(m *Main) *StatsCommand { + return &StatsCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the command. +func (cmd *StatsCommand) Run(args ...string) error { + // Parse flags. + fs := flag.NewFlagSet("", flag.ContinueOnError) + help := fs.Bool("h", false, "") + if err := fs.Parse(args); err != nil { + return err + } else if *help { + fmt.Fprintln(cmd.Stderr, cmd.Usage()) + return ErrUsage + } + + // Require database path. + path, prefix := fs.Arg(0), fs.Arg(1) + if path == "" { + return ErrPathRequired + } else if _, err := os.Stat(path); os.IsNotExist(err) { + return ErrFileNotFound + } + + // Open database. + db, err := bolt.Open(path, 0666, nil) + if err != nil { + return err + } + defer db.Close() + + return db.View(func(tx *bolt.Tx) error { + var s bolt.BucketStats + var count int + if err := tx.ForEach(func(name []byte, b *bolt.Bucket) error { + if bytes.HasPrefix(name, []byte(prefix)) { + s.Add(b.Stats()) + count += 1 + } + return nil + }); err != nil { + return err + } + + fmt.Fprintf(cmd.Stdout, "Aggregate statistics for %d buckets\n\n", count) + + fmt.Fprintln(cmd.Stdout, "Page count statistics") + fmt.Fprintf(cmd.Stdout, "\tNumber of logical branch pages: %d\n", s.BranchPageN) + fmt.Fprintf(cmd.Stdout, "\tNumber of physical branch overflow pages: %d\n", s.BranchOverflowN) + fmt.Fprintf(cmd.Stdout, "\tNumber of logical leaf pages: %d\n", s.LeafPageN) + fmt.Fprintf(cmd.Stdout, "\tNumber of physical leaf overflow pages: %d\n", s.LeafOverflowN) + + fmt.Fprintln(cmd.Stdout, "Tree statistics") + fmt.Fprintf(cmd.Stdout, "\tNumber of keys/value pairs: %d\n", s.KeyN) + fmt.Fprintf(cmd.Stdout, "\tNumber of levels in B+tree: %d\n", s.Depth) + + fmt.Fprintln(cmd.Stdout, "Page size utilization") + fmt.Fprintf(cmd.Stdout, "\tBytes allocated for physical branch pages: %d\n", s.BranchAlloc) + var percentage int + if s.BranchAlloc != 0 { + percentage = int(float32(s.BranchInuse) * 100.0 / float32(s.BranchAlloc)) + } + fmt.Fprintf(cmd.Stdout, "\tBytes actually used for branch data: %d (%d%%)\n", s.BranchInuse, percentage) + fmt.Fprintf(cmd.Stdout, "\tBytes allocated for physical leaf pages: %d\n", s.LeafAlloc) + percentage = 0 + if s.LeafAlloc != 0 { + percentage = int(float32(s.LeafInuse) * 100.0 / float32(s.LeafAlloc)) + } + fmt.Fprintf(cmd.Stdout, "\tBytes actually used for leaf data: %d (%d%%)\n", s.LeafInuse, percentage) + + fmt.Fprintln(cmd.Stdout, "Bucket statistics") + fmt.Fprintf(cmd.Stdout, "\tTotal number of buckets: %d\n", s.BucketN) + percentage = int(float32(s.InlineBucketN) * 100.0 / float32(s.BucketN)) + fmt.Fprintf(cmd.Stdout, "\tTotal number on inlined buckets: %d (%d%%)\n", s.InlineBucketN, percentage) + percentage = 0 + if s.LeafInuse != 0 { + percentage = int(float32(s.InlineBucketInuse) * 100.0 / float32(s.LeafInuse)) + } + fmt.Fprintf(cmd.Stdout, "\tBytes used for inlined buckets: %d (%d%%)\n", s.InlineBucketInuse, percentage) + + return nil + }) +} + +// Usage returns the help message. +func (cmd *StatsCommand) Usage() string { + return strings.TrimLeft(` +usage: bolt stats PATH + +Stats performs an extensive search of the database to track every page +reference. It starts at the current meta page and recursively iterates +through every accessible bucket. + +The following errors can be reported: + + already freed + The page is referenced more than once in the freelist. + + unreachable unfreed + The page is not referenced by a bucket or in the freelist. + + reachable freed + The page is referenced by a bucket but is also in the freelist. + + out of bounds + A page is referenced that is above the high water mark. + + multiple references + A page is referenced by more than one other page. + + invalid type + The page type is not "meta", "leaf", "branch", or "freelist". + +No errors should occur in your database. However, if for some reason you +experience corruption, please submit a ticket to the Bolt project page: + + https://github.com/boltdb/bolt/issues +`, "\n") +} + +var benchBucketName = []byte("bench") + +// BenchCommand represents the "bench" command execution. +type BenchCommand struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer +} + +// NewBenchCommand returns a BenchCommand using the +func newBenchCommand(m *Main) *BenchCommand { + return &BenchCommand{ + Stdin: m.Stdin, + Stdout: m.Stdout, + Stderr: m.Stderr, + } +} + +// Run executes the "bench" command. +func (cmd *BenchCommand) Run(args ...string) error { + // Parse CLI arguments. + options, err := cmd.ParseFlags(args) + if err != nil { + return err + } + + // Remove path if "-work" is not set. Otherwise keep path. + if options.Work { + fmt.Fprintf(cmd.Stdout, "work: %s\n", options.Path) + } else { + defer os.Remove(options.Path) + } + + // Create database. + db, err := bolt.Open(options.Path, 0666, nil) + if err != nil { + return err + } + db.NoSync = options.NoSync + defer db.Close() + + // Write to the database. + var results BenchResults + if err := cmd.runWrites(db, options, &results); err != nil { + return fmt.Errorf("write: ", err) + } + + // Read from the database. + if err := cmd.runReads(db, options, &results); err != nil { + return fmt.Errorf("bench: read: %s", err) + } + + // Print results. + fmt.Fprintf(os.Stderr, "# Write\t%v\t(%v/op)\t(%v op/sec)\n", results.WriteDuration, results.WriteOpDuration(), results.WriteOpsPerSecond()) + fmt.Fprintf(os.Stderr, "# Read\t%v\t(%v/op)\t(%v op/sec)\n", results.ReadDuration, results.ReadOpDuration(), results.ReadOpsPerSecond()) + fmt.Fprintln(os.Stderr, "") + return nil +} + +// ParseFlags parses the command line flags. +func (cmd *BenchCommand) ParseFlags(args []string) (*BenchOptions, error) { + var options BenchOptions + + // Parse flagset. + fs := flag.NewFlagSet("", flag.ContinueOnError) + fs.StringVar(&options.ProfileMode, "profile-mode", "rw", "") + fs.StringVar(&options.WriteMode, "write-mode", "seq", "") + fs.StringVar(&options.ReadMode, "read-mode", "seq", "") + fs.IntVar(&options.Iterations, "count", 1000, "") + fs.IntVar(&options.BatchSize, "batch-size", 0, "") + fs.IntVar(&options.KeySize, "key-size", 8, "") + fs.IntVar(&options.ValueSize, "value-size", 32, "") + fs.StringVar(&options.CPUProfile, "cpuprofile", "", "") + fs.StringVar(&options.MemProfile, "memprofile", "", "") + fs.StringVar(&options.BlockProfile, "blockprofile", "", "") + fs.Float64Var(&options.FillPercent, "fill-percent", bolt.DefaultFillPercent, "") + fs.BoolVar(&options.NoSync, "no-sync", false, "") + fs.BoolVar(&options.Work, "work", false, "") + fs.StringVar(&options.Path, "path", "", "") + fs.SetOutput(cmd.Stderr) + if err := fs.Parse(args); err != nil { + return nil, err + } + + // Set batch size to iteration size if not set. + // Require that batch size can be evenly divided by the iteration count. + if options.BatchSize == 0 { + options.BatchSize = options.Iterations + } else if options.Iterations%options.BatchSize != 0 { + return nil, ErrNonDivisibleBatchSize + } + + // Generate temp path if one is not passed in. + if options.Path == "" { + f, err := ioutil.TempFile("", "bolt-bench-") + if err != nil { + return nil, fmt.Errorf("temp file: %s", err) + } + f.Close() + os.Remove(f.Name()) + options.Path = f.Name() + } + + return &options, nil +} + +// Writes to the database. +func (cmd *BenchCommand) runWrites(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + // Start profiling for writes. + if options.ProfileMode == "rw" || options.ProfileMode == "w" { + cmd.startProfiling(options) + } + + t := time.Now() + + var err error + switch options.WriteMode { + case "seq": + err = cmd.runWritesSequential(db, options, results) + case "rnd": + err = cmd.runWritesRandom(db, options, results) + case "seq-nest": + err = cmd.runWritesSequentialNested(db, options, results) + case "rnd-nest": + err = cmd.runWritesRandomNested(db, options, results) + default: + return fmt.Errorf("invalid write mode: %s", options.WriteMode) + } + + // Save time to write. + results.WriteDuration = time.Since(t) + + // Stop profiling for writes only. + if options.ProfileMode == "w" { + cmd.stopProfiling() + } + + return err +} + +func (cmd *BenchCommand) runWritesSequential(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + var i = uint32(0) + return cmd.runWritesWithSource(db, options, results, func() uint32 { i++; return i }) +} + +func (cmd *BenchCommand) runWritesRandom(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + return cmd.runWritesWithSource(db, options, results, func() uint32 { return r.Uint32() }) +} + +func (cmd *BenchCommand) runWritesSequentialNested(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + var i = uint32(0) + return cmd.runWritesWithSource(db, options, results, func() uint32 { i++; return i }) +} + +func (cmd *BenchCommand) runWritesRandomNested(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + return cmd.runWritesWithSource(db, options, results, func() uint32 { return r.Uint32() }) +} + +func (cmd *BenchCommand) runWritesWithSource(db *bolt.DB, options *BenchOptions, results *BenchResults, keySource func() uint32) error { + results.WriteOps = options.Iterations + + for i := 0; i < options.Iterations; i += options.BatchSize { + if err := db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists(benchBucketName) + b.FillPercent = options.FillPercent + + for j := 0; j < options.BatchSize; j++ { + key := make([]byte, options.KeySize) + value := make([]byte, options.ValueSize) + + // Write key as uint32. + binary.BigEndian.PutUint32(key, keySource()) + + // Insert key/value. + if err := b.Put(key, value); err != nil { + return err + } + } + + return nil + }); err != nil { + return err + } + } + return nil +} + +func (cmd *BenchCommand) runWritesNestedWithSource(db *bolt.DB, options *BenchOptions, results *BenchResults, keySource func() uint32) error { + results.WriteOps = options.Iterations + + for i := 0; i < options.Iterations; i += options.BatchSize { + if err := db.Update(func(tx *bolt.Tx) error { + top, err := tx.CreateBucketIfNotExists(benchBucketName) + if err != nil { + return err + } + top.FillPercent = options.FillPercent + + // Create bucket key. + name := make([]byte, options.KeySize) + binary.BigEndian.PutUint32(name, keySource()) + + // Create bucket. + b, err := top.CreateBucketIfNotExists(name) + if err != nil { + return err + } + b.FillPercent = options.FillPercent + + for j := 0; j < options.BatchSize; j++ { + var key = make([]byte, options.KeySize) + var value = make([]byte, options.ValueSize) + + // Generate key as uint32. + binary.BigEndian.PutUint32(key, keySource()) + + // Insert value into subbucket. + if err := b.Put(key, value); err != nil { + return err + } + } + + return nil + }); err != nil { + return err + } + } + return nil +} + +// Reads from the database. +func (cmd *BenchCommand) runReads(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + // Start profiling for reads. + if options.ProfileMode == "r" { + cmd.startProfiling(options) + } + + t := time.Now() + + var err error + switch options.ReadMode { + case "seq": + switch options.WriteMode { + case "seq-nest", "rnd-nest": + err = cmd.runReadsSequentialNested(db, options, results) + default: + err = cmd.runReadsSequential(db, options, results) + } + default: + return fmt.Errorf("invalid read mode: %s", options.ReadMode) + } + + // Save read time. + results.ReadDuration = time.Since(t) + + // Stop profiling for reads. + if options.ProfileMode == "rw" || options.ProfileMode == "r" { + cmd.stopProfiling() + } + + return err +} + +func (cmd *BenchCommand) runReadsSequential(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + return db.View(func(tx *bolt.Tx) error { + t := time.Now() + + for { + var count int + + c := tx.Bucket(benchBucketName).Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + if v == nil { + return errors.New("invalid value") + } + count++ + } + + if options.WriteMode == "seq" && count != options.Iterations { + return fmt.Errorf("read seq: iter mismatch: expected %d, got %d", options.Iterations, count) + } + + results.ReadOps += count + + // Make sure we do this for at least a second. + if time.Since(t) >= time.Second { + break + } + } + + return nil + }) +} + +func (cmd *BenchCommand) runReadsSequentialNested(db *bolt.DB, options *BenchOptions, results *BenchResults) error { + return db.View(func(tx *bolt.Tx) error { + t := time.Now() + + for { + var count int + var top = tx.Bucket(benchBucketName) + if err := top.ForEach(func(name, _ []byte) error { + c := top.Bucket(name).Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + if v == nil { + return ErrInvalidValue + } + count++ + } + return nil + }); err != nil { + return err + } + + if options.WriteMode == "seq-nest" && count != options.Iterations { + return fmt.Errorf("read seq-nest: iter mismatch: expected %d, got %d", options.Iterations, count) + } + + results.ReadOps += count + + // Make sure we do this for at least a second. + if time.Since(t) >= time.Second { + break + } + } + + return nil + }) +} + +// File handlers for the various profiles. +var cpuprofile, memprofile, blockprofile *os.File + +// Starts all profiles set on the options. +func (cmd *BenchCommand) startProfiling(options *BenchOptions) { + var err error + + // Start CPU profiling. + if options.CPUProfile != "" { + cpuprofile, err = os.Create(options.CPUProfile) + if err != nil { + fmt.Fprintf(cmd.Stderr, "bench: could not create cpu profile %q: %v\n", options.CPUProfile, err) + os.Exit(1) + } + pprof.StartCPUProfile(cpuprofile) + } + + // Start memory profiling. + if options.MemProfile != "" { + memprofile, err = os.Create(options.MemProfile) + if err != nil { + fmt.Fprintf(cmd.Stderr, "bench: could not create memory profile %q: %v\n", options.MemProfile, err) + os.Exit(1) + } + runtime.MemProfileRate = 4096 + } + + // Start fatal profiling. + if options.BlockProfile != "" { + blockprofile, err = os.Create(options.BlockProfile) + if err != nil { + fmt.Fprintf(cmd.Stderr, "bench: could not create block profile %q: %v\n", options.BlockProfile, err) + os.Exit(1) + } + runtime.SetBlockProfileRate(1) + } +} + +// Stops all profiles. +func (cmd *BenchCommand) stopProfiling() { + if cpuprofile != nil { + pprof.StopCPUProfile() + cpuprofile.Close() + cpuprofile = nil + } + + if memprofile != nil { + pprof.Lookup("heap").WriteTo(memprofile, 0) + memprofile.Close() + memprofile = nil + } + + if blockprofile != nil { + pprof.Lookup("block").WriteTo(blockprofile, 0) + blockprofile.Close() + blockprofile = nil + runtime.SetBlockProfileRate(0) + } +} + +// BenchOptions represents the set of options that can be passed to "bolt bench". +type BenchOptions struct { + ProfileMode string + WriteMode string + ReadMode string + Iterations int + BatchSize int + KeySize int + ValueSize int + CPUProfile string + MemProfile string + BlockProfile string + StatsInterval time.Duration + FillPercent float64 + NoSync bool + Work bool + Path string +} + +// BenchResults represents the performance results of the benchmark. +type BenchResults struct { + WriteOps int + WriteDuration time.Duration + ReadOps int + ReadDuration time.Duration +} + +// Returns the duration for a single write operation. +func (r *BenchResults) WriteOpDuration() time.Duration { + if r.WriteOps == 0 { + return 0 + } + return r.WriteDuration / time.Duration(r.WriteOps) +} + +// Returns average number of write operations that can be performed per second. +func (r *BenchResults) WriteOpsPerSecond() int { + var op = r.WriteOpDuration() + if op == 0 { + return 0 + } + return int(time.Second) / int(op) +} + +// Returns the duration for a single read operation. +func (r *BenchResults) ReadOpDuration() time.Duration { + if r.ReadOps == 0 { + return 0 + } + return r.ReadDuration / time.Duration(r.ReadOps) +} + +// Returns average number of read operations that can be performed per second. +func (r *BenchResults) ReadOpsPerSecond() int { + var op = r.ReadOpDuration() + if op == 0 { + return 0 + } + return int(time.Second) / int(op) +} + +type PageError struct { + ID int + Err error +} + +func (e *PageError) Error() string { + return fmt.Sprintf("page error: id=%d, err=%s", e.ID, e.Err) +} + +// isPrintable returns true if the string is valid unicode and contains only printable runes. +func isPrintable(s string) bool { + if !utf8.ValidString(s) { + return false + } + for _, ch := range s { + if !unicode.IsPrint(ch) { + return false + } + } + return true +} + +// ReadPage reads page info & full page data from a path. +// This is not transactionally safe. +func ReadPage(path string, pageID int) (*page, []byte, error) { + // Find page size. + pageSize, err := ReadPageSize(path) + if err != nil { + return nil, nil, fmt.Errorf("read page size: %s", err) + } + + // Open database file. + f, err := os.Open(path) + if err != nil { + return nil, nil, err + } + defer f.Close() + + // Read one block into buffer. + buf := make([]byte, pageSize) + if n, err := f.ReadAt(buf, int64(pageID*pageSize)); err != nil { + return nil, nil, err + } else if n != len(buf) { + return nil, nil, io.ErrUnexpectedEOF + } + + // Determine total number of blocks. + p := (*page)(unsafe.Pointer(&buf[0])) + overflowN := p.overflow + + // Re-read entire page (with overflow) into buffer. + buf = make([]byte, (int(overflowN)+1)*pageSize) + if n, err := f.ReadAt(buf, int64(pageID*pageSize)); err != nil { + return nil, nil, err + } else if n != len(buf) { + return nil, nil, io.ErrUnexpectedEOF + } + p = (*page)(unsafe.Pointer(&buf[0])) + + return p, buf, nil +} + +// ReadPageSize reads page size a path. +// This is not transactionally safe. +func ReadPageSize(path string) (int, error) { + // Open database file. + f, err := os.Open(path) + if err != nil { + return 0, err + } + defer f.Close() + + // Read 4KB chunk. + buf := make([]byte, 4096) + if _, err := io.ReadFull(f, buf); err != nil { + return 0, err + } + + // Read page size from metadata. + m := (*meta)(unsafe.Pointer(&buf[PageHeaderSize])) + return int(m.pageSize), nil +} + +// atois parses a slice of strings into integers. +func atois(strs []string) ([]int, error) { + var a []int + for _, str := range strs { + i, err := strconv.Atoi(str) + if err != nil { + return nil, err + } + a = append(a, i) + } + return a, nil +} + +// DO NOT EDIT. Copied from the "bolt" package. +const maxAllocSize = 0xFFFFFFF + +// DO NOT EDIT. Copied from the "bolt" package. +const ( + branchPageFlag = 0x01 + leafPageFlag = 0x02 + metaPageFlag = 0x04 + freelistPageFlag = 0x10 +) + +// DO NOT EDIT. Copied from the "bolt" package. +const bucketLeafFlag = 0x01 + +// DO NOT EDIT. Copied from the "bolt" package. +type pgid uint64 + +// DO NOT EDIT. Copied from the "bolt" package. +type txid uint64 + +// DO NOT EDIT. Copied from the "bolt" package. +type meta struct { + magic uint32 + version uint32 + pageSize uint32 + flags uint32 + root bucket + freelist pgid + pgid pgid + txid txid + checksum uint64 +} + +// DO NOT EDIT. Copied from the "bolt" package. +type bucket struct { + root pgid + sequence uint64 +} + +// DO NOT EDIT. Copied from the "bolt" package. +type page struct { + id pgid + flags uint16 + count uint16 + overflow uint32 + ptr uintptr +} + +// DO NOT EDIT. Copied from the "bolt" package. +func (p *page) Type() string { + if (p.flags & branchPageFlag) != 0 { + return "branch" + } else if (p.flags & leafPageFlag) != 0 { + return "leaf" + } else if (p.flags & metaPageFlag) != 0 { + return "meta" + } else if (p.flags & freelistPageFlag) != 0 { + return "freelist" + } + return fmt.Sprintf("unknown<%02x>", p.flags) +} + +// DO NOT EDIT. Copied from the "bolt" package. +func (p *page) leafPageElement(index uint16) *leafPageElement { + n := &((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index] + return n +} + +// DO NOT EDIT. Copied from the "bolt" package. +func (p *page) branchPageElement(index uint16) *branchPageElement { + return &((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[index] +} + +// DO NOT EDIT. Copied from the "bolt" package. +type branchPageElement struct { + pos uint32 + ksize uint32 + pgid pgid +} + +// DO NOT EDIT. Copied from the "bolt" package. +func (n *branchPageElement) key() []byte { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(n)) + return buf[n.pos : n.pos+n.ksize] +} + +// DO NOT EDIT. Copied from the "bolt" package. +type leafPageElement struct { + flags uint32 + pos uint32 + ksize uint32 + vsize uint32 +} + +// DO NOT EDIT. Copied from the "bolt" package. +func (n *leafPageElement) key() []byte { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(n)) + return buf[n.pos : n.pos+n.ksize] +} + +// DO NOT EDIT. Copied from the "bolt" package. +func (n *leafPageElement) value() []byte { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(n)) + return buf[n.pos+n.ksize : n.pos+n.ksize+n.vsize] +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main_test.go new file mode 100644 index 000000000..6b05ac23d --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/main_test.go @@ -0,0 +1,145 @@ +package main_test + +import ( + "bytes" + "io/ioutil" + "os" + "strconv" + "testing" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt" +) + +// Ensure the "info" command can print information about a database. +func TestInfoCommand_Run(t *testing.T) { + db := MustOpen(0666, nil) + db.DB.Close() + defer db.Close() + + // Run the info command. + m := NewMain() + if err := m.Run("info", db.Path); err != nil { + t.Fatal(err) + } +} + +// Ensure the "stats" command can execute correctly. +func TestStatsCommand_Run(t *testing.T) { + // Ignore + if os.Getpagesize() != 4096 { + t.Skip("system does not use 4KB page size") + } + + db := MustOpen(0666, nil) + defer db.Close() + + if err := db.Update(func(tx *bolt.Tx) error { + // Create "foo" bucket. + b, err := tx.CreateBucket([]byte("foo")) + if err != nil { + return err + } + for i := 0; i < 10; i++ { + if err := b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil { + return err + } + } + + // Create "bar" bucket. + b, err = tx.CreateBucket([]byte("bar")) + if err != nil { + return err + } + for i := 0; i < 100; i++ { + if err := b.Put([]byte(strconv.Itoa(i)), []byte(strconv.Itoa(i))); err != nil { + return err + } + } + + // Create "baz" bucket. + b, err = tx.CreateBucket([]byte("baz")) + if err != nil { + return err + } + if err := b.Put([]byte("key"), []byte("value")); err != nil { + return err + } + + return nil + }); err != nil { + t.Fatal(err) + } + db.DB.Close() + + // Generate expected result. + exp := "Aggregate statistics for 3 buckets\n\n" + + "Page count statistics\n" + + "\tNumber of logical branch pages: 0\n" + + "\tNumber of physical branch overflow pages: 0\n" + + "\tNumber of logical leaf pages: 1\n" + + "\tNumber of physical leaf overflow pages: 0\n" + + "Tree statistics\n" + + "\tNumber of keys/value pairs: 111\n" + + "\tNumber of levels in B+tree: 1\n" + + "Page size utilization\n" + + "\tBytes allocated for physical branch pages: 0\n" + + "\tBytes actually used for branch data: 0 (0%)\n" + + "\tBytes allocated for physical leaf pages: 4096\n" + + "\tBytes actually used for leaf data: 1996 (48%)\n" + + "Bucket statistics\n" + + "\tTotal number of buckets: 3\n" + + "\tTotal number on inlined buckets: 2 (66%)\n" + + "\tBytes used for inlined buckets: 236 (11%)\n" + + // Run the command. + m := NewMain() + if err := m.Run("stats", db.Path); err != nil { + t.Fatal(err) + } else if m.Stdout.String() != exp { + t.Fatalf("unexpected stdout:\n\n%s", m.Stdout.String()) + } +} + +// Main represents a test wrapper for main.Main that records output. +type Main struct { + *main.Main + Stdin bytes.Buffer + Stdout bytes.Buffer + Stderr bytes.Buffer +} + +// NewMain returns a new instance of Main. +func NewMain() *Main { + m := &Main{Main: main.NewMain()} + m.Main.Stdin = &m.Stdin + m.Main.Stdout = &m.Stdout + m.Main.Stderr = &m.Stderr + return m +} + +// MustOpen creates a Bolt database in a temporary location. +func MustOpen(mode os.FileMode, options *bolt.Options) *DB { + // Create temporary path. + f, _ := ioutil.TempFile("", "bolt-") + f.Close() + os.Remove(f.Name()) + + db, err := bolt.Open(f.Name(), mode, options) + if err != nil { + panic(err.Error()) + } + return &DB{DB: db, Path: f.Name()} +} + +// DB is a test wrapper for bolt.DB. +type DB struct { + *bolt.DB + Path string +} + +// Close closes and removes the database. +func (db *DB) Close() error { + defer os.Remove(db.Path) + return db.DB.Close() +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/p.out b/Godeps/_workspace/src/github.com/boltdb/bolt/cmd/bolt/p.out new file mode 100644 index 0000000000000000000000000000000000000000..ace9346e745ac9c07d152124967fcdf89a0d7ce4 GIT binary patch literal 45272 zcmdU2X^>XM6@AFQ51_b&1c(L|2_PB?qLD(QaRp2nTqr9=EH#mm0W=^2V{j=!twaO@ zg9sw!J|aX!ksTx=qY)8sK#YXN3WW(qrBIBdiqprbIicSj%lW!n|6IR$y!TGuy>H*{ zmu2{`wxc9PC-VP5Yq_6CI9fU!cg*cm=g?pD`hShme3Omq*7z-a(+&Pv&+loB|90c~|1qvx^4I&RH>5g#a68L*-QvF`f7KsoOXc$| z{#pF_!r;#qLw~r^n0Q)eoOzX_n$sG-@bMH)EiQZzt;`H z^M^S9#rsGt`6_>SAF0|0|4wS@U&TE9OUj@3k?Q-^|62O1_Nn(<@;kxMuOh?0tNd!( zKA&F!k3#wC_>_P8e#NKvt9JQ&b z+STw67XKfT@$ct@vl`0U>uG__pKo@t<*cNEgJ{X;Tqj%i81j?A7=^Hc%dE>5&zOUXyyY>WTGy zOHV94wBi`&i@to!swXLac-6{$)MrO6U7o$_L0IgUpFytsABLQN_;XO^U!Y%m`b|=m8@Ny@S4%I|Kdatb{>Ac7s`rY| ziXZ11{OjZ5JNcvdwa%;8XBc%zjem+??Mk0N(^$vTbuzvGq^qjxHRVof@lXA~;#d9A z_gnm99o!fHto%spEc*UCjCH0}27ikrztQJg_F>6yy77LWel&4@wU_g&Ge*I$7P{VI zjaTD6^^DZgmrj4Ks;|m#t8S+LLho;7%!e&`lp6ACb!z^6L-CO>q~A0S>-cO)^{i*MaPL{}`lV|1Kz^fjvCw&0k;BzD1D;-I9v)YyJn=|}r_l?*an)d0 z)JMypFSDH9s2=I>LhBX%0p)tBtD7(L)H_4TwZ7vYaW!>ycjb@%4$ZIHiSSG1*d{St zw1*DGu!l)&Kz9v;U2Ob4=+u#*2W|&#@9ONK^p1Qa-ipEB4ZN+Kz3h7pcxT;`7GFR7qX_@wy(`Bd>1__U%Jd^+Fh+l?Ojsp#buGjab}_kh;) zdJprE*&7h&w><~Ve7hOmx8^)h+68H-_(s2c^8(;td>hsQzpwa3ReXiUMZIDkFm-NK zT+c2Jo39ZM`PA3>(5hZDz5iQt$Xd3}KV7#A4_^>^VK#E%}1wx1W*FH(Q$ryq&z4;9b+MDWlr zURw_Ny>L9_rg1fN+^5_=N{mluuZ1MXJ%Tv@$xEQ2r&3nJs8UQ=%SJ@ysb-mXi8Pn26pWIUXQ5YLRn@XU&ghk8x^JQEqub~i5~ zo@@u^8^^B)-P944(Uo;T*Ud+K`O%}Gg{nso&r6Z{LwV5;{dyuad}dFKzhUIMNHZtD z0Uy>o^nc5?f;M;`baO+DU`b;~YpBm%?fk7opP7>!G3f zLw)5uZcrlYqpZ8J|D#O$w3ZZ_s(6QHQnEaYIc^fPjC2kX!6+w>Z>E)nKx=*&x6DB`+7pz4{_3-neX4{*^dzF z{1oEhzKm4x@Z6f%cv$zSZ}iuM&a)XGs8_lliGGOJTg&+aShc8}f9{rZ+_cP z()Sl%TdHGRG% z`SU?r==UWZ@xEC7;^YhU{9e~jGUhDcIx}*=md5-06T=5B$uipExXAtgtb^#J8d(Q=r<(JHLdQ$` z4dQ$~ah$ZtiWx0=dSH6T~&i%`a0q=ZA51!)C+>-#L60#yP=Tw;-eO-G8a)dmHqtdM-#) zV_$e^J7nHbG6@>|rW)ownS+Bp_Y%i$?f**{7>YbW&q)>F9d7i)e;ze=2SWqm=< zRf%<;5B&vks@^#6M9H2+S&^-sr_GZN|NV;s;rjm80M z9Y1v5$#pcIHC6oj*0c(*F%{=lgvo=ho5B#q!ULYd6UEy<)9L(ym9ly#9gN zm{(7Yy#JVT{ChR)g`w@2_|_(hk8-W# zZ3P|nE~wSN5n2z(=N5^qr!bx~z6_VX60Yl~_Pr3|)&A5}@zVbJoq$yN`LXOTPL-dG zi>%wQ4<=S09_{+$*I`lZ5~(*=w?CNkstJkJ8JI`XFQtZ)eKfRh?Q^63q|z64sqB|c z1s~=7`5bWcDNh_qg^!b}xqcZdznGF(eolXFohub8ucW=scKr}-SHf>!v=ns4GoT+v z`W_zn#r0m_cOydai}CH+#MYn5r{5a+bSOSCFD-L=b?02@(HjlY>?z&%Ctp zQV*B7{-puU(^%KXEHulGT!DFKtLH%r{T*|@w_o7zBJ#b=cbJ#$9Eouk>icKh7k71m zzi-bvHqRYA+SSRqAAsw`h5r5|-_P&Qz1$ASE;$K$AL{)Tp1M_`-_JNb!}ZG)xxR~3 z`W%jS^{H2OKrVkc8PvD`lKFOO^MC65zofqh)?B$ywV9lg#QR9Ezcs)AXZ-6`uk)NG z`t?uU{5h3=E$UyXXB{{8`T+U%LZbQppPb$L*8f7~W!yKh{@J*BJ#mzI&e!5TmqOd0qX6)6X`3U zzHlC;eFfJ3kI?n%r4BH0^ISsqcku6|`rYXtOMl26Zr;KB^?HMmi1)lsePUeIb?sEn zd!U}N?=F>mlepF-wtt7Xo_rJY5^(3(0AiTdla%j)hc3SGaY zUF`78w_^7-QqDsY*;lj_?&a(6?y*nc?s8Np7PiFq9Dep2%w$^5f}Yj%_Z(U}$435e z-?I95{T({r^q^p-y`P~ah@D&y~n9lMtquo#m1*`bfD~KNChA5;h4nM4Jg;g z6J5t6z6puq<9hAo%b)SiDs7z1Q@C#ATaS#*SLRi;YsR^QOA%l9F9MAf z=g7w{Zl90#Nn78U4V~{%KTnW-NU7oEI;+*sAF7^5JRcc#fY5k8NemCq!5tC#JHp&| z!TfynTIA=0+8{rFZv*^BYW=!j>zOu%VScW7 zV#|wh+wxPP;~>}di`+gJ&R=>o1}AI!TrYT^EYov7`Q8U=_`TFmuIF K+l+e2-~R*lY0YK; literal 0 HcmV?d00001 diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/cursor.go b/Godeps/_workspace/src/github.com/boltdb/bolt/cursor.go new file mode 100644 index 000000000..006c54889 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/cursor.go @@ -0,0 +1,384 @@ +package bolt + +import ( + "bytes" + "fmt" + "sort" +) + +// Cursor represents an iterator that can traverse over all key/value pairs in a bucket in sorted order. +// Cursors see nested buckets with value == nil. +// Cursors can be obtained from a transaction and are valid as long as the transaction is open. +// +// Keys and values returned from the cursor are only valid for the life of the transaction. +// +// Changing data while traversing with a cursor may cause it to be invalidated +// and return unexpected keys and/or values. You must reposition your cursor +// after mutating data. +type Cursor struct { + bucket *Bucket + stack []elemRef +} + +// Bucket returns the bucket that this cursor was created from. +func (c *Cursor) Bucket() *Bucket { + return c.bucket +} + +// First moves the cursor to the first item in the bucket and returns its key and value. +// If the bucket is empty then a nil key and value are returned. +// The returned key and value are only valid for the life of the transaction. +func (c *Cursor) First() (key []byte, value []byte) { + _assert(c.bucket.tx.db != nil, "tx closed") + c.stack = c.stack[:0] + p, n := c.bucket.pageNode(c.bucket.root) + c.stack = append(c.stack, elemRef{page: p, node: n, index: 0}) + c.first() + k, v, flags := c.keyValue() + if (flags & uint32(bucketLeafFlag)) != 0 { + return k, nil + } + return k, v + +} + +// Last moves the cursor to the last item in the bucket and returns its key and value. +// If the bucket is empty then a nil key and value are returned. +// The returned key and value are only valid for the life of the transaction. +func (c *Cursor) Last() (key []byte, value []byte) { + _assert(c.bucket.tx.db != nil, "tx closed") + c.stack = c.stack[:0] + p, n := c.bucket.pageNode(c.bucket.root) + ref := elemRef{page: p, node: n} + ref.index = ref.count() - 1 + c.stack = append(c.stack, ref) + c.last() + k, v, flags := c.keyValue() + if (flags & uint32(bucketLeafFlag)) != 0 { + return k, nil + } + return k, v +} + +// Next moves the cursor to the next item in the bucket and returns its key and value. +// If the cursor is at the end of the bucket then a nil key and value are returned. +// The returned key and value are only valid for the life of the transaction. +func (c *Cursor) Next() (key []byte, value []byte) { + _assert(c.bucket.tx.db != nil, "tx closed") + k, v, flags := c.next() + if (flags & uint32(bucketLeafFlag)) != 0 { + return k, nil + } + return k, v +} + +// Prev moves the cursor to the previous item in the bucket and returns its key and value. +// If the cursor is at the beginning of the bucket then a nil key and value are returned. +// The returned key and value are only valid for the life of the transaction. +func (c *Cursor) Prev() (key []byte, value []byte) { + _assert(c.bucket.tx.db != nil, "tx closed") + + // Attempt to move back one element until we're successful. + // Move up the stack as we hit the beginning of each page in our stack. + for i := len(c.stack) - 1; i >= 0; i-- { + elem := &c.stack[i] + if elem.index > 0 { + elem.index-- + break + } + c.stack = c.stack[:i] + } + + // If we've hit the end then return nil. + if len(c.stack) == 0 { + return nil, nil + } + + // Move down the stack to find the last element of the last leaf under this branch. + c.last() + k, v, flags := c.keyValue() + if (flags & uint32(bucketLeafFlag)) != 0 { + return k, nil + } + return k, v +} + +// Seek moves the cursor to a given key and returns it. +// If the key does not exist then the next key is used. If no keys +// follow, a nil key is returned. +// The returned key and value are only valid for the life of the transaction. +func (c *Cursor) Seek(seek []byte) (key []byte, value []byte) { + k, v, flags := c.seek(seek) + + // If we ended up after the last element of a page then move to the next one. + if ref := &c.stack[len(c.stack)-1]; ref.index >= ref.count() { + k, v, flags = c.next() + } + + if k == nil { + return nil, nil + } else if (flags & uint32(bucketLeafFlag)) != 0 { + return k, nil + } + return k, v +} + +// Delete removes the current key/value under the cursor from the bucket. +// Delete fails if current key/value is a bucket or if the transaction is not writable. +func (c *Cursor) Delete() error { + if c.bucket.tx.db == nil { + return ErrTxClosed + } else if !c.bucket.Writable() { + return ErrTxNotWritable + } + + key, _, flags := c.keyValue() + // Return an error if current value is a bucket. + if (flags & bucketLeafFlag) != 0 { + return ErrIncompatibleValue + } + c.node().del(key) + + return nil +} + +// seek moves the cursor to a given key and returns it. +// If the key does not exist then the next key is used. +func (c *Cursor) seek(seek []byte) (key []byte, value []byte, flags uint32) { + _assert(c.bucket.tx.db != nil, "tx closed") + + // Start from root page/node and traverse to correct page. + c.stack = c.stack[:0] + c.search(seek, c.bucket.root) + ref := &c.stack[len(c.stack)-1] + + // If the cursor is pointing to the end of page/node then return nil. + if ref.index >= ref.count() { + return nil, nil, 0 + } + + // If this is a bucket then return a nil value. + return c.keyValue() +} + +// first moves the cursor to the first leaf element under the last page in the stack. +func (c *Cursor) first() { + for { + // Exit when we hit a leaf page. + var ref = &c.stack[len(c.stack)-1] + if ref.isLeaf() { + break + } + + // Keep adding pages pointing to the first element to the stack. + var pgid pgid + if ref.node != nil { + pgid = ref.node.inodes[ref.index].pgid + } else { + pgid = ref.page.branchPageElement(uint16(ref.index)).pgid + } + p, n := c.bucket.pageNode(pgid) + c.stack = append(c.stack, elemRef{page: p, node: n, index: 0}) + } +} + +// last moves the cursor to the last leaf element under the last page in the stack. +func (c *Cursor) last() { + for { + // Exit when we hit a leaf page. + ref := &c.stack[len(c.stack)-1] + if ref.isLeaf() { + break + } + + // Keep adding pages pointing to the last element in the stack. + var pgid pgid + if ref.node != nil { + pgid = ref.node.inodes[ref.index].pgid + } else { + pgid = ref.page.branchPageElement(uint16(ref.index)).pgid + } + p, n := c.bucket.pageNode(pgid) + + var nextRef = elemRef{page: p, node: n} + nextRef.index = nextRef.count() - 1 + c.stack = append(c.stack, nextRef) + } +} + +// next moves to the next leaf element and returns the key and value. +// If the cursor is at the last leaf element then it stays there and returns nil. +func (c *Cursor) next() (key []byte, value []byte, flags uint32) { + // Attempt to move over one element until we're successful. + // Move up the stack as we hit the end of each page in our stack. + var i int + for i = len(c.stack) - 1; i >= 0; i-- { + elem := &c.stack[i] + if elem.index < elem.count()-1 { + elem.index++ + break + } + } + + // If we've hit the root page then stop and return. This will leave the + // cursor on the last element of the last page. + if i == -1 { + return nil, nil, 0 + } + + // Otherwise start from where we left off in the stack and find the + // first element of the first leaf page. + c.stack = c.stack[:i+1] + c.first() + return c.keyValue() +} + +// search recursively performs a binary search against a given page/node until it finds a given key. +func (c *Cursor) search(key []byte, pgid pgid) { + p, n := c.bucket.pageNode(pgid) + if p != nil && (p.flags&(branchPageFlag|leafPageFlag)) == 0 { + panic(fmt.Sprintf("invalid page type: %d: %x", p.id, p.flags)) + } + e := elemRef{page: p, node: n} + c.stack = append(c.stack, e) + + // If we're on a leaf page/node then find the specific node. + if e.isLeaf() { + c.nsearch(key) + return + } + + if n != nil { + c.searchNode(key, n) + return + } + c.searchPage(key, p) +} + +func (c *Cursor) searchNode(key []byte, n *node) { + var exact bool + index := sort.Search(len(n.inodes), func(i int) bool { + // TODO(benbjohnson): Optimize this range search. It's a bit hacky right now. + // sort.Search() finds the lowest index where f() != -1 but we need the highest index. + ret := bytes.Compare(n.inodes[i].key, key) + if ret == 0 { + exact = true + } + return ret != -1 + }) + if !exact && index > 0 { + index-- + } + c.stack[len(c.stack)-1].index = index + + // Recursively search to the next page. + c.search(key, n.inodes[index].pgid) +} + +func (c *Cursor) searchPage(key []byte, p *page) { + // Binary search for the correct range. + inodes := p.branchPageElements() + + var exact bool + index := sort.Search(int(p.count), func(i int) bool { + // TODO(benbjohnson): Optimize this range search. It's a bit hacky right now. + // sort.Search() finds the lowest index where f() != -1 but we need the highest index. + ret := bytes.Compare(inodes[i].key(), key) + if ret == 0 { + exact = true + } + return ret != -1 + }) + if !exact && index > 0 { + index-- + } + c.stack[len(c.stack)-1].index = index + + // Recursively search to the next page. + c.search(key, inodes[index].pgid) +} + +// nsearch searches the leaf node on the top of the stack for a key. +func (c *Cursor) nsearch(key []byte) { + e := &c.stack[len(c.stack)-1] + p, n := e.page, e.node + + // If we have a node then search its inodes. + if n != nil { + index := sort.Search(len(n.inodes), func(i int) bool { + return bytes.Compare(n.inodes[i].key, key) != -1 + }) + e.index = index + return + } + + // If we have a page then search its leaf elements. + inodes := p.leafPageElements() + index := sort.Search(int(p.count), func(i int) bool { + return bytes.Compare(inodes[i].key(), key) != -1 + }) + e.index = index +} + +// keyValue returns the key and value of the current leaf element. +func (c *Cursor) keyValue() ([]byte, []byte, uint32) { + ref := &c.stack[len(c.stack)-1] + if ref.count() == 0 || ref.index >= ref.count() { + return nil, nil, 0 + } + + // Retrieve value from node. + if ref.node != nil { + inode := &ref.node.inodes[ref.index] + return inode.key, inode.value, inode.flags + } + + // Or retrieve value from page. + elem := ref.page.leafPageElement(uint16(ref.index)) + return elem.key(), elem.value(), elem.flags +} + +// node returns the node that the cursor is currently positioned on. +func (c *Cursor) node() *node { + _assert(len(c.stack) > 0, "accessing a node with a zero-length cursor stack") + + // If the top of the stack is a leaf node then just return it. + if ref := &c.stack[len(c.stack)-1]; ref.node != nil && ref.isLeaf() { + return ref.node + } + + // Start from root and traverse down the hierarchy. + var n = c.stack[0].node + if n == nil { + n = c.bucket.node(c.stack[0].page.id, nil) + } + for _, ref := range c.stack[:len(c.stack)-1] { + _assert(!n.isLeaf, "expected branch node") + n = n.childAt(int(ref.index)) + } + _assert(n.isLeaf, "expected leaf node") + return n +} + +// elemRef represents a reference to an element on a given page/node. +type elemRef struct { + page *page + node *node + index int +} + +// isLeaf returns whether the ref is pointing at a leaf page/node. +func (r *elemRef) isLeaf() bool { + if r.node != nil { + return r.node.isLeaf + } + return (r.page.flags & leafPageFlag) != 0 +} + +// count returns the number of inodes or page elements. +func (r *elemRef) count() int { + if r.node != nil { + return len(r.node.inodes) + } + return int(r.page.count) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/cursor_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/cursor_test.go new file mode 100644 index 000000000..5f8ca5b5a --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/cursor_test.go @@ -0,0 +1,511 @@ +package bolt_test + +import ( + "bytes" + "encoding/binary" + "fmt" + "os" + "sort" + "testing" + "testing/quick" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +// Ensure that a cursor can return a reference to the bucket that created it. +func TestCursor_Bucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucket([]byte("widgets")) + c := b.Cursor() + equals(t, b, c.Bucket()) + return nil + }) +} + +// Ensure that a Tx cursor can seek to the appropriate keys. +func TestCursor_Seek(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + ok(t, b.Put([]byte("foo"), []byte("0001"))) + ok(t, b.Put([]byte("bar"), []byte("0002"))) + ok(t, b.Put([]byte("baz"), []byte("0003"))) + _, err = b.CreateBucket([]byte("bkt")) + ok(t, err) + return nil + }) + db.View(func(tx *bolt.Tx) error { + c := tx.Bucket([]byte("widgets")).Cursor() + + // Exact match should go to the key. + k, v := c.Seek([]byte("bar")) + equals(t, []byte("bar"), k) + equals(t, []byte("0002"), v) + + // Inexact match should go to the next key. + k, v = c.Seek([]byte("bas")) + equals(t, []byte("baz"), k) + equals(t, []byte("0003"), v) + + // Low key should go to the first key. + k, v = c.Seek([]byte("")) + equals(t, []byte("bar"), k) + equals(t, []byte("0002"), v) + + // High key should return no key. + k, v = c.Seek([]byte("zzz")) + assert(t, k == nil, "") + assert(t, v == nil, "") + + // Buckets should return their key but no value. + k, v = c.Seek([]byte("bkt")) + equals(t, []byte("bkt"), k) + assert(t, v == nil, "") + + return nil + }) +} + +func TestCursor_Delete(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var count = 1000 + + // Insert every other key between 0 and $count. + db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucket([]byte("widgets")) + for i := 0; i < count; i += 1 { + k := make([]byte, 8) + binary.BigEndian.PutUint64(k, uint64(i)) + b.Put(k, make([]byte, 100)) + } + b.CreateBucket([]byte("sub")) + return nil + }) + + db.Update(func(tx *bolt.Tx) error { + c := tx.Bucket([]byte("widgets")).Cursor() + bound := make([]byte, 8) + binary.BigEndian.PutUint64(bound, uint64(count/2)) + for key, _ := c.First(); bytes.Compare(key, bound) < 0; key, _ = c.Next() { + if err := c.Delete(); err != nil { + return err + } + } + c.Seek([]byte("sub")) + err := c.Delete() + equals(t, err, bolt.ErrIncompatibleValue) + return nil + }) + + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + equals(t, b.Stats().KeyN, count/2+1) + return nil + }) +} + +// Ensure that a Tx cursor can seek to the appropriate keys when there are a +// large number of keys. This test also checks that seek will always move +// forward to the next key. +// +// Related: https://github.com/boltdb/bolt/pull/187 +func TestCursor_Seek_Large(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var count = 10000 + + // Insert every other key between 0 and $count. + db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucket([]byte("widgets")) + for i := 0; i < count; i += 100 { + for j := i; j < i+100; j += 2 { + k := make([]byte, 8) + binary.BigEndian.PutUint64(k, uint64(j)) + b.Put(k, make([]byte, 100)) + } + } + return nil + }) + + db.View(func(tx *bolt.Tx) error { + c := tx.Bucket([]byte("widgets")).Cursor() + for i := 0; i < count; i++ { + seek := make([]byte, 8) + binary.BigEndian.PutUint64(seek, uint64(i)) + + k, _ := c.Seek(seek) + + // The last seek is beyond the end of the the range so + // it should return nil. + if i == count-1 { + assert(t, k == nil, "") + continue + } + + // Otherwise we should seek to the exact key or the next key. + num := binary.BigEndian.Uint64(k) + if i%2 == 0 { + equals(t, uint64(i), num) + } else { + equals(t, uint64(i+1), num) + } + } + + return nil + }) +} + +// Ensure that a cursor can iterate over an empty bucket without error. +func TestCursor_EmptyBucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + db.View(func(tx *bolt.Tx) error { + c := tx.Bucket([]byte("widgets")).Cursor() + k, v := c.First() + assert(t, k == nil, "") + assert(t, v == nil, "") + return nil + }) +} + +// Ensure that a Tx cursor can reverse iterate over an empty bucket without error. +func TestCursor_EmptyBucketReverse(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + db.View(func(tx *bolt.Tx) error { + c := tx.Bucket([]byte("widgets")).Cursor() + k, v := c.Last() + assert(t, k == nil, "") + assert(t, v == nil, "") + return nil + }) +} + +// Ensure that a Tx cursor can iterate over a single root with a couple elements. +func TestCursor_Iterate_Leaf(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte{}) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte{0}) + tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte{1}) + return nil + }) + tx, _ := db.Begin(false) + c := tx.Bucket([]byte("widgets")).Cursor() + + k, v := c.First() + equals(t, string(k), "bar") + equals(t, v, []byte{1}) + + k, v = c.Next() + equals(t, string(k), "baz") + equals(t, v, []byte{}) + + k, v = c.Next() + equals(t, string(k), "foo") + equals(t, v, []byte{0}) + + k, v = c.Next() + assert(t, k == nil, "") + assert(t, v == nil, "") + + k, v = c.Next() + assert(t, k == nil, "") + assert(t, v == nil, "") + + tx.Rollback() +} + +// Ensure that a Tx cursor can iterate in reverse over a single root with a couple elements. +func TestCursor_LeafRootReverse(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte{}) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte{0}) + tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte{1}) + return nil + }) + tx, _ := db.Begin(false) + c := tx.Bucket([]byte("widgets")).Cursor() + + k, v := c.Last() + equals(t, string(k), "foo") + equals(t, v, []byte{0}) + + k, v = c.Prev() + equals(t, string(k), "baz") + equals(t, v, []byte{}) + + k, v = c.Prev() + equals(t, string(k), "bar") + equals(t, v, []byte{1}) + + k, v = c.Prev() + assert(t, k == nil, "") + assert(t, v == nil, "") + + k, v = c.Prev() + assert(t, k == nil, "") + assert(t, v == nil, "") + + tx.Rollback() +} + +// Ensure that a Tx cursor can restart from the beginning. +func TestCursor_Restart(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("bar"), []byte{}) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte{}) + return nil + }) + + tx, _ := db.Begin(false) + c := tx.Bucket([]byte("widgets")).Cursor() + + k, _ := c.First() + equals(t, string(k), "bar") + + k, _ = c.Next() + equals(t, string(k), "foo") + + k, _ = c.First() + equals(t, string(k), "bar") + + k, _ = c.Next() + equals(t, string(k), "foo") + + tx.Rollback() +} + +// Ensure that a Tx can iterate over all elements in a bucket. +func TestCursor_QuickCheck(t *testing.T) { + f := func(items testdata) bool { + db := NewTestDB() + defer db.Close() + + // Bulk insert all values. + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + for _, item := range items { + ok(t, b.Put(item.Key, item.Value)) + } + ok(t, tx.Commit()) + + // Sort test data. + sort.Sort(items) + + // Iterate over all items and check consistency. + var index = 0 + tx, _ = db.Begin(false) + c := tx.Bucket([]byte("widgets")).Cursor() + for k, v := c.First(); k != nil && index < len(items); k, v = c.Next() { + equals(t, k, items[index].Key) + equals(t, v, items[index].Value) + index++ + } + equals(t, len(items), index) + tx.Rollback() + + return true + } + if err := quick.Check(f, qconfig()); err != nil { + t.Error(err) + } +} + +// Ensure that a transaction can iterate over all elements in a bucket in reverse. +func TestCursor_QuickCheck_Reverse(t *testing.T) { + f := func(items testdata) bool { + db := NewTestDB() + defer db.Close() + + // Bulk insert all values. + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + for _, item := range items { + ok(t, b.Put(item.Key, item.Value)) + } + ok(t, tx.Commit()) + + // Sort test data. + sort.Sort(revtestdata(items)) + + // Iterate over all items and check consistency. + var index = 0 + tx, _ = db.Begin(false) + c := tx.Bucket([]byte("widgets")).Cursor() + for k, v := c.Last(); k != nil && index < len(items); k, v = c.Prev() { + equals(t, k, items[index].Key) + equals(t, v, items[index].Value) + index++ + } + equals(t, len(items), index) + tx.Rollback() + + return true + } + if err := quick.Check(f, qconfig()); err != nil { + t.Error(err) + } +} + +// Ensure that a Tx cursor can iterate over subbuckets. +func TestCursor_QuickCheck_BucketsOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + _, err = b.CreateBucket([]byte("foo")) + ok(t, err) + _, err = b.CreateBucket([]byte("bar")) + ok(t, err) + _, err = b.CreateBucket([]byte("baz")) + ok(t, err) + return nil + }) + db.View(func(tx *bolt.Tx) error { + var names []string + c := tx.Bucket([]byte("widgets")).Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + names = append(names, string(k)) + assert(t, v == nil, "") + } + equals(t, names, []string{"bar", "baz", "foo"}) + return nil + }) +} + +// Ensure that a Tx cursor can reverse iterate over subbuckets. +func TestCursor_QuickCheck_BucketsOnly_Reverse(t *testing.T) { + db := NewTestDB() + defer db.Close() + + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + ok(t, err) + _, err = b.CreateBucket([]byte("foo")) + ok(t, err) + _, err = b.CreateBucket([]byte("bar")) + ok(t, err) + _, err = b.CreateBucket([]byte("baz")) + ok(t, err) + return nil + }) + db.View(func(tx *bolt.Tx) error { + var names []string + c := tx.Bucket([]byte("widgets")).Cursor() + for k, v := c.Last(); k != nil; k, v = c.Prev() { + names = append(names, string(k)) + assert(t, v == nil, "") + } + equals(t, names, []string{"foo", "baz", "bar"}) + return nil + }) +} + +func ExampleCursor() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Start a read-write transaction. + db.Update(func(tx *bolt.Tx) error { + // Create a new bucket. + tx.CreateBucket([]byte("animals")) + + // Insert data into a bucket. + b := tx.Bucket([]byte("animals")) + b.Put([]byte("dog"), []byte("fun")) + b.Put([]byte("cat"), []byte("lame")) + b.Put([]byte("liger"), []byte("awesome")) + + // Create a cursor for iteration. + c := b.Cursor() + + // Iterate over items in sorted key order. This starts from the + // first key/value pair and updates the k/v variables to the + // next key/value on each iteration. + // + // The loop finishes at the end of the cursor when a nil key is returned. + for k, v := c.First(); k != nil; k, v = c.Next() { + fmt.Printf("A %s is %s.\n", k, v) + } + + return nil + }) + + // Output: + // A cat is lame. + // A dog is fun. + // A liger is awesome. +} + +func ExampleCursor_reverse() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Start a read-write transaction. + db.Update(func(tx *bolt.Tx) error { + // Create a new bucket. + tx.CreateBucket([]byte("animals")) + + // Insert data into a bucket. + b := tx.Bucket([]byte("animals")) + b.Put([]byte("dog"), []byte("fun")) + b.Put([]byte("cat"), []byte("lame")) + b.Put([]byte("liger"), []byte("awesome")) + + // Create a cursor for iteration. + c := b.Cursor() + + // Iterate over items in reverse sorted key order. This starts + // from the last key/value pair and updates the k/v variables to + // the previous key/value on each iteration. + // + // The loop finishes at the beginning of the cursor when a nil key + // is returned. + for k, v := c.Last(); k != nil; k, v = c.Prev() { + fmt.Printf("A %s is %s.\n", k, v) + } + + return nil + }) + + // Output: + // A liger is awesome. + // A dog is fun. + // A cat is lame. +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/db.go b/Godeps/_workspace/src/github.com/boltdb/bolt/db.go new file mode 100644 index 000000000..8f0e90b55 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/db.go @@ -0,0 +1,732 @@ +package bolt + +import ( + "fmt" + "hash/fnv" + "os" + "runtime" + "runtime/debug" + "strings" + "sync" + "time" + "unsafe" +) + +// The largest step that can be taken when remapping the mmap. +const maxMmapStep = 1 << 30 // 1GB + +// The data file format version. +const version = 2 + +// Represents a marker value to indicate that a file is a Bolt DB. +const magic uint32 = 0xED0CDAED + +// IgnoreNoSync specifies whether the NoSync field of a DB is ignored when +// syncing changes to a file. This is required as some operating systems, +// such as OpenBSD, do not have a unified buffer cache (UBC) and writes +// must be synchronzied using the msync(2) syscall. +const IgnoreNoSync = runtime.GOOS == "openbsd" + +// Default values if not set in a DB instance. +const ( + DefaultMaxBatchSize int = 1000 + DefaultMaxBatchDelay = 10 * time.Millisecond +) + +// DB represents a collection of buckets persisted to a file on disk. +// All data access is performed through transactions which can be obtained through the DB. +// All the functions on DB will return a ErrDatabaseNotOpen if accessed before Open() is called. +type DB struct { + // When enabled, the database will perform a Check() after every commit. + // A panic is issued if the database is in an inconsistent state. This + // flag has a large performance impact so it should only be used for + // debugging purposes. + StrictMode bool + + // Setting the NoSync flag will cause the database to skip fsync() + // calls after each commit. This can be useful when bulk loading data + // into a database and you can restart the bulk load in the event of + // a system failure or database corruption. Do not set this flag for + // normal use. + // + // If the package global IgnoreNoSync constant is true, this value is + // ignored. See the comment on that constant for more details. + // + // THIS IS UNSAFE. PLEASE USE WITH CAUTION. + NoSync bool + + // MaxBatchSize is the maximum size of a batch. Default value is + // copied from DefaultMaxBatchSize in Open. + // + // If <=0, disables batching. + // + // Do not change concurrently with calls to Batch. + MaxBatchSize int + + // MaxBatchDelay is the maximum delay before a batch starts. + // Default value is copied from DefaultMaxBatchDelay in Open. + // + // If <=0, effectively disables batching. + // + // Do not change concurrently with calls to Batch. + MaxBatchDelay time.Duration + + path string + file *os.File + dataref []byte // mmap'ed readonly, write throws SEGV + data *[maxMapSize]byte + datasz int + meta0 *meta + meta1 *meta + pageSize int + opened bool + rwtx *Tx + txs []*Tx + freelist *freelist + stats Stats + + batchMu sync.Mutex + batch *batch + + rwlock sync.Mutex // Allows only one writer at a time. + metalock sync.Mutex // Protects meta page access. + mmaplock sync.RWMutex // Protects mmap access during remapping. + statlock sync.RWMutex // Protects stats access. + + ops struct { + writeAt func(b []byte, off int64) (n int, err error) + } +} + +// Path returns the path to currently open database file. +func (db *DB) Path() string { + return db.path +} + +// GoString returns the Go string representation of the database. +func (db *DB) GoString() string { + return fmt.Sprintf("bolt.DB{path:%q}", db.path) +} + +// String returns the string representation of the database. +func (db *DB) String() string { + return fmt.Sprintf("DB<%q>", db.path) +} + +// Open creates and opens a database at the given path. +// If the file does not exist then it will be created automatically. +// Passing in nil options will cause Bolt to open the database with the default options. +func Open(path string, mode os.FileMode, options *Options) (*DB, error) { + var db = &DB{opened: true} + + // Set default options if no options are provided. + if options == nil { + options = DefaultOptions + } + + // Set default values for later DB operations. + db.MaxBatchSize = DefaultMaxBatchSize + db.MaxBatchDelay = DefaultMaxBatchDelay + + // Open data file and separate sync handler for metadata writes. + db.path = path + + var err error + if db.file, err = os.OpenFile(db.path, os.O_RDWR|os.O_CREATE, mode); err != nil { + _ = db.close() + return nil, err + } + + // Lock file so that other processes using Bolt cannot use the database + // at the same time. This would cause corruption since the two processes + // would write meta pages and free pages separately. + if err := flock(db.file, options.Timeout); err != nil { + _ = db.close() + return nil, err + } + + // Default values for test hooks + db.ops.writeAt = db.file.WriteAt + + // Initialize the database if it doesn't exist. + if info, err := db.file.Stat(); err != nil { + return nil, fmt.Errorf("stat error: %s", err) + } else if info.Size() == 0 { + // Initialize new files with meta pages. + if err := db.init(); err != nil { + return nil, err + } + } else { + // Read the first meta page to determine the page size. + var buf [0x1000]byte + if _, err := db.file.ReadAt(buf[:], 0); err == nil { + m := db.pageInBuffer(buf[:], 0).meta() + if err := m.validate(); err != nil { + return nil, fmt.Errorf("meta0 error: %s", err) + } + db.pageSize = int(m.pageSize) + } + } + + // Memory map the data file. + if err := db.mmap(0); err != nil { + _ = db.close() + return nil, err + } + + // Read in the freelist. + db.freelist = newFreelist() + db.freelist.read(db.page(db.meta().freelist)) + + // Mark the database as opened and return. + return db, nil +} + +// mmap opens the underlying memory-mapped file and initializes the meta references. +// minsz is the minimum size that the new mmap can be. +func (db *DB) mmap(minsz int) error { + db.mmaplock.Lock() + defer db.mmaplock.Unlock() + + info, err := db.file.Stat() + if err != nil { + return fmt.Errorf("mmap stat error: %s", err) + } else if int(info.Size()) < db.pageSize*2 { + return fmt.Errorf("file size too small") + } + + // Ensure the size is at least the minimum size. + var size = int(info.Size()) + if size < minsz { + size = minsz + } + size, err = db.mmapSize(size) + if err != nil { + return err + } + + // Dereference all mmap references before unmapping. + if db.rwtx != nil { + db.rwtx.root.dereference() + } + + // Unmap existing data before continuing. + if err := db.munmap(); err != nil { + return err + } + + // Memory-map the data file as a byte slice. + if err := mmap(db, size); err != nil { + return err + } + + // Save references to the meta pages. + db.meta0 = db.page(0).meta() + db.meta1 = db.page(1).meta() + + // Validate the meta pages. + if err := db.meta0.validate(); err != nil { + return fmt.Errorf("meta0 error: %s", err) + } + if err := db.meta1.validate(); err != nil { + return fmt.Errorf("meta1 error: %s", err) + } + + return nil +} + +// munmap unmaps the data file from memory. +func (db *DB) munmap() error { + if err := munmap(db); err != nil { + return fmt.Errorf("unmap error: " + err.Error()) + } + return nil +} + +// mmapSize determines the appropriate size for the mmap given the current size +// of the database. The minimum size is 1MB and doubles until it reaches 1GB. +// Returns an error if the new mmap size is greater than the max allowed. +func (db *DB) mmapSize(size int) (int, error) { + // Double the size from 1MB until 1GB. + for i := uint(20); i <= 30; i++ { + if size <= 1< maxMapSize { + return 0, fmt.Errorf("mmap too large") + } + + // If larger than 1GB then grow by 1GB at a time. + sz := int64(size) + if remainder := sz % int64(maxMmapStep); remainder > 0 { + sz += int64(maxMmapStep) - remainder + } + + // Ensure that the mmap size is a multiple of the page size. + // This should always be true since we're incrementing in MBs. + pageSize := int64(db.pageSize) + if (sz % pageSize) != 0 { + sz = ((sz / pageSize) + 1) * pageSize + } + + // If we've exceeded the max size then only grow up to the max size. + if sz > maxMapSize { + sz = maxMapSize + } + + return int(sz), nil +} + +// init creates a new database file and initializes its meta pages. +func (db *DB) init() error { + // Set the page size to the OS page size. + db.pageSize = os.Getpagesize() + + // Create two meta pages on a buffer. + buf := make([]byte, db.pageSize*4) + for i := 0; i < 2; i++ { + p := db.pageInBuffer(buf[:], pgid(i)) + p.id = pgid(i) + p.flags = metaPageFlag + + // Initialize the meta page. + m := p.meta() + m.magic = magic + m.version = version + m.pageSize = uint32(db.pageSize) + m.freelist = 2 + m.root = bucket{root: 3} + m.pgid = 4 + m.txid = txid(i) + } + + // Write an empty freelist at page 3. + p := db.pageInBuffer(buf[:], pgid(2)) + p.id = pgid(2) + p.flags = freelistPageFlag + p.count = 0 + + // Write an empty leaf page at page 4. + p = db.pageInBuffer(buf[:], pgid(3)) + p.id = pgid(3) + p.flags = leafPageFlag + p.count = 0 + + // Write the buffer to our data file. + if _, err := db.ops.writeAt(buf, 0); err != nil { + return err + } + if err := fdatasync(db); err != nil { + return err + } + + return nil +} + +// Close releases all database resources. +// All transactions must be closed before closing the database. +func (db *DB) Close() error { + db.metalock.Lock() + defer db.metalock.Unlock() + return db.close() +} + +func (db *DB) close() error { + db.opened = false + + db.freelist = nil + db.path = "" + + // Clear ops. + db.ops.writeAt = nil + + // Close the mmap. + if err := db.munmap(); err != nil { + return err + } + + // Close file handles. + if db.file != nil { + // Unlock the file. + _ = funlock(db.file) + + // Close the file descriptor. + if err := db.file.Close(); err != nil { + return fmt.Errorf("db file close: %s", err) + } + db.file = nil + } + + return nil +} + +// Begin starts a new transaction. +// Multiple read-only transactions can be used concurrently but only one +// write transaction can be used at a time. Starting multiple write transactions +// will cause the calls to block and be serialized until the current write +// transaction finishes. +// +// IMPORTANT: You must close read-only transactions after you are finished or +// else the database will not reclaim old pages. +func (db *DB) Begin(writable bool) (*Tx, error) { + if writable { + return db.beginRWTx() + } + return db.beginTx() +} + +func (db *DB) beginTx() (*Tx, error) { + // Lock the meta pages while we initialize the transaction. We obtain + // the meta lock before the mmap lock because that's the order that the + // write transaction will obtain them. + db.metalock.Lock() + + // Obtain a read-only lock on the mmap. When the mmap is remapped it will + // obtain a write lock so all transactions must finish before it can be + // remapped. + db.mmaplock.RLock() + + // Exit if the database is not open yet. + if !db.opened { + db.mmaplock.RUnlock() + db.metalock.Unlock() + return nil, ErrDatabaseNotOpen + } + + // Create a transaction associated with the database. + t := &Tx{} + t.init(db) + + // Keep track of transaction until it closes. + db.txs = append(db.txs, t) + n := len(db.txs) + + // Unlock the meta pages. + db.metalock.Unlock() + + // Update the transaction stats. + db.statlock.Lock() + db.stats.TxN++ + db.stats.OpenTxN = n + db.statlock.Unlock() + + return t, nil +} + +func (db *DB) beginRWTx() (*Tx, error) { + // Obtain writer lock. This is released by the transaction when it closes. + // This enforces only one writer transaction at a time. + db.rwlock.Lock() + + // Once we have the writer lock then we can lock the meta pages so that + // we can set up the transaction. + db.metalock.Lock() + defer db.metalock.Unlock() + + // Exit if the database is not open yet. + if !db.opened { + db.rwlock.Unlock() + return nil, ErrDatabaseNotOpen + } + + // Create a transaction associated with the database. + t := &Tx{writable: true} + t.init(db) + db.rwtx = t + + // Free any pages associated with closed read-only transactions. + var minid txid = 0xFFFFFFFFFFFFFFFF + for _, t := range db.txs { + if t.meta.txid < minid { + minid = t.meta.txid + } + } + if minid > 0 { + db.freelist.release(minid - 1) + } + + return t, nil +} + +// removeTx removes a transaction from the database. +func (db *DB) removeTx(tx *Tx) { + // Release the read lock on the mmap. + db.mmaplock.RUnlock() + + // Use the meta lock to restrict access to the DB object. + db.metalock.Lock() + + // Remove the transaction. + for i, t := range db.txs { + if t == tx { + db.txs = append(db.txs[:i], db.txs[i+1:]...) + break + } + } + n := len(db.txs) + + // Unlock the meta pages. + db.metalock.Unlock() + + // Merge statistics. + db.statlock.Lock() + db.stats.OpenTxN = n + db.stats.TxStats.add(&tx.stats) + db.statlock.Unlock() +} + +// Update executes a function within the context of a read-write managed transaction. +// If no error is returned from the function then the transaction is committed. +// If an error is returned then the entire transaction is rolled back. +// Any error that is returned from the function or returned from the commit is +// returned from the Update() method. +// +// Attempting to manually commit or rollback within the function will cause a panic. +func (db *DB) Update(fn func(*Tx) error) error { + t, err := db.Begin(true) + if err != nil { + return err + } + + // Make sure the transaction rolls back in the event of a panic. + defer func() { + if t.db != nil { + t.rollback() + } + }() + + // Mark as a managed tx so that the inner function cannot manually commit. + t.managed = true + + // If an error is returned from the function then rollback and return error. + err = fn(t) + t.managed = false + if err != nil { + _ = t.Rollback() + return err + } + + return t.Commit() +} + +// View executes a function within the context of a managed read-only transaction. +// Any error that is returned from the function is returned from the View() method. +// +// Attempting to manually rollback within the function will cause a panic. +func (db *DB) View(fn func(*Tx) error) error { + t, err := db.Begin(false) + if err != nil { + return err + } + + // Make sure the transaction rolls back in the event of a panic. + defer func() { + if t.db != nil { + t.rollback() + } + }() + + // Mark as a managed tx so that the inner function cannot manually rollback. + t.managed = true + + // If an error is returned from the function then pass it through. + err = fn(t) + t.managed = false + if err != nil { + _ = t.Rollback() + return err + } + + if err := t.Rollback(); err != nil { + return err + } + + return nil +} + +// Stats retrieves ongoing performance stats for the database. +// This is only updated when a transaction closes. +func (db *DB) Stats() Stats { + db.statlock.RLock() + defer db.statlock.RUnlock() + return db.stats +} + +// This is for internal access to the raw data bytes from the C cursor, use +// carefully, or not at all. +func (db *DB) Info() *Info { + return &Info{uintptr(unsafe.Pointer(&db.data[0])), db.pageSize} +} + +// page retrieves a page reference from the mmap based on the current page size. +func (db *DB) page(id pgid) *page { + pos := id * pgid(db.pageSize) + return (*page)(unsafe.Pointer(&db.data[pos])) +} + +// pageInBuffer retrieves a page reference from a given byte array based on the current page size. +func (db *DB) pageInBuffer(b []byte, id pgid) *page { + return (*page)(unsafe.Pointer(&b[id*pgid(db.pageSize)])) +} + +// meta retrieves the current meta page reference. +func (db *DB) meta() *meta { + if db.meta0.txid > db.meta1.txid { + return db.meta0 + } + return db.meta1 +} + +// allocate returns a contiguous block of memory starting at a given page. +func (db *DB) allocate(count int) (*page, error) { + // Allocate a temporary buffer for the page. + buf := make([]byte, count*db.pageSize) + p := (*page)(unsafe.Pointer(&buf[0])) + p.overflow = uint32(count - 1) + + // Use pages from the freelist if they are available. + if p.id = db.freelist.allocate(count); p.id != 0 { + return p, nil + } + + // Resize mmap() if we're at the end. + p.id = db.rwtx.meta.pgid + var minsz = int((p.id+pgid(count))+1) * db.pageSize + if minsz >= db.datasz { + if err := db.mmap(minsz); err != nil { + return nil, fmt.Errorf("mmap allocate error: %s", err) + } + } + + // Move the page id high water mark. + db.rwtx.meta.pgid += pgid(count) + + return p, nil +} + +// Options represents the options that can be set when opening a database. +type Options struct { + // Timeout is the amount of time to wait to obtain a file lock. + // When set to zero it will wait indefinitely. This option is only + // available on Darwin and Linux. + Timeout time.Duration +} + +// DefaultOptions represent the options used if nil options are passed into Open(). +// No timeout is used which will cause Bolt to wait indefinitely for a lock. +var DefaultOptions = &Options{ + Timeout: 0, +} + +// Stats represents statistics about the database. +type Stats struct { + // Freelist stats + FreePageN int // total number of free pages on the freelist + PendingPageN int // total number of pending pages on the freelist + FreeAlloc int // total bytes allocated in free pages + FreelistInuse int // total bytes used by the freelist + + // Transaction stats + TxN int // total number of started read transactions + OpenTxN int // number of currently open read transactions + + TxStats TxStats // global, ongoing stats. +} + +// Sub calculates and returns the difference between two sets of database stats. +// This is useful when obtaining stats at two different points and time and +// you need the performance counters that occurred within that time span. +func (s *Stats) Sub(other *Stats) Stats { + if other == nil { + return *s + } + var diff Stats + diff.FreePageN = s.FreePageN + diff.PendingPageN = s.PendingPageN + diff.FreeAlloc = s.FreeAlloc + diff.FreelistInuse = s.FreelistInuse + diff.TxN = other.TxN - s.TxN + diff.TxStats = s.TxStats.Sub(&other.TxStats) + return diff +} + +func (s *Stats) add(other *Stats) { + s.TxStats.add(&other.TxStats) +} + +type Info struct { + Data uintptr + PageSize int +} + +type meta struct { + magic uint32 + version uint32 + pageSize uint32 + flags uint32 + root bucket + freelist pgid + pgid pgid + txid txid + checksum uint64 +} + +// validate checks the marker bytes and version of the meta page to ensure it matches this binary. +func (m *meta) validate() error { + if m.checksum != 0 && m.checksum != m.sum64() { + return ErrChecksum + } else if m.magic != magic { + return ErrInvalid + } else if m.version != version { + return ErrVersionMismatch + } + return nil +} + +// copy copies one meta object to another. +func (m *meta) copy(dest *meta) { + *dest = *m +} + +// write writes the meta onto a page. +func (m *meta) write(p *page) { + if m.root.root >= m.pgid { + panic(fmt.Sprintf("root bucket pgid (%d) above high water mark (%d)", m.root.root, m.pgid)) + } else if m.freelist >= m.pgid { + panic(fmt.Sprintf("freelist pgid (%d) above high water mark (%d)", m.freelist, m.pgid)) + } + + // Page id is either going to be 0 or 1 which we can determine by the transaction ID. + p.id = pgid(m.txid % 2) + p.flags |= metaPageFlag + + // Calculate the checksum. + m.checksum = m.sum64() + + m.copy(p.meta()) +} + +// generates the checksum for the meta. +func (m *meta) sum64() uint64 { + var h = fnv.New64a() + _, _ = h.Write((*[unsafe.Offsetof(meta{}.checksum)]byte)(unsafe.Pointer(m))[:]) + return h.Sum64() +} + +// _assert will panic with a given formatted message if the given condition is false. +func _assert(condition bool, msg string, v ...interface{}) { + if !condition { + panic(fmt.Sprintf("assertion failed: "+msg, v...)) + } +} + +func warn(v ...interface{}) { fmt.Fprintln(os.Stderr, v...) } +func warnf(msg string, v ...interface{}) { fmt.Fprintf(os.Stderr, msg+"\n", v...) } + +func printstack() { + stack := strings.Join(strings.Split(string(debug.Stack()), "\n")[2:], "\n") + fmt.Fprintln(os.Stderr, stack) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/db_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/db_test.go new file mode 100644 index 000000000..08ca9fbab --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/db_test.go @@ -0,0 +1,790 @@ +package bolt_test + +import ( + "encoding/binary" + "errors" + "flag" + "fmt" + "io/ioutil" + "os" + "regexp" + "runtime" + "sort" + "strings" + "testing" + "time" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +var statsFlag = flag.Bool("stats", false, "show performance stats") + +// Ensure that opening a database with a bad path returns an error. +func TestOpen_BadPath(t *testing.T) { + db, err := bolt.Open("", 0666, nil) + assert(t, err != nil, "err: %s", err) + assert(t, db == nil, "") +} + +// Ensure that a database can be opened without error. +func TestOpen(t *testing.T) { + path := tempfile() + defer os.Remove(path) + db, err := bolt.Open(path, 0666, nil) + assert(t, db != nil, "") + ok(t, err) + equals(t, db.Path(), path) + ok(t, db.Close()) +} + +// Ensure that opening an already open database file will timeout. +func TestOpen_Timeout(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("timeout not supported on windows") + } + + path := tempfile() + defer os.Remove(path) + + // Open a data file. + db0, err := bolt.Open(path, 0666, nil) + assert(t, db0 != nil, "") + ok(t, err) + + // Attempt to open the database again. + start := time.Now() + db1, err := bolt.Open(path, 0666, &bolt.Options{Timeout: 100 * time.Millisecond}) + assert(t, db1 == nil, "") + equals(t, bolt.ErrTimeout, err) + assert(t, time.Since(start) > 100*time.Millisecond, "") + + db0.Close() +} + +// Ensure that opening an already open database file will wait until its closed. +func TestOpen_Wait(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("timeout not supported on windows") + } + + path := tempfile() + defer os.Remove(path) + + // Open a data file. + db0, err := bolt.Open(path, 0666, nil) + assert(t, db0 != nil, "") + ok(t, err) + + // Close it in just a bit. + time.AfterFunc(100*time.Millisecond, func() { db0.Close() }) + + // Attempt to open the database again. + start := time.Now() + db1, err := bolt.Open(path, 0666, &bolt.Options{Timeout: 200 * time.Millisecond}) + assert(t, db1 != nil, "") + ok(t, err) + assert(t, time.Since(start) > 100*time.Millisecond, "") +} + +// Ensure that opening a database does not increase its size. +// https://github.com/boltdb/bolt/issues/291 +func TestOpen_Size(t *testing.T) { + // Open a data file. + db := NewTestDB() + path := db.Path() + defer db.Close() + + // Insert until we get above the minimum 4MB size. + ok(t, db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists([]byte("data")) + for i := 0; i < 10000; i++ { + ok(t, b.Put([]byte(fmt.Sprintf("%04d", i)), make([]byte, 1000))) + } + return nil + })) + + // Close database and grab the size. + db.DB.Close() + sz := fileSize(path) + if sz == 0 { + t.Fatalf("unexpected new file size: %d", sz) + } + + // Reopen database, update, and check size again. + db0, err := bolt.Open(path, 0666, nil) + ok(t, err) + ok(t, db0.Update(func(tx *bolt.Tx) error { return tx.Bucket([]byte("data")).Put([]byte{0}, []byte{0}) })) + ok(t, db0.Close()) + newSz := fileSize(path) + if newSz == 0 { + t.Fatalf("unexpected new file size: %d", newSz) + } + + // Compare the original size with the new size. + if sz != newSz { + t.Fatalf("unexpected file growth: %d => %d", sz, newSz) + } +} + +// Ensure that opening a database beyond the max step size does not increase its size. +// https://github.com/boltdb/bolt/issues/303 +func TestOpen_Size_Large(t *testing.T) { + if testing.Short() { + t.Skip("short mode") + } + + // Open a data file. + db := NewTestDB() + path := db.Path() + defer db.Close() + + // Insert until we get above the minimum 4MB size. + var index uint64 + for i := 0; i < 10000; i++ { + ok(t, db.Update(func(tx *bolt.Tx) error { + b, _ := tx.CreateBucketIfNotExists([]byte("data")) + for j := 0; j < 1000; j++ { + ok(t, b.Put(u64tob(index), make([]byte, 50))) + index++ + } + return nil + })) + } + + // Close database and grab the size. + db.DB.Close() + sz := fileSize(path) + if sz == 0 { + t.Fatalf("unexpected new file size: %d", sz) + } else if sz < (1 << 30) { + t.Fatalf("expected larger initial size: %d", sz) + } + + // Reopen database, update, and check size again. + db0, err := bolt.Open(path, 0666, nil) + ok(t, err) + ok(t, db0.Update(func(tx *bolt.Tx) error { return tx.Bucket([]byte("data")).Put([]byte{0}, []byte{0}) })) + ok(t, db0.Close()) + newSz := fileSize(path) + if newSz == 0 { + t.Fatalf("unexpected new file size: %d", newSz) + } + + // Compare the original size with the new size. + if sz != newSz { + t.Fatalf("unexpected file growth: %d => %d", sz, newSz) + } +} + +// Ensure that a re-opened database is consistent. +func TestOpen_Check(t *testing.T) { + path := tempfile() + defer os.Remove(path) + + db, err := bolt.Open(path, 0666, nil) + ok(t, err) + ok(t, db.View(func(tx *bolt.Tx) error { return <-tx.Check() })) + db.Close() + + db, err = bolt.Open(path, 0666, nil) + ok(t, err) + ok(t, db.View(func(tx *bolt.Tx) error { return <-tx.Check() })) + db.Close() +} + +// Ensure that the database returns an error if the file handle cannot be open. +func TestDB_Open_FileError(t *testing.T) { + path := tempfile() + defer os.Remove(path) + + _, err := bolt.Open(path+"/youre-not-my-real-parent", 0666, nil) + assert(t, err.(*os.PathError) != nil, "") + equals(t, path+"/youre-not-my-real-parent", err.(*os.PathError).Path) + equals(t, "open", err.(*os.PathError).Op) +} + +// Ensure that write errors to the meta file handler during initialization are returned. +func TestDB_Open_MetaInitWriteError(t *testing.T) { + t.Skip("pending") +} + +// Ensure that a database that is too small returns an error. +func TestDB_Open_FileTooSmall(t *testing.T) { + path := tempfile() + defer os.Remove(path) + + db, err := bolt.Open(path, 0666, nil) + ok(t, err) + db.Close() + + // corrupt the database + ok(t, os.Truncate(path, int64(os.Getpagesize()))) + + db, err = bolt.Open(path, 0666, nil) + equals(t, errors.New("file size too small"), err) +} + +// TODO(benbjohnson): Test corruption at every byte of the first two pages. + +// Ensure that a database cannot open a transaction when it's not open. +func TestDB_Begin_DatabaseNotOpen(t *testing.T) { + var db bolt.DB + tx, err := db.Begin(false) + assert(t, tx == nil, "") + equals(t, err, bolt.ErrDatabaseNotOpen) +} + +// Ensure that a read-write transaction can be retrieved. +func TestDB_BeginRW(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, err := db.Begin(true) + assert(t, tx != nil, "") + ok(t, err) + assert(t, tx.DB() == db.DB, "") + equals(t, tx.Writable(), true) + ok(t, tx.Commit()) +} + +// Ensure that opening a transaction while the DB is closed returns an error. +func TestDB_BeginRW_Closed(t *testing.T) { + var db bolt.DB + tx, err := db.Begin(true) + equals(t, err, bolt.ErrDatabaseNotOpen) + assert(t, tx == nil, "") +} + +// Ensure a database can provide a transactional block. +func TestDB_Update(t *testing.T) { + db := NewTestDB() + defer db.Close() + err := db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + b.Put([]byte("foo"), []byte("bar")) + b.Put([]byte("baz"), []byte("bat")) + b.Delete([]byte("foo")) + return nil + }) + ok(t, err) + err = db.View(func(tx *bolt.Tx) error { + assert(t, tx.Bucket([]byte("widgets")).Get([]byte("foo")) == nil, "") + equals(t, []byte("bat"), tx.Bucket([]byte("widgets")).Get([]byte("baz"))) + return nil + }) + ok(t, err) +} + +// Ensure a closed database returns an error while running a transaction block +func TestDB_Update_Closed(t *testing.T) { + var db bolt.DB + err := db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + return nil + }) + equals(t, err, bolt.ErrDatabaseNotOpen) +} + +// Ensure a panic occurs while trying to commit a managed transaction. +func TestDB_Update_ManualCommit(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var ok bool + db.Update(func(tx *bolt.Tx) error { + func() { + defer func() { + if r := recover(); r != nil { + ok = true + } + }() + tx.Commit() + }() + return nil + }) + assert(t, ok, "expected panic") +} + +// Ensure a panic occurs while trying to rollback a managed transaction. +func TestDB_Update_ManualRollback(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var ok bool + db.Update(func(tx *bolt.Tx) error { + func() { + defer func() { + if r := recover(); r != nil { + ok = true + } + }() + tx.Rollback() + }() + return nil + }) + assert(t, ok, "expected panic") +} + +// Ensure a panic occurs while trying to commit a managed transaction. +func TestDB_View_ManualCommit(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var ok bool + db.Update(func(tx *bolt.Tx) error { + func() { + defer func() { + if r := recover(); r != nil { + ok = true + } + }() + tx.Commit() + }() + return nil + }) + assert(t, ok, "expected panic") +} + +// Ensure a panic occurs while trying to rollback a managed transaction. +func TestDB_View_ManualRollback(t *testing.T) { + db := NewTestDB() + defer db.Close() + + var ok bool + db.Update(func(tx *bolt.Tx) error { + func() { + defer func() { + if r := recover(); r != nil { + ok = true + } + }() + tx.Rollback() + }() + return nil + }) + assert(t, ok, "expected panic") +} + +// Ensure a write transaction that panics does not hold open locks. +func TestDB_Update_Panic(t *testing.T) { + db := NewTestDB() + defer db.Close() + + func() { + defer func() { + if r := recover(); r != nil { + t.Log("recover: update", r) + } + }() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + panic("omg") + }) + }() + + // Verify we can update again. + err := db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + ok(t, err) + + // Verify that our change persisted. + err = db.Update(func(tx *bolt.Tx) error { + assert(t, tx.Bucket([]byte("widgets")) != nil, "") + return nil + }) +} + +// Ensure a database can return an error through a read-only transactional block. +func TestDB_View_Error(t *testing.T) { + db := NewTestDB() + defer db.Close() + err := db.View(func(tx *bolt.Tx) error { + return errors.New("xxx") + }) + equals(t, errors.New("xxx"), err) +} + +// Ensure a read transaction that panics does not hold open locks. +func TestDB_View_Panic(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + return nil + }) + + func() { + defer func() { + if r := recover(); r != nil { + t.Log("recover: view", r) + } + }() + db.View(func(tx *bolt.Tx) error { + assert(t, tx.Bucket([]byte("widgets")) != nil, "") + panic("omg") + }) + }() + + // Verify that we can still use read transactions. + db.View(func(tx *bolt.Tx) error { + assert(t, tx.Bucket([]byte("widgets")) != nil, "") + return nil + }) +} + +// Ensure that an error is returned when a database write fails. +func TestDB_Commit_WriteFail(t *testing.T) { + t.Skip("pending") // TODO(benbjohnson) +} + +// Ensure that DB stats can be returned. +func TestDB_Stats(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + stats := db.Stats() + equals(t, 2, stats.TxStats.PageCount) + equals(t, 0, stats.FreePageN) + equals(t, 2, stats.PendingPageN) +} + +// Ensure that database pages are in expected order and type. +func TestDB_Consistency(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + + for i := 0; i < 10; i++ { + db.Update(func(tx *bolt.Tx) error { + ok(t, tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar"))) + return nil + }) + } + db.Update(func(tx *bolt.Tx) error { + p, _ := tx.Page(0) + assert(t, p != nil, "") + equals(t, "meta", p.Type) + + p, _ = tx.Page(1) + assert(t, p != nil, "") + equals(t, "meta", p.Type) + + p, _ = tx.Page(2) + assert(t, p != nil, "") + equals(t, "free", p.Type) + + p, _ = tx.Page(3) + assert(t, p != nil, "") + equals(t, "free", p.Type) + + p, _ = tx.Page(4) + assert(t, p != nil, "") + equals(t, "leaf", p.Type) + + p, _ = tx.Page(5) + assert(t, p != nil, "") + equals(t, "freelist", p.Type) + + p, _ = tx.Page(6) + assert(t, p == nil, "") + return nil + }) +} + +// Ensure that DB stats can be substracted from one another. +func TestDBStats_Sub(t *testing.T) { + var a, b bolt.Stats + a.TxStats.PageCount = 3 + a.FreePageN = 4 + b.TxStats.PageCount = 10 + b.FreePageN = 14 + diff := b.Sub(&a) + equals(t, 7, diff.TxStats.PageCount) + // free page stats are copied from the receiver and not subtracted + equals(t, 14, diff.FreePageN) +} + +func ExampleDB_Update() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Execute several commands within a write transaction. + err := db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + if err != nil { + return err + } + if err := b.Put([]byte("foo"), []byte("bar")); err != nil { + return err + } + return nil + }) + + // If our transactional block didn't return an error then our data is saved. + if err == nil { + db.View(func(tx *bolt.Tx) error { + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + fmt.Printf("The value of 'foo' is: %s\n", value) + return nil + }) + } + + // Output: + // The value of 'foo' is: bar +} + +func ExampleDB_View() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Insert data into a bucket. + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("people")) + b := tx.Bucket([]byte("people")) + b.Put([]byte("john"), []byte("doe")) + b.Put([]byte("susy"), []byte("que")) + return nil + }) + + // Access data from within a read-only transactional block. + db.View(func(tx *bolt.Tx) error { + v := tx.Bucket([]byte("people")).Get([]byte("john")) + fmt.Printf("John's last name is %s.\n", v) + return nil + }) + + // Output: + // John's last name is doe. +} + +func ExampleDB_Begin_ReadOnly() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Create a bucket. + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + + // Create several keys in a transaction. + tx, _ := db.Begin(true) + b := tx.Bucket([]byte("widgets")) + b.Put([]byte("john"), []byte("blue")) + b.Put([]byte("abby"), []byte("red")) + b.Put([]byte("zephyr"), []byte("purple")) + tx.Commit() + + // Iterate over the values in sorted key order. + tx, _ = db.Begin(false) + c := tx.Bucket([]byte("widgets")).Cursor() + for k, v := c.First(); k != nil; k, v = c.Next() { + fmt.Printf("%s likes %s\n", k, v) + } + tx.Rollback() + + // Output: + // abby likes red + // john likes blue + // zephyr likes purple +} + +// TestDB represents a wrapper around a Bolt DB to handle temporary file +// creation and automatic cleanup on close. +type TestDB struct { + *bolt.DB +} + +// NewTestDB returns a new instance of TestDB. +func NewTestDB() *TestDB { + db, err := bolt.Open(tempfile(), 0666, nil) + if err != nil { + panic("cannot open db: " + err.Error()) + } + return &TestDB{db} +} + +// MustView executes a read-only function. Panic on error. +func (db *TestDB) MustView(fn func(tx *bolt.Tx) error) { + if err := db.DB.View(func(tx *bolt.Tx) error { + return fn(tx) + }); err != nil { + panic(err.Error()) + } +} + +// MustUpdate executes a read-write function. Panic on error. +func (db *TestDB) MustUpdate(fn func(tx *bolt.Tx) error) { + if err := db.DB.View(func(tx *bolt.Tx) error { + return fn(tx) + }); err != nil { + panic(err.Error()) + } +} + +// MustCreateBucket creates a new bucket. Panic on error. +func (db *TestDB) MustCreateBucket(name []byte) { + if err := db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte(name)) + return err + }); err != nil { + panic(err.Error()) + } +} + +// Close closes the database and deletes the underlying file. +func (db *TestDB) Close() { + // Log statistics. + if *statsFlag { + db.PrintStats() + } + + // Check database consistency after every test. + db.MustCheck() + + // Close database and remove file. + defer os.Remove(db.Path()) + db.DB.Close() +} + +// PrintStats prints the database stats +func (db *TestDB) PrintStats() { + var stats = db.Stats() + fmt.Printf("[db] %-20s %-20s %-20s\n", + fmt.Sprintf("pg(%d/%d)", stats.TxStats.PageCount, stats.TxStats.PageAlloc), + fmt.Sprintf("cur(%d)", stats.TxStats.CursorCount), + fmt.Sprintf("node(%d/%d)", stats.TxStats.NodeCount, stats.TxStats.NodeDeref), + ) + fmt.Printf(" %-20s %-20s %-20s\n", + fmt.Sprintf("rebal(%d/%v)", stats.TxStats.Rebalance, truncDuration(stats.TxStats.RebalanceTime)), + fmt.Sprintf("spill(%d/%v)", stats.TxStats.Spill, truncDuration(stats.TxStats.SpillTime)), + fmt.Sprintf("w(%d/%v)", stats.TxStats.Write, truncDuration(stats.TxStats.WriteTime)), + ) +} + +// MustCheck runs a consistency check on the database and panics if any errors are found. +func (db *TestDB) MustCheck() { + db.View(func(tx *bolt.Tx) error { + // Collect all the errors. + var errors []error + for err := range tx.Check() { + errors = append(errors, err) + if len(errors) > 10 { + break + } + } + + // If errors occurred, copy the DB and print the errors. + if len(errors) > 0 { + var path = tempfile() + tx.CopyFile(path, 0600) + + // Print errors. + fmt.Print("\n\n") + fmt.Printf("consistency check failed (%d errors)\n", len(errors)) + for _, err := range errors { + fmt.Println(err) + } + fmt.Println("") + fmt.Println("db saved to:") + fmt.Println(path) + fmt.Print("\n\n") + os.Exit(-1) + } + + return nil + }) +} + +// CopyTempFile copies a database to a temporary file. +func (db *TestDB) CopyTempFile() { + path := tempfile() + db.View(func(tx *bolt.Tx) error { return tx.CopyFile(path, 0600) }) + fmt.Println("db copied to: ", path) +} + +// tempfile returns a temporary file path. +func tempfile() string { + f, _ := ioutil.TempFile("", "bolt-") + f.Close() + os.Remove(f.Name()) + return f.Name() +} + +// mustContainKeys checks that a bucket contains a given set of keys. +func mustContainKeys(b *bolt.Bucket, m map[string]string) { + found := make(map[string]string) + b.ForEach(func(k, _ []byte) error { + found[string(k)] = "" + return nil + }) + + // Check for keys found in bucket that shouldn't be there. + var keys []string + for k, _ := range found { + if _, ok := m[string(k)]; !ok { + keys = append(keys, k) + } + } + if len(keys) > 0 { + sort.Strings(keys) + panic(fmt.Sprintf("keys found(%d): %s", len(keys), strings.Join(keys, ","))) + } + + // Check for keys not found in bucket that should be there. + for k, _ := range m { + if _, ok := found[string(k)]; !ok { + keys = append(keys, k) + } + } + if len(keys) > 0 { + sort.Strings(keys) + panic(fmt.Sprintf("keys not found(%d): %s", len(keys), strings.Join(keys, ","))) + } +} + +func trunc(b []byte, length int) []byte { + if length < len(b) { + return b[:length] + } + return b +} + +func truncDuration(d time.Duration) string { + return regexp.MustCompile(`^(\d+)(\.\d+)`).ReplaceAllString(d.String(), "$1") +} + +func fileSize(path string) int64 { + fi, err := os.Stat(path) + if err != nil { + return 0 + } + return fi.Size() +} + +func warn(v ...interface{}) { fmt.Fprintln(os.Stderr, v...) } +func warnf(msg string, v ...interface{}) { fmt.Fprintf(os.Stderr, msg+"\n", v...) } + +// u64tob converts a uint64 into an 8-byte slice. +func u64tob(v uint64) []byte { + b := make([]byte, 8) + binary.BigEndian.PutUint64(b, v) + return b +} + +// btou64 converts an 8-byte slice into an uint64. +func btou64(b []byte) uint64 { return binary.BigEndian.Uint64(b) } diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/doc.go b/Godeps/_workspace/src/github.com/boltdb/bolt/doc.go new file mode 100644 index 000000000..cc937845d --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/doc.go @@ -0,0 +1,44 @@ +/* +Package bolt implements a low-level key/value store in pure Go. It supports +fully serializable transactions, ACID semantics, and lock-free MVCC with +multiple readers and a single writer. Bolt can be used for projects that +want a simple data store without the need to add large dependencies such as +Postgres or MySQL. + +Bolt is a single-level, zero-copy, B+tree data store. This means that Bolt is +optimized for fast read access and does not require recovery in the event of a +system crash. Transactions which have not finished committing will simply be +rolled back in the event of a crash. + +The design of Bolt is based on Howard Chu's LMDB database project. + +Bolt currently works on Windows, Mac OS X, and Linux. + + +Basics + +There are only a few types in Bolt: DB, Bucket, Tx, and Cursor. The DB is +a collection of buckets and is represented by a single file on disk. A bucket is +a collection of unique keys that are associated with values. + +Transactions provide either read-only or read-write access to the database. +Read-only transactions can retrieve key/value pairs and can use Cursors to +iterate over the dataset sequentially. Read-write transactions can create and +delete buckets and can insert and remove keys. Only one read-write transaction +is allowed at a time. + + +Caveats + +The database uses a read-only, memory-mapped data file to ensure that +applications cannot corrupt the database, however, this means that keys and +values returned from Bolt cannot be changed. Writing to a read-only byte slice +will cause Go to panic. + +Keys and values retrieved from the database are only valid for the life of +the transaction. When used outside the transaction, these byte slices can +point to different data or can point to invalid memory which will cause a panic. + + +*/ +package bolt diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/errors.go b/Godeps/_workspace/src/github.com/boltdb/bolt/errors.go new file mode 100644 index 000000000..aa504f138 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/errors.go @@ -0,0 +1,66 @@ +package bolt + +import "errors" + +// These errors can be returned when opening or calling methods on a DB. +var ( + // ErrDatabaseNotOpen is returned when a DB instance is accessed before it + // is opened or after it is closed. + ErrDatabaseNotOpen = errors.New("database not open") + + // ErrDatabaseOpen is returned when opening a database that is + // already open. + ErrDatabaseOpen = errors.New("database already open") + + // ErrInvalid is returned when a data file is not a Bolt-formatted database. + ErrInvalid = errors.New("invalid database") + + // ErrVersionMismatch is returned when the data file was created with a + // different version of Bolt. + ErrVersionMismatch = errors.New("version mismatch") + + // ErrChecksum is returned when either meta page checksum does not match. + ErrChecksum = errors.New("checksum error") + + // ErrTimeout is returned when a database cannot obtain an exclusive lock + // on the data file after the timeout passed to Open(). + ErrTimeout = errors.New("timeout") +) + +// These errors can occur when beginning or committing a Tx. +var ( + // ErrTxNotWritable is returned when performing a write operation on a + // read-only transaction. + ErrTxNotWritable = errors.New("tx not writable") + + // ErrTxClosed is returned when committing or rolling back a transaction + // that has already been committed or rolled back. + ErrTxClosed = errors.New("tx closed") +) + +// These errors can occur when putting or deleting a value or a bucket. +var ( + // ErrBucketNotFound is returned when trying to access a bucket that has + // not been created yet. + ErrBucketNotFound = errors.New("bucket not found") + + // ErrBucketExists is returned when creating a bucket that already exists. + ErrBucketExists = errors.New("bucket already exists") + + // ErrBucketNameRequired is returned when creating a bucket with a blank name. + ErrBucketNameRequired = errors.New("bucket name required") + + // ErrKeyRequired is returned when inserting a zero-length key. + ErrKeyRequired = errors.New("key required") + + // ErrKeyTooLarge is returned when inserting a key that is larger than MaxKeySize. + ErrKeyTooLarge = errors.New("key too large") + + // ErrValueTooLarge is returned when inserting a value that is larger than MaxValueSize. + ErrValueTooLarge = errors.New("value too large") + + // ErrIncompatibleValue is returned when trying create or delete a bucket + // on an existing non-bucket key or when trying to create or delete a + // non-bucket key on an existing bucket key. + ErrIncompatibleValue = errors.New("incompatible value") +) diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/freelist.go b/Godeps/_workspace/src/github.com/boltdb/bolt/freelist.go new file mode 100644 index 000000000..1346e82e5 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/freelist.go @@ -0,0 +1,241 @@ +package bolt + +import ( + "fmt" + "sort" + "unsafe" +) + +// freelist represents a list of all pages that are available for allocation. +// It also tracks pages that have been freed but are still in use by open transactions. +type freelist struct { + ids []pgid // all free and available free page ids. + pending map[txid][]pgid // mapping of soon-to-be free page ids by tx. + cache map[pgid]bool // fast lookup of all free and pending page ids. +} + +// newFreelist returns an empty, initialized freelist. +func newFreelist() *freelist { + return &freelist{ + pending: make(map[txid][]pgid), + cache: make(map[pgid]bool), + } +} + +// size returns the size of the page after serialization. +func (f *freelist) size() int { + return pageHeaderSize + (int(unsafe.Sizeof(pgid(0))) * f.count()) +} + +// count returns count of pages on the freelist +func (f *freelist) count() int { + return f.free_count() + f.pending_count() +} + +// free_count returns count of free pages +func (f *freelist) free_count() int { + return len(f.ids) +} + +// pending_count returns count of pending pages +func (f *freelist) pending_count() int { + var count int + for _, list := range f.pending { + count += len(list) + } + return count +} + +// all returns a list of all free ids and all pending ids in one sorted list. +func (f *freelist) all() []pgid { + ids := make([]pgid, len(f.ids)) + copy(ids, f.ids) + + for _, list := range f.pending { + ids = append(ids, list...) + } + + sort.Sort(pgids(ids)) + return ids +} + +// allocate returns the starting page id of a contiguous list of pages of a given size. +// If a contiguous block cannot be found then 0 is returned. +func (f *freelist) allocate(n int) pgid { + if len(f.ids) == 0 { + return 0 + } + + var initial, previd pgid + for i, id := range f.ids { + if id <= 1 { + panic(fmt.Sprintf("invalid page allocation: %d", id)) + } + + // Reset initial page if this is not contiguous. + if previd == 0 || id-previd != 1 { + initial = id + } + + // If we found a contiguous block then remove it and return it. + if (id-initial)+1 == pgid(n) { + // If we're allocating off the beginning then take the fast path + // and just adjust the existing slice. This will use extra memory + // temporarily but the append() in free() will realloc the slice + // as is necessary. + if (i + 1) == n { + f.ids = f.ids[i+1:] + } else { + copy(f.ids[i-n+1:], f.ids[i+1:]) + f.ids = f.ids[:len(f.ids)-n] + } + + // Remove from the free cache. + for i := pgid(0); i < pgid(n); i++ { + delete(f.cache, initial+i) + } + + return initial + } + + previd = id + } + return 0 +} + +// free releases a page and its overflow for a given transaction id. +// If the page is already free then a panic will occur. +func (f *freelist) free(txid txid, p *page) { + if p.id <= 1 { + panic(fmt.Sprintf("cannot free page 0 or 1: %d", p.id)) + } + + // Free page and all its overflow pages. + var ids = f.pending[txid] + for id := p.id; id <= p.id+pgid(p.overflow); id++ { + // Verify that page is not already free. + if f.cache[id] { + panic(fmt.Sprintf("page %d already freed", id)) + } + + // Add to the freelist and cache. + ids = append(ids, id) + f.cache[id] = true + } + f.pending[txid] = ids +} + +// release moves all page ids for a transaction id (or older) to the freelist. +func (f *freelist) release(txid txid) { + for tid, ids := range f.pending { + if tid <= txid { + // Move transaction's pending pages to the available freelist. + // Don't remove from the cache since the page is still free. + f.ids = append(f.ids, ids...) + delete(f.pending, tid) + } + } + sort.Sort(pgids(f.ids)) +} + +// rollback removes the pages from a given pending tx. +func (f *freelist) rollback(txid txid) { + // Remove page ids from cache. + for _, id := range f.pending[txid] { + delete(f.cache, id) + } + + // Remove pages from pending list. + delete(f.pending, txid) +} + +// freed returns whether a given page is in the free list. +func (f *freelist) freed(pgid pgid) bool { + return f.cache[pgid] +} + +// read initializes the freelist from a freelist page. +func (f *freelist) read(p *page) { + // If the page.count is at the max uint16 value (64k) then it's considered + // an overflow and the size of the freelist is stored as the first element. + idx, count := 0, int(p.count) + if count == 0xFFFF { + idx = 1 + count = int(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0]) + } + + // Copy the list of page ids from the freelist. + ids := ((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[idx:count] + f.ids = make([]pgid, len(ids)) + copy(f.ids, ids) + + // Make sure they're sorted. + sort.Sort(pgids(f.ids)) + + // Rebuild the page cache. + f.reindex() +} + +// write writes the page ids onto a freelist page. All free and pending ids are +// saved to disk since in the event of a program crash, all pending ids will +// become free. +func (f *freelist) write(p *page) error { + // Combine the old free pgids and pgids waiting on an open transaction. + ids := f.all() + + // Update the header flag. + p.flags |= freelistPageFlag + + // The page.count can only hold up to 64k elements so if we overflow that + // number then we handle it by putting the size in the first element. + if len(ids) < 0xFFFF { + p.count = uint16(len(ids)) + copy(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[:], ids) + } else { + p.count = 0xFFFF + ((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[0] = pgid(len(ids)) + copy(((*[maxAllocSize]pgid)(unsafe.Pointer(&p.ptr)))[1:], ids) + } + + return nil +} + +// reload reads the freelist from a page and filters out pending items. +func (f *freelist) reload(p *page) { + f.read(p) + + // Build a cache of only pending pages. + pcache := make(map[pgid]bool) + for _, pendingIDs := range f.pending { + for _, pendingID := range pendingIDs { + pcache[pendingID] = true + } + } + + // Check each page in the freelist and build a new available freelist + // with any pages not in the pending lists. + var a []pgid + for _, id := range f.ids { + if !pcache[id] { + a = append(a, id) + } + } + f.ids = a + + // Once the available list is rebuilt then rebuild the free cache so that + // it includes the available and pending free pages. + f.reindex() +} + +// reindex rebuilds the free cache based on available and pending free lists. +func (f *freelist) reindex() { + f.cache = make(map[pgid]bool) + for _, id := range f.ids { + f.cache[id] = true + } + for _, pendingIDs := range f.pending { + for _, pendingID := range pendingIDs { + f.cache[pendingID] = true + } + } +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/freelist_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/freelist_test.go new file mode 100644 index 000000000..792ca9222 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/freelist_test.go @@ -0,0 +1,129 @@ +package bolt + +import ( + "reflect" + "testing" + "unsafe" +) + +// Ensure that a page is added to a transaction's freelist. +func TestFreelist_free(t *testing.T) { + f := newFreelist() + f.free(100, &page{id: 12}) + if !reflect.DeepEqual([]pgid{12}, f.pending[100]) { + t.Fatalf("exp=%v; got=%v", []pgid{12}, f.pending[100]) + } +} + +// Ensure that a page and its overflow is added to a transaction's freelist. +func TestFreelist_free_overflow(t *testing.T) { + f := newFreelist() + f.free(100, &page{id: 12, overflow: 3}) + if exp := []pgid{12, 13, 14, 15}; !reflect.DeepEqual(exp, f.pending[100]) { + t.Fatalf("exp=%v; got=%v", exp, f.pending[100]) + } +} + +// Ensure that a transaction's free pages can be released. +func TestFreelist_release(t *testing.T) { + f := newFreelist() + f.free(100, &page{id: 12, overflow: 1}) + f.free(100, &page{id: 9}) + f.free(102, &page{id: 39}) + f.release(100) + f.release(101) + if exp := []pgid{9, 12, 13}; !reflect.DeepEqual(exp, f.ids) { + t.Fatalf("exp=%v; got=%v", exp, f.ids) + } + + f.release(102) + if exp := []pgid{9, 12, 13, 39}; !reflect.DeepEqual(exp, f.ids) { + t.Fatalf("exp=%v; got=%v", exp, f.ids) + } +} + +// Ensure that a freelist can find contiguous blocks of pages. +func TestFreelist_allocate(t *testing.T) { + f := &freelist{ids: []pgid{3, 4, 5, 6, 7, 9, 12, 13, 18}} + if id := int(f.allocate(3)); id != 3 { + t.Fatalf("exp=3; got=%v", id) + } + if id := int(f.allocate(1)); id != 6 { + t.Fatalf("exp=6; got=%v", id) + } + if id := int(f.allocate(3)); id != 0 { + t.Fatalf("exp=0; got=%v", id) + } + if id := int(f.allocate(2)); id != 12 { + t.Fatalf("exp=12; got=%v", id) + } + if id := int(f.allocate(1)); id != 7 { + t.Fatalf("exp=7; got=%v", id) + } + if id := int(f.allocate(0)); id != 0 { + t.Fatalf("exp=0; got=%v", id) + } + if id := int(f.allocate(0)); id != 0 { + t.Fatalf("exp=0; got=%v", id) + } + if exp := []pgid{9, 18}; !reflect.DeepEqual(exp, f.ids) { + t.Fatalf("exp=%v; got=%v", exp, f.ids) + } + + if id := int(f.allocate(1)); id != 9 { + t.Fatalf("exp=9; got=%v", id) + } + if id := int(f.allocate(1)); id != 18 { + t.Fatalf("exp=18; got=%v", id) + } + if id := int(f.allocate(1)); id != 0 { + t.Fatalf("exp=0; got=%v", id) + } + if exp := []pgid{}; !reflect.DeepEqual(exp, f.ids) { + t.Fatalf("exp=%v; got=%v", exp, f.ids) + } +} + +// Ensure that a freelist can deserialize from a freelist page. +func TestFreelist_read(t *testing.T) { + // Create a page. + var buf [4096]byte + page := (*page)(unsafe.Pointer(&buf[0])) + page.flags = freelistPageFlag + page.count = 2 + + // Insert 2 page ids. + ids := (*[3]pgid)(unsafe.Pointer(&page.ptr)) + ids[0] = 23 + ids[1] = 50 + + // Deserialize page into a freelist. + f := newFreelist() + f.read(page) + + // Ensure that there are two page ids in the freelist. + if exp := []pgid{23, 50}; !reflect.DeepEqual(exp, f.ids) { + t.Fatalf("exp=%v; got=%v", exp, f.ids) + } +} + +// Ensure that a freelist can serialize into a freelist page. +func TestFreelist_write(t *testing.T) { + // Create a freelist and write it to a page. + var buf [4096]byte + f := &freelist{ids: []pgid{12, 39}, pending: make(map[txid][]pgid)} + f.pending[100] = []pgid{28, 11} + f.pending[101] = []pgid{3} + p := (*page)(unsafe.Pointer(&buf[0])) + f.write(p) + + // Read the page back out. + f2 := newFreelist() + f2.read(p) + + // Ensure that the freelist is correct. + // All pages should be present and in reverse order. + if exp := []pgid{3, 11, 12, 28, 39}; !reflect.DeepEqual(exp, f2.ids) { + t.Fatalf("exp=%v; got=%v", exp, f2.ids) + } +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/node.go b/Godeps/_workspace/src/github.com/boltdb/bolt/node.go new file mode 100644 index 000000000..05aefb8ad --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/node.go @@ -0,0 +1,627 @@ +package bolt + +import ( + "bytes" + "fmt" + "sort" + "unsafe" +) + +// node represents an in-memory, deserialized page. +type node struct { + bucket *Bucket + isLeaf bool + unbalanced bool + spilled bool + key []byte + pgid pgid + parent *node + children nodes + inodes inodes +} + +// root returns the top-level node this node is attached to. +func (n *node) root() *node { + if n.parent == nil { + return n + } + return n.parent.root() +} + +// minKeys returns the minimum number of inodes this node should have. +func (n *node) minKeys() int { + if n.isLeaf { + return 1 + } + return 2 +} + +// size returns the size of the node after serialization. +func (n *node) size() int { + sz, elsz := pageHeaderSize, n.pageElementSize() + for i := 0; i < len(n.inodes); i++ { + item := &n.inodes[i] + sz += elsz + len(item.key) + len(item.value) + } + return sz +} + +// sizeLessThan returns true if the node is less than a given size. +// This is an optimization to avoid calculating a large node when we only need +// to know if it fits inside a certain page size. +func (n *node) sizeLessThan(v int) bool { + sz, elsz := pageHeaderSize, n.pageElementSize() + for i := 0; i < len(n.inodes); i++ { + item := &n.inodes[i] + sz += elsz + len(item.key) + len(item.value) + if sz >= v { + return false + } + } + return true +} + +// pageElementSize returns the size of each page element based on the type of node. +func (n *node) pageElementSize() int { + if n.isLeaf { + return leafPageElementSize + } + return branchPageElementSize +} + +// childAt returns the child node at a given index. +func (n *node) childAt(index int) *node { + if n.isLeaf { + panic(fmt.Sprintf("invalid childAt(%d) on a leaf node", index)) + } + return n.bucket.node(n.inodes[index].pgid, n) +} + +// childIndex returns the index of a given child node. +func (n *node) childIndex(child *node) int { + index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, child.key) != -1 }) + return index +} + +// numChildren returns the number of children. +func (n *node) numChildren() int { + return len(n.inodes) +} + +// nextSibling returns the next node with the same parent. +func (n *node) nextSibling() *node { + if n.parent == nil { + return nil + } + index := n.parent.childIndex(n) + if index >= n.parent.numChildren()-1 { + return nil + } + return n.parent.childAt(index + 1) +} + +// prevSibling returns the previous node with the same parent. +func (n *node) prevSibling() *node { + if n.parent == nil { + return nil + } + index := n.parent.childIndex(n) + if index == 0 { + return nil + } + return n.parent.childAt(index - 1) +} + +// put inserts a key/value. +func (n *node) put(oldKey, newKey, value []byte, pgid pgid, flags uint32) { + if pgid >= n.bucket.tx.meta.pgid { + panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", pgid, n.bucket.tx.meta.pgid)) + } else if len(oldKey) <= 0 { + panic("put: zero-length old key") + } else if len(newKey) <= 0 { + panic("put: zero-length new key") + } + + // Find insertion index. + index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, oldKey) != -1 }) + + // Add capacity and shift nodes if we don't have an exact match and need to insert. + exact := (len(n.inodes) > 0 && index < len(n.inodes) && bytes.Equal(n.inodes[index].key, oldKey)) + if !exact { + n.inodes = append(n.inodes, inode{}) + copy(n.inodes[index+1:], n.inodes[index:]) + } + + inode := &n.inodes[index] + inode.flags = flags + inode.key = newKey + inode.value = value + inode.pgid = pgid + _assert(len(inode.key) > 0, "put: zero-length inode key") +} + +// del removes a key from the node. +func (n *node) del(key []byte) { + // Find index of key. + index := sort.Search(len(n.inodes), func(i int) bool { return bytes.Compare(n.inodes[i].key, key) != -1 }) + + // Exit if the key isn't found. + if index >= len(n.inodes) || !bytes.Equal(n.inodes[index].key, key) { + return + } + + // Delete inode from the node. + n.inodes = append(n.inodes[:index], n.inodes[index+1:]...) + + // Mark the node as needing rebalancing. + n.unbalanced = true +} + +// read initializes the node from a page. +func (n *node) read(p *page) { + n.pgid = p.id + n.isLeaf = ((p.flags & leafPageFlag) != 0) + n.inodes = make(inodes, int(p.count)) + + for i := 0; i < int(p.count); i++ { + inode := &n.inodes[i] + if n.isLeaf { + elem := p.leafPageElement(uint16(i)) + inode.flags = elem.flags + inode.key = elem.key() + inode.value = elem.value() + } else { + elem := p.branchPageElement(uint16(i)) + inode.pgid = elem.pgid + inode.key = elem.key() + } + _assert(len(inode.key) > 0, "read: zero-length inode key") + } + + // Save first key so we can find the node in the parent when we spill. + if len(n.inodes) > 0 { + n.key = n.inodes[0].key + _assert(len(n.key) > 0, "read: zero-length node key") + } else { + n.key = nil + } +} + +// write writes the items onto one or more pages. +func (n *node) write(p *page) { + // Initialize page. + if n.isLeaf { + p.flags |= leafPageFlag + } else { + p.flags |= branchPageFlag + } + + if len(n.inodes) >= 0xFFFF { + panic(fmt.Sprintf("inode overflow: %d (pgid=%d)", len(n.inodes), p.id)) + } + p.count = uint16(len(n.inodes)) + + // Loop over each item and write it to the page. + b := (*[maxAllocSize]byte)(unsafe.Pointer(&p.ptr))[n.pageElementSize()*len(n.inodes):] + for i, item := range n.inodes { + _assert(len(item.key) > 0, "write: zero-length inode key") + + // Write the page element. + if n.isLeaf { + elem := p.leafPageElement(uint16(i)) + elem.pos = uint32(uintptr(unsafe.Pointer(&b[0])) - uintptr(unsafe.Pointer(elem))) + elem.flags = item.flags + elem.ksize = uint32(len(item.key)) + elem.vsize = uint32(len(item.value)) + } else { + elem := p.branchPageElement(uint16(i)) + elem.pos = uint32(uintptr(unsafe.Pointer(&b[0])) - uintptr(unsafe.Pointer(elem))) + elem.ksize = uint32(len(item.key)) + elem.pgid = item.pgid + _assert(elem.pgid != p.id, "write: circular dependency occurred") + } + + // Write data for the element to the end of the page. + copy(b[0:], item.key) + b = b[len(item.key):] + copy(b[0:], item.value) + b = b[len(item.value):] + } + + // DEBUG ONLY: n.dump() +} + +// split breaks up a node into multiple smaller nodes, if appropriate. +// This should only be called from the spill() function. +func (n *node) split(pageSize int) []*node { + var nodes []*node + + node := n + for { + // Split node into two. + a, b := node.splitTwo(pageSize) + nodes = append(nodes, a) + + // If we can't split then exit the loop. + if b == nil { + break + } + + // Set node to b so it gets split on the next iteration. + node = b + } + + return nodes +} + +// splitTwo breaks up a node into two smaller nodes, if appropriate. +// This should only be called from the split() function. +func (n *node) splitTwo(pageSize int) (*node, *node) { + // Ignore the split if the page doesn't have at least enough nodes for + // two pages or if the nodes can fit in a single page. + if len(n.inodes) <= (minKeysPerPage*2) || n.sizeLessThan(pageSize) { + return n, nil + } + + // Determine the threshold before starting a new node. + var fillPercent = n.bucket.FillPercent + if fillPercent < minFillPercent { + fillPercent = minFillPercent + } else if fillPercent > maxFillPercent { + fillPercent = maxFillPercent + } + threshold := int(float64(pageSize) * fillPercent) + + // Determine split position and sizes of the two pages. + splitIndex, _ := n.splitIndex(threshold) + + // Split node into two separate nodes. + // If there's no parent then we'll need to create one. + if n.parent == nil { + n.parent = &node{bucket: n.bucket, children: []*node{n}} + } + + // Create a new node and add it to the parent. + next := &node{bucket: n.bucket, isLeaf: n.isLeaf, parent: n.parent} + n.parent.children = append(n.parent.children, next) + + // Split inodes across two nodes. + next.inodes = n.inodes[splitIndex:] + n.inodes = n.inodes[:splitIndex] + + // Update the statistics. + n.bucket.tx.stats.Split++ + + return n, next +} + +// splitIndex finds the position where a page will fill a given threshold. +// It returns the index as well as the size of the first page. +// This is only be called from split(). +func (n *node) splitIndex(threshold int) (index, sz int) { + sz = pageHeaderSize + + // Loop until we only have the minimum number of keys required for the second page. + for i := 0; i < len(n.inodes)-minKeysPerPage; i++ { + index = i + inode := n.inodes[i] + elsize := n.pageElementSize() + len(inode.key) + len(inode.value) + + // If we have at least the minimum number of keys and adding another + // node would put us over the threshold then exit and return. + if i >= minKeysPerPage && sz+elsize > threshold { + break + } + + // Add the element size to the total size. + sz += elsize + } + + return +} + +// spill writes the nodes to dirty pages and splits nodes as it goes. +// Returns an error if dirty pages cannot be allocated. +func (n *node) spill() error { + var tx = n.bucket.tx + if n.spilled { + return nil + } + + // Spill child nodes first. Child nodes can materialize sibling nodes in + // the case of split-merge so we cannot use a range loop. We have to check + // the children size on every loop iteration. + sort.Sort(n.children) + for i := 0; i < len(n.children); i++ { + if err := n.children[i].spill(); err != nil { + return err + } + } + + // We no longer need the child list because it's only used for spill tracking. + n.children = nil + + // Split nodes into appropriate sizes. The first node will always be n. + var nodes = n.split(tx.db.pageSize) + for _, node := range nodes { + // Add node's page to the freelist if it's not new. + if node.pgid > 0 { + tx.db.freelist.free(tx.meta.txid, tx.page(node.pgid)) + node.pgid = 0 + } + + // Allocate contiguous space for the node. + p, err := tx.allocate((node.size() / tx.db.pageSize) + 1) + if err != nil { + return err + } + + // Write the node. + if p.id >= tx.meta.pgid { + panic(fmt.Sprintf("pgid (%d) above high water mark (%d)", p.id, tx.meta.pgid)) + } + node.pgid = p.id + node.write(p) + node.spilled = true + + // Insert into parent inodes. + if node.parent != nil { + var key = node.key + if key == nil { + key = node.inodes[0].key + } + + node.parent.put(key, node.inodes[0].key, nil, node.pgid, 0) + node.key = node.inodes[0].key + _assert(len(node.key) > 0, "spill: zero-length node key") + } + + // Update the statistics. + tx.stats.Spill++ + } + + // If the root node split and created a new root then we need to spill that + // as well. We'll clear out the children to make sure it doesn't try to respill. + if n.parent != nil && n.parent.pgid == 0 { + n.children = nil + return n.parent.spill() + } + + return nil +} + +// rebalance attempts to combine the node with sibling nodes if the node fill +// size is below a threshold or if there are not enough keys. +func (n *node) rebalance() { + if !n.unbalanced { + return + } + n.unbalanced = false + + // Update statistics. + n.bucket.tx.stats.Rebalance++ + + // Ignore if node is above threshold (25%) and has enough keys. + var threshold = n.bucket.tx.db.pageSize / 4 + if n.size() > threshold && len(n.inodes) > n.minKeys() { + return + } + + // Root node has special handling. + if n.parent == nil { + // If root node is a branch and only has one node then collapse it. + if !n.isLeaf && len(n.inodes) == 1 { + // Move root's child up. + child := n.bucket.node(n.inodes[0].pgid, n) + n.isLeaf = child.isLeaf + n.inodes = child.inodes[:] + n.children = child.children + + // Reparent all child nodes being moved. + for _, inode := range n.inodes { + if child, ok := n.bucket.nodes[inode.pgid]; ok { + child.parent = n + } + } + + // Remove old child. + child.parent = nil + delete(n.bucket.nodes, child.pgid) + child.free() + } + + return + } + + // If node has no keys then just remove it. + if n.numChildren() == 0 { + n.parent.del(n.key) + n.parent.removeChild(n) + delete(n.bucket.nodes, n.pgid) + n.free() + n.parent.rebalance() + return + } + + _assert(n.parent.numChildren() > 1, "parent must have at least 2 children") + + // Destination node is right sibling if idx == 0, otherwise left sibling. + var target *node + var useNextSibling = (n.parent.childIndex(n) == 0) + if useNextSibling { + target = n.nextSibling() + } else { + target = n.prevSibling() + } + + // If target node has extra nodes then just move one over. + if target.numChildren() > target.minKeys() { + if useNextSibling { + // Reparent and move node. + if child, ok := n.bucket.nodes[target.inodes[0].pgid]; ok { + child.parent.removeChild(child) + child.parent = n + child.parent.children = append(child.parent.children, child) + } + n.inodes = append(n.inodes, target.inodes[0]) + target.inodes = target.inodes[1:] + + // Update target key on parent. + target.parent.put(target.key, target.inodes[0].key, nil, target.pgid, 0) + target.key = target.inodes[0].key + _assert(len(target.key) > 0, "rebalance(1): zero-length node key") + } else { + // Reparent and move node. + if child, ok := n.bucket.nodes[target.inodes[len(target.inodes)-1].pgid]; ok { + child.parent.removeChild(child) + child.parent = n + child.parent.children = append(child.parent.children, child) + } + n.inodes = append(n.inodes, inode{}) + copy(n.inodes[1:], n.inodes) + n.inodes[0] = target.inodes[len(target.inodes)-1] + target.inodes = target.inodes[:len(target.inodes)-1] + } + + // Update parent key for node. + n.parent.put(n.key, n.inodes[0].key, nil, n.pgid, 0) + n.key = n.inodes[0].key + _assert(len(n.key) > 0, "rebalance(2): zero-length node key") + + return + } + + // If both this node and the target node are too small then merge them. + if useNextSibling { + // Reparent all child nodes being moved. + for _, inode := range target.inodes { + if child, ok := n.bucket.nodes[inode.pgid]; ok { + child.parent.removeChild(child) + child.parent = n + child.parent.children = append(child.parent.children, child) + } + } + + // Copy over inodes from target and remove target. + n.inodes = append(n.inodes, target.inodes...) + n.parent.del(target.key) + n.parent.removeChild(target) + delete(n.bucket.nodes, target.pgid) + target.free() + } else { + // Reparent all child nodes being moved. + for _, inode := range n.inodes { + if child, ok := n.bucket.nodes[inode.pgid]; ok { + child.parent.removeChild(child) + child.parent = target + child.parent.children = append(child.parent.children, child) + } + } + + // Copy over inodes to target and remove node. + target.inodes = append(target.inodes, n.inodes...) + n.parent.del(n.key) + n.parent.removeChild(n) + delete(n.bucket.nodes, n.pgid) + n.free() + } + + // Either this node or the target node was deleted from the parent so rebalance it. + n.parent.rebalance() +} + +// removes a node from the list of in-memory children. +// This does not affect the inodes. +func (n *node) removeChild(target *node) { + for i, child := range n.children { + if child == target { + n.children = append(n.children[:i], n.children[i+1:]...) + return + } + } +} + +// dereference causes the node to copy all its inode key/value references to heap memory. +// This is required when the mmap is reallocated so inodes are not pointing to stale data. +func (n *node) dereference() { + if n.key != nil { + key := make([]byte, len(n.key)) + copy(key, n.key) + n.key = key + _assert(n.pgid == 0 || len(n.key) > 0, "dereference: zero-length node key on existing node") + } + + for i := range n.inodes { + inode := &n.inodes[i] + + key := make([]byte, len(inode.key)) + copy(key, inode.key) + inode.key = key + _assert(len(inode.key) > 0, "dereference: zero-length inode key") + + value := make([]byte, len(inode.value)) + copy(value, inode.value) + inode.value = value + } + + // Recursively dereference children. + for _, child := range n.children { + child.dereference() + } + + // Update statistics. + n.bucket.tx.stats.NodeDeref++ +} + +// free adds the node's underlying page to the freelist. +func (n *node) free() { + if n.pgid != 0 { + n.bucket.tx.db.freelist.free(n.bucket.tx.meta.txid, n.bucket.tx.page(n.pgid)) + n.pgid = 0 + } +} + +// dump writes the contents of the node to STDERR for debugging purposes. +/* +func (n *node) dump() { + // Write node header. + var typ = "branch" + if n.isLeaf { + typ = "leaf" + } + warnf("[NODE %d {type=%s count=%d}]", n.pgid, typ, len(n.inodes)) + + // Write out abbreviated version of each item. + for _, item := range n.inodes { + if n.isLeaf { + if item.flags&bucketLeafFlag != 0 { + bucket := (*bucket)(unsafe.Pointer(&item.value[0])) + warnf("+L %08x -> (bucket root=%d)", trunc(item.key, 4), bucket.root) + } else { + warnf("+L %08x -> %08x", trunc(item.key, 4), trunc(item.value, 4)) + } + } else { + warnf("+B %08x -> pgid=%d", trunc(item.key, 4), item.pgid) + } + } + warn("") +} +*/ + +type nodes []*node + +func (s nodes) Len() int { return len(s) } +func (s nodes) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s nodes) Less(i, j int) bool { return bytes.Compare(s[i].inodes[0].key, s[j].inodes[0].key) == -1 } + +// inode represents an internal node inside of a node. +// It can be used to point to elements in a page or point +// to an element which hasn't been added to a page yet. +type inode struct { + flags uint32 + pgid pgid + key []byte + value []byte +} + +type inodes []inode diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/node_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/node_test.go new file mode 100644 index 000000000..fa5d10f99 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/node_test.go @@ -0,0 +1,156 @@ +package bolt + +import ( + "testing" + "unsafe" +) + +// Ensure that a node can insert a key/value. +func TestNode_put(t *testing.T) { + n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{meta: &meta{pgid: 1}}}} + n.put([]byte("baz"), []byte("baz"), []byte("2"), 0, 0) + n.put([]byte("foo"), []byte("foo"), []byte("0"), 0, 0) + n.put([]byte("bar"), []byte("bar"), []byte("1"), 0, 0) + n.put([]byte("foo"), []byte("foo"), []byte("3"), 0, leafPageFlag) + + if len(n.inodes) != 3 { + t.Fatalf("exp=3; got=%d", len(n.inodes)) + } + if k, v := n.inodes[0].key, n.inodes[0].value; string(k) != "bar" || string(v) != "1" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } + if k, v := n.inodes[1].key, n.inodes[1].value; string(k) != "baz" || string(v) != "2" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } + if k, v := n.inodes[2].key, n.inodes[2].value; string(k) != "foo" || string(v) != "3" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } + if n.inodes[2].flags != uint32(leafPageFlag) { + t.Fatalf("not a leaf: %d", n.inodes[2].flags) + } +} + +// Ensure that a node can deserialize from a leaf page. +func TestNode_read_LeafPage(t *testing.T) { + // Create a page. + var buf [4096]byte + page := (*page)(unsafe.Pointer(&buf[0])) + page.flags = leafPageFlag + page.count = 2 + + // Insert 2 elements at the beginning. sizeof(leafPageElement) == 16 + nodes := (*[3]leafPageElement)(unsafe.Pointer(&page.ptr)) + nodes[0] = leafPageElement{flags: 0, pos: 32, ksize: 3, vsize: 4} // pos = sizeof(leafPageElement) * 2 + nodes[1] = leafPageElement{flags: 0, pos: 23, ksize: 10, vsize: 3} // pos = sizeof(leafPageElement) + 3 + 4 + + // Write data for the nodes at the end. + data := (*[4096]byte)(unsafe.Pointer(&nodes[2])) + copy(data[:], []byte("barfooz")) + copy(data[7:], []byte("helloworldbye")) + + // Deserialize page into a leaf. + n := &node{} + n.read(page) + + // Check that there are two inodes with correct data. + if !n.isLeaf { + t.Fatal("expected leaf") + } + if len(n.inodes) != 2 { + t.Fatalf("exp=2; got=%d", len(n.inodes)) + } + if k, v := n.inodes[0].key, n.inodes[0].value; string(k) != "bar" || string(v) != "fooz" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } + if k, v := n.inodes[1].key, n.inodes[1].value; string(k) != "helloworld" || string(v) != "bye" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } +} + +// Ensure that a node can serialize into a leaf page. +func TestNode_write_LeafPage(t *testing.T) { + // Create a node. + n := &node{isLeaf: true, inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}} + n.put([]byte("susy"), []byte("susy"), []byte("que"), 0, 0) + n.put([]byte("ricki"), []byte("ricki"), []byte("lake"), 0, 0) + n.put([]byte("john"), []byte("john"), []byte("johnson"), 0, 0) + + // Write it to a page. + var buf [4096]byte + p := (*page)(unsafe.Pointer(&buf[0])) + n.write(p) + + // Read the page back in. + n2 := &node{} + n2.read(p) + + // Check that the two pages are the same. + if len(n2.inodes) != 3 { + t.Fatalf("exp=3; got=%d", len(n2.inodes)) + } + if k, v := n2.inodes[0].key, n2.inodes[0].value; string(k) != "john" || string(v) != "johnson" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } + if k, v := n2.inodes[1].key, n2.inodes[1].value; string(k) != "ricki" || string(v) != "lake" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } + if k, v := n2.inodes[2].key, n2.inodes[2].value; string(k) != "susy" || string(v) != "que" { + t.Fatalf("exp=; got=<%s,%s>", k, v) + } +} + +// Ensure that a node can split into appropriate subgroups. +func TestNode_split(t *testing.T) { + // Create a node. + n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}} + n.put([]byte("00000001"), []byte("00000001"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000002"), []byte("00000002"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000003"), []byte("00000003"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000004"), []byte("00000004"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000005"), []byte("00000005"), []byte("0123456701234567"), 0, 0) + + // Split between 2 & 3. + n.split(100) + + var parent = n.parent + if len(parent.children) != 2 { + t.Fatalf("exp=2; got=%d", len(parent.children)) + } + if len(parent.children[0].inodes) != 2 { + t.Fatalf("exp=2; got=%d", len(parent.children[0].inodes)) + } + if len(parent.children[1].inodes) != 3 { + t.Fatalf("exp=3; got=%d", len(parent.children[1].inodes)) + } +} + +// Ensure that a page with the minimum number of inodes just returns a single node. +func TestNode_split_MinKeys(t *testing.T) { + // Create a node. + n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}} + n.put([]byte("00000001"), []byte("00000001"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000002"), []byte("00000002"), []byte("0123456701234567"), 0, 0) + + // Split. + n.split(20) + if n.parent != nil { + t.Fatalf("expected nil parent") + } +} + +// Ensure that a node that has keys that all fit on a page just returns one leaf. +func TestNode_split_SinglePage(t *testing.T) { + // Create a node. + n := &node{inodes: make(inodes, 0), bucket: &Bucket{tx: &Tx{db: &DB{}, meta: &meta{pgid: 1}}}} + n.put([]byte("00000001"), []byte("00000001"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000002"), []byte("00000002"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000003"), []byte("00000003"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000004"), []byte("00000004"), []byte("0123456701234567"), 0, 0) + n.put([]byte("00000005"), []byte("00000005"), []byte("0123456701234567"), 0, 0) + + // Split. + n.split(4096) + if n.parent != nil { + t.Fatalf("expected nil parent") + } +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/page.go b/Godeps/_workspace/src/github.com/boltdb/bolt/page.go new file mode 100644 index 000000000..58e43c4b6 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/page.go @@ -0,0 +1,134 @@ +package bolt + +import ( + "fmt" + "os" + "unsafe" +) + +const pageHeaderSize = int(unsafe.Offsetof(((*page)(nil)).ptr)) + +const minKeysPerPage = 2 + +const branchPageElementSize = int(unsafe.Sizeof(branchPageElement{})) +const leafPageElementSize = int(unsafe.Sizeof(leafPageElement{})) + +const ( + branchPageFlag = 0x01 + leafPageFlag = 0x02 + metaPageFlag = 0x04 + freelistPageFlag = 0x10 +) + +const ( + bucketLeafFlag = 0x01 +) + +type pgid uint64 + +type page struct { + id pgid + flags uint16 + count uint16 + overflow uint32 + ptr uintptr +} + +// typ returns a human readable page type string used for debugging. +func (p *page) typ() string { + if (p.flags & branchPageFlag) != 0 { + return "branch" + } else if (p.flags & leafPageFlag) != 0 { + return "leaf" + } else if (p.flags & metaPageFlag) != 0 { + return "meta" + } else if (p.flags & freelistPageFlag) != 0 { + return "freelist" + } + return fmt.Sprintf("unknown<%02x>", p.flags) +} + +// meta returns a pointer to the metadata section of the page. +func (p *page) meta() *meta { + return (*meta)(unsafe.Pointer(&p.ptr)) +} + +// leafPageElement retrieves the leaf node by index +func (p *page) leafPageElement(index uint16) *leafPageElement { + n := &((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[index] + return n +} + +// leafPageElements retrieves a list of leaf nodes. +func (p *page) leafPageElements() []leafPageElement { + return ((*[0x7FFFFFF]leafPageElement)(unsafe.Pointer(&p.ptr)))[:] +} + +// branchPageElement retrieves the branch node by index +func (p *page) branchPageElement(index uint16) *branchPageElement { + return &((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[index] +} + +// branchPageElements retrieves a list of branch nodes. +func (p *page) branchPageElements() []branchPageElement { + return ((*[0x7FFFFFF]branchPageElement)(unsafe.Pointer(&p.ptr)))[:] +} + +// dump writes n bytes of the page to STDERR as hex output. +func (p *page) hexdump(n int) { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(p))[:n] + fmt.Fprintf(os.Stderr, "%x\n", buf) +} + +type pages []*page + +func (s pages) Len() int { return len(s) } +func (s pages) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s pages) Less(i, j int) bool { return s[i].id < s[j].id } + +// branchPageElement represents a node on a branch page. +type branchPageElement struct { + pos uint32 + ksize uint32 + pgid pgid +} + +// key returns a byte slice of the node key. +func (n *branchPageElement) key() []byte { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(n)) + return buf[n.pos : n.pos+n.ksize] +} + +// leafPageElement represents a node on a leaf page. +type leafPageElement struct { + flags uint32 + pos uint32 + ksize uint32 + vsize uint32 +} + +// key returns a byte slice of the node key. +func (n *leafPageElement) key() []byte { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(n)) + return buf[n.pos : n.pos+n.ksize] +} + +// value returns a byte slice of the node value. +func (n *leafPageElement) value() []byte { + buf := (*[maxAllocSize]byte)(unsafe.Pointer(n)) + return buf[n.pos+n.ksize : n.pos+n.ksize+n.vsize] +} + +// PageInfo represents human readable information about a page. +type PageInfo struct { + ID int + Type string + Count int + OverflowCount int +} + +type pgids []pgid + +func (s pgids) Len() int { return len(s) } +func (s pgids) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s pgids) Less(i, j int) bool { return s[i] < s[j] } diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/page_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/page_test.go new file mode 100644 index 000000000..7a4d327fe --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/page_test.go @@ -0,0 +1,29 @@ +package bolt + +import ( + "testing" +) + +// Ensure that the page type can be returned in human readable format. +func TestPage_typ(t *testing.T) { + if typ := (&page{flags: branchPageFlag}).typ(); typ != "branch" { + t.Fatalf("exp=branch; got=%v", typ) + } + if typ := (&page{flags: leafPageFlag}).typ(); typ != "leaf" { + t.Fatalf("exp=leaf; got=%v", typ) + } + if typ := (&page{flags: metaPageFlag}).typ(); typ != "meta" { + t.Fatalf("exp=meta; got=%v", typ) + } + if typ := (&page{flags: freelistPageFlag}).typ(); typ != "freelist" { + t.Fatalf("exp=freelist; got=%v", typ) + } + if typ := (&page{flags: 20000}).typ(); typ != "unknown<4e20>" { + t.Fatalf("exp=unknown<4e20>; got=%v", typ) + } +} + +// Ensure that the hexdump debugging function doesn't blow up. +func TestPage_dump(t *testing.T) { + (&page{id: 256}).hexdump(16) +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/quick_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/quick_test.go new file mode 100644 index 000000000..4da581775 --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/quick_test.go @@ -0,0 +1,79 @@ +package bolt_test + +import ( + "bytes" + "flag" + "fmt" + "math/rand" + "os" + "reflect" + "testing/quick" + "time" +) + +// testing/quick defaults to 5 iterations and a random seed. +// You can override these settings from the command line: +// +// -quick.count The number of iterations to perform. +// -quick.seed The seed to use for randomizing. +// -quick.maxitems The maximum number of items to insert into a DB. +// -quick.maxksize The maximum size of a key. +// -quick.maxvsize The maximum size of a value. +// + +var qcount, qseed, qmaxitems, qmaxksize, qmaxvsize int + +func init() { + flag.IntVar(&qcount, "quick.count", 5, "") + flag.IntVar(&qseed, "quick.seed", int(time.Now().UnixNano())%100000, "") + flag.IntVar(&qmaxitems, "quick.maxitems", 1000, "") + flag.IntVar(&qmaxksize, "quick.maxksize", 1024, "") + flag.IntVar(&qmaxvsize, "quick.maxvsize", 1024, "") + flag.Parse() + fmt.Fprintln(os.Stderr, "seed:", qseed) + fmt.Fprintf(os.Stderr, "quick settings: count=%v, items=%v, ksize=%v, vsize=%v\n", qcount, qmaxitems, qmaxksize, qmaxvsize) +} + +func qconfig() *quick.Config { + return &quick.Config{ + MaxCount: qcount, + Rand: rand.New(rand.NewSource(int64(qseed))), + } +} + +type testdata []testdataitem + +func (t testdata) Len() int { return len(t) } +func (t testdata) Swap(i, j int) { t[i], t[j] = t[j], t[i] } +func (t testdata) Less(i, j int) bool { return bytes.Compare(t[i].Key, t[j].Key) == -1 } + +func (t testdata) Generate(rand *rand.Rand, size int) reflect.Value { + n := rand.Intn(qmaxitems-1) + 1 + items := make(testdata, n) + for i := 0; i < n; i++ { + item := &items[i] + item.Key = randByteSlice(rand, 1, qmaxksize) + item.Value = randByteSlice(rand, 0, qmaxvsize) + } + return reflect.ValueOf(items) +} + +type revtestdata []testdataitem + +func (t revtestdata) Len() int { return len(t) } +func (t revtestdata) Swap(i, j int) { t[i], t[j] = t[j], t[i] } +func (t revtestdata) Less(i, j int) bool { return bytes.Compare(t[i].Key, t[j].Key) == 1 } + +type testdataitem struct { + Key []byte + Value []byte +} + +func randByteSlice(rand *rand.Rand, minSize, maxSize int) []byte { + n := rand.Intn(maxSize-minSize) + minSize + b := make([]byte, n) + for i := 0; i < n; i++ { + b[i] = byte(rand.Intn(255)) + } + return b +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/simulation_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/simulation_test.go new file mode 100644 index 000000000..8a49a381b --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/simulation_test.go @@ -0,0 +1,327 @@ +package bolt_test + +import ( + "bytes" + "fmt" + "math/rand" + "sync" + "testing" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +func TestSimulate_1op_1p(t *testing.T) { testSimulate(t, 100, 1) } +func TestSimulate_10op_1p(t *testing.T) { testSimulate(t, 10, 1) } +func TestSimulate_100op_1p(t *testing.T) { testSimulate(t, 100, 1) } +func TestSimulate_1000op_1p(t *testing.T) { testSimulate(t, 1000, 1) } +func TestSimulate_10000op_1p(t *testing.T) { testSimulate(t, 10000, 1) } + +func TestSimulate_10op_10p(t *testing.T) { testSimulate(t, 10, 10) } +func TestSimulate_100op_10p(t *testing.T) { testSimulate(t, 100, 10) } +func TestSimulate_1000op_10p(t *testing.T) { testSimulate(t, 1000, 10) } +func TestSimulate_10000op_10p(t *testing.T) { testSimulate(t, 10000, 10) } + +func TestSimulate_100op_100p(t *testing.T) { testSimulate(t, 100, 100) } +func TestSimulate_1000op_100p(t *testing.T) { testSimulate(t, 1000, 100) } +func TestSimulate_10000op_100p(t *testing.T) { testSimulate(t, 10000, 100) } + +func TestSimulate_10000op_1000p(t *testing.T) { testSimulate(t, 10000, 1000) } + +// Randomly generate operations on a given database with multiple clients to ensure consistency and thread safety. +func testSimulate(t *testing.T, threadCount, parallelism int) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + rand.Seed(int64(qseed)) + + // A list of operations that readers and writers can perform. + var readerHandlers = []simulateHandler{simulateGetHandler} + var writerHandlers = []simulateHandler{simulateGetHandler, simulatePutHandler} + + var versions = make(map[int]*QuickDB) + versions[1] = NewQuickDB() + + db := NewTestDB() + defer db.Close() + + var mutex sync.Mutex + + // Run n threads in parallel, each with their own operation. + var wg sync.WaitGroup + var threads = make(chan bool, parallelism) + var i int + for { + threads <- true + wg.Add(1) + writable := ((rand.Int() % 100) < 20) // 20% writers + + // Choose an operation to execute. + var handler simulateHandler + if writable { + handler = writerHandlers[rand.Intn(len(writerHandlers))] + } else { + handler = readerHandlers[rand.Intn(len(readerHandlers))] + } + + // Execute a thread for the given operation. + go func(writable bool, handler simulateHandler) { + defer wg.Done() + + // Start transaction. + tx, err := db.Begin(writable) + if err != nil { + t.Fatal("tx begin: ", err) + } + + // Obtain current state of the dataset. + mutex.Lock() + var qdb = versions[tx.ID()] + if writable { + qdb = versions[tx.ID()-1].Copy() + } + mutex.Unlock() + + // Make sure we commit/rollback the tx at the end and update the state. + if writable { + defer func() { + mutex.Lock() + versions[tx.ID()] = qdb + mutex.Unlock() + + ok(t, tx.Commit()) + }() + } else { + defer tx.Rollback() + } + + // Ignore operation if we don't have data yet. + if qdb == nil { + return + } + + // Execute handler. + handler(tx, qdb) + + // Release a thread back to the scheduling loop. + <-threads + }(writable, handler) + + i++ + if i > threadCount { + break + } + } + + // Wait until all threads are done. + wg.Wait() +} + +type simulateHandler func(tx *bolt.Tx, qdb *QuickDB) + +// Retrieves a key from the database and verifies that it is what is expected. +func simulateGetHandler(tx *bolt.Tx, qdb *QuickDB) { + // Randomly retrieve an existing exist. + keys := qdb.Rand() + if len(keys) == 0 { + return + } + + // Retrieve root bucket. + b := tx.Bucket(keys[0]) + if b == nil { + panic(fmt.Sprintf("bucket[0] expected: %08x\n", trunc(keys[0], 4))) + } + + // Drill into nested buckets. + for _, key := range keys[1 : len(keys)-1] { + b = b.Bucket(key) + if b == nil { + panic(fmt.Sprintf("bucket[n] expected: %v -> %v\n", keys, key)) + } + } + + // Verify key/value on the final bucket. + expected := qdb.Get(keys) + actual := b.Get(keys[len(keys)-1]) + if !bytes.Equal(actual, expected) { + fmt.Println("=== EXPECTED ===") + fmt.Println(expected) + fmt.Println("=== ACTUAL ===") + fmt.Println(actual) + fmt.Println("=== END ===") + panic("value mismatch") + } +} + +// Inserts a key into the database. +func simulatePutHandler(tx *bolt.Tx, qdb *QuickDB) { + var err error + keys, value := randKeys(), randValue() + + // Retrieve root bucket. + b := tx.Bucket(keys[0]) + if b == nil { + b, err = tx.CreateBucket(keys[0]) + if err != nil { + panic("create bucket: " + err.Error()) + } + } + + // Create nested buckets, if necessary. + for _, key := range keys[1 : len(keys)-1] { + child := b.Bucket(key) + if child != nil { + b = child + } else { + b, err = b.CreateBucket(key) + if err != nil { + panic("create bucket: " + err.Error()) + } + } + } + + // Insert into database. + if err := b.Put(keys[len(keys)-1], value); err != nil { + panic("put: " + err.Error()) + } + + // Insert into in-memory database. + qdb.Put(keys, value) +} + +// QuickDB is an in-memory database that replicates the functionality of the +// Bolt DB type except that it is entirely in-memory. It is meant for testing +// that the Bolt database is consistent. +type QuickDB struct { + sync.RWMutex + m map[string]interface{} +} + +// NewQuickDB returns an instance of QuickDB. +func NewQuickDB() *QuickDB { + return &QuickDB{m: make(map[string]interface{})} +} + +// Get retrieves the value at a key path. +func (db *QuickDB) Get(keys [][]byte) []byte { + db.RLock() + defer db.RUnlock() + + m := db.m + for _, key := range keys[:len(keys)-1] { + value := m[string(key)] + if value == nil { + return nil + } + switch value := value.(type) { + case map[string]interface{}: + m = value + case []byte: + return nil + } + } + + // Only return if it's a simple value. + if value, ok := m[string(keys[len(keys)-1])].([]byte); ok { + return value + } + return nil +} + +// Put inserts a value into a key path. +func (db *QuickDB) Put(keys [][]byte, value []byte) { + db.Lock() + defer db.Unlock() + + // Build buckets all the way down the key path. + m := db.m + for _, key := range keys[:len(keys)-1] { + if _, ok := m[string(key)].([]byte); ok { + return // Keypath intersects with a simple value. Do nothing. + } + + if m[string(key)] == nil { + m[string(key)] = make(map[string]interface{}) + } + m = m[string(key)].(map[string]interface{}) + } + + // Insert value into the last key. + m[string(keys[len(keys)-1])] = value +} + +// Rand returns a random key path that points to a simple value. +func (db *QuickDB) Rand() [][]byte { + db.RLock() + defer db.RUnlock() + if len(db.m) == 0 { + return nil + } + var keys [][]byte + db.rand(db.m, &keys) + return keys +} + +func (db *QuickDB) rand(m map[string]interface{}, keys *[][]byte) { + i, index := 0, rand.Intn(len(m)) + for k, v := range m { + if i == index { + *keys = append(*keys, []byte(k)) + if v, ok := v.(map[string]interface{}); ok { + db.rand(v, keys) + } + return + } + i++ + } + panic("quickdb rand: out-of-range") +} + +// Copy copies the entire database. +func (db *QuickDB) Copy() *QuickDB { + db.RLock() + defer db.RUnlock() + return &QuickDB{m: db.copy(db.m)} +} + +func (db *QuickDB) copy(m map[string]interface{}) map[string]interface{} { + clone := make(map[string]interface{}, len(m)) + for k, v := range m { + switch v := v.(type) { + case map[string]interface{}: + clone[k] = db.copy(v) + default: + clone[k] = v + } + } + return clone +} + +func randKey() []byte { + var min, max = 1, 1024 + n := rand.Intn(max-min) + min + b := make([]byte, n) + for i := 0; i < n; i++ { + b[i] = byte(rand.Intn(255)) + } + return b +} + +func randKeys() [][]byte { + var keys [][]byte + var count = rand.Intn(2) + 2 + for i := 0; i < count; i++ { + keys = append(keys, randKey()) + } + return keys +} + +func randValue() []byte { + n := rand.Intn(8192) + b := make([]byte, n) + for i := 0; i < n; i++ { + b[i] = byte(rand.Intn(255)) + } + return b +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/tx.go b/Godeps/_workspace/src/github.com/boltdb/bolt/tx.go new file mode 100644 index 000000000..fda6a210a --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/tx.go @@ -0,0 +1,585 @@ +package bolt + +import ( + "fmt" + "io" + "os" + "sort" + "time" + "unsafe" +) + +// txid represents the internal transaction identifier. +type txid uint64 + +// Tx represents a read-only or read/write transaction on the database. +// Read-only transactions can be used for retrieving values for keys and creating cursors. +// Read/write transactions can create and remove buckets and create and remove keys. +// +// IMPORTANT: You must commit or rollback transactions when you are done with +// them. Pages can not be reclaimed by the writer until no more transactions +// are using them. A long running read transaction can cause the database to +// quickly grow. +type Tx struct { + writable bool + managed bool + db *DB + meta *meta + root Bucket + pages map[pgid]*page + stats TxStats + commitHandlers []func() +} + +// init initializes the transaction. +func (tx *Tx) init(db *DB) { + tx.db = db + tx.pages = nil + + // Copy the meta page since it can be changed by the writer. + tx.meta = &meta{} + db.meta().copy(tx.meta) + + // Copy over the root bucket. + tx.root = newBucket(tx) + tx.root.bucket = &bucket{} + *tx.root.bucket = tx.meta.root + + // Increment the transaction id and add a page cache for writable transactions. + if tx.writable { + tx.pages = make(map[pgid]*page) + tx.meta.txid += txid(1) + } +} + +// ID returns the transaction id. +func (tx *Tx) ID() int { + return int(tx.meta.txid) +} + +// DB returns a reference to the database that created the transaction. +func (tx *Tx) DB() *DB { + return tx.db +} + +// Size returns current database size in bytes as seen by this transaction. +func (tx *Tx) Size() int64 { + return int64(tx.meta.pgid) * int64(tx.db.pageSize) +} + +// Writable returns whether the transaction can perform write operations. +func (tx *Tx) Writable() bool { + return tx.writable +} + +// Cursor creates a cursor associated with the root bucket. +// All items in the cursor will return a nil value because all root bucket keys point to buckets. +// The cursor is only valid as long as the transaction is open. +// Do not use a cursor after the transaction is closed. +func (tx *Tx) Cursor() *Cursor { + return tx.root.Cursor() +} + +// Stats retrieves a copy of the current transaction statistics. +func (tx *Tx) Stats() TxStats { + return tx.stats +} + +// Bucket retrieves a bucket by name. +// Returns nil if the bucket does not exist. +func (tx *Tx) Bucket(name []byte) *Bucket { + return tx.root.Bucket(name) +} + +// CreateBucket creates a new bucket. +// Returns an error if the bucket already exists, if the bucket name is blank, or if the bucket name is too long. +func (tx *Tx) CreateBucket(name []byte) (*Bucket, error) { + return tx.root.CreateBucket(name) +} + +// CreateBucketIfNotExists creates a new bucket if it doesn't already exist. +// Returns an error if the bucket name is blank, or if the bucket name is too long. +func (tx *Tx) CreateBucketIfNotExists(name []byte) (*Bucket, error) { + return tx.root.CreateBucketIfNotExists(name) +} + +// DeleteBucket deletes a bucket. +// Returns an error if the bucket cannot be found or if the key represents a non-bucket value. +func (tx *Tx) DeleteBucket(name []byte) error { + return tx.root.DeleteBucket(name) +} + +// ForEach executes a function for each bucket in the root. +// If the provided function returns an error then the iteration is stopped and +// the error is returned to the caller. +func (tx *Tx) ForEach(fn func(name []byte, b *Bucket) error) error { + return tx.root.ForEach(func(k, v []byte) error { + if err := fn(k, tx.root.Bucket(k)); err != nil { + return err + } + return nil + }) +} + +// OnCommit adds a handler function to be executed after the transaction successfully commits. +func (tx *Tx) OnCommit(fn func()) { + tx.commitHandlers = append(tx.commitHandlers, fn) +} + +// Commit writes all changes to disk and updates the meta page. +// Returns an error if a disk write error occurs. +func (tx *Tx) Commit() error { + _assert(!tx.managed, "managed tx commit not allowed") + if tx.db == nil { + return ErrTxClosed + } else if !tx.writable { + return ErrTxNotWritable + } + + // TODO(benbjohnson): Use vectorized I/O to write out dirty pages. + + // Rebalance nodes which have had deletions. + var startTime = time.Now() + tx.root.rebalance() + if tx.stats.Rebalance > 0 { + tx.stats.RebalanceTime += time.Since(startTime) + } + + // spill data onto dirty pages. + startTime = time.Now() + if err := tx.root.spill(); err != nil { + tx.rollback() + return err + } + tx.stats.SpillTime += time.Since(startTime) + + // Free the old root bucket. + tx.meta.root.root = tx.root.root + + // Free the freelist and allocate new pages for it. This will overestimate + // the size of the freelist but not underestimate the size (which would be bad). + tx.db.freelist.free(tx.meta.txid, tx.db.page(tx.meta.freelist)) + p, err := tx.allocate((tx.db.freelist.size() / tx.db.pageSize) + 1) + if err != nil { + tx.rollback() + return err + } + if err := tx.db.freelist.write(p); err != nil { + tx.rollback() + return err + } + tx.meta.freelist = p.id + + // Write dirty pages to disk. + startTime = time.Now() + if err := tx.write(); err != nil { + tx.rollback() + return err + } + + // If strict mode is enabled then perform a consistency check. + // Only the first consistency error is reported in the panic. + if tx.db.StrictMode { + if err, ok := <-tx.Check(); ok { + panic("check fail: " + err.Error()) + } + } + + // Write meta to disk. + if err := tx.writeMeta(); err != nil { + tx.rollback() + return err + } + tx.stats.WriteTime += time.Since(startTime) + + // Finalize the transaction. + tx.close() + + // Execute commit handlers now that the locks have been removed. + for _, fn := range tx.commitHandlers { + fn() + } + + return nil +} + +// Rollback closes the transaction and ignores all previous updates. +func (tx *Tx) Rollback() error { + _assert(!tx.managed, "managed tx rollback not allowed") + if tx.db == nil { + return ErrTxClosed + } + tx.rollback() + return nil +} + +func (tx *Tx) rollback() { + if tx.db == nil { + return + } + if tx.writable { + tx.db.freelist.rollback(tx.meta.txid) + tx.db.freelist.reload(tx.db.page(tx.db.meta().freelist)) + } + tx.close() +} + +func (tx *Tx) close() { + if tx.db == nil { + return + } + if tx.writable { + // Grab freelist stats. + var freelistFreeN = tx.db.freelist.free_count() + var freelistPendingN = tx.db.freelist.pending_count() + var freelistAlloc = tx.db.freelist.size() + + // Remove writer lock. + tx.db.rwlock.Unlock() + + // Merge statistics. + tx.db.statlock.Lock() + tx.db.stats.FreePageN = freelistFreeN + tx.db.stats.PendingPageN = freelistPendingN + tx.db.stats.FreeAlloc = (freelistFreeN + freelistPendingN) * tx.db.pageSize + tx.db.stats.FreelistInuse = freelistAlloc + tx.db.stats.TxStats.add(&tx.stats) + tx.db.statlock.Unlock() + } else { + tx.db.removeTx(tx) + } + tx.db = nil +} + +// Copy writes the entire database to a writer. +// This function exists for backwards compatibility. Use WriteTo() in +func (tx *Tx) Copy(w io.Writer) error { + _, err := tx.WriteTo(w) + return err +} + +// WriteTo writes the entire database to a writer. +// If err == nil then exactly tx.Size() bytes will be written into the writer. +func (tx *Tx) WriteTo(w io.Writer) (n int64, err error) { + // Attempt to open reader directly. + var f *os.File + if f, err = os.OpenFile(tx.db.path, os.O_RDONLY|odirect, 0); err != nil { + // Fallback to a regular open if that doesn't work. + if f, err = os.OpenFile(tx.db.path, os.O_RDONLY, 0); err != nil { + return 0, err + } + } + + // Copy the meta pages. + tx.db.metalock.Lock() + n, err = io.CopyN(w, f, int64(tx.db.pageSize*2)) + tx.db.metalock.Unlock() + if err != nil { + _ = f.Close() + return n, fmt.Errorf("meta copy: %s", err) + } + + // Copy data pages. + wn, err := io.CopyN(w, f, tx.Size()-int64(tx.db.pageSize*2)) + n += wn + if err != nil { + _ = f.Close() + return n, err + } + + return n, f.Close() +} + +// CopyFile copies the entire database to file at the given path. +// A reader transaction is maintained during the copy so it is safe to continue +// using the database while a copy is in progress. +func (tx *Tx) CopyFile(path string, mode os.FileMode) error { + f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, mode) + if err != nil { + return err + } + + err = tx.Copy(f) + if err != nil { + _ = f.Close() + return err + } + return f.Close() +} + +// Check performs several consistency checks on the database for this transaction. +// An error is returned if any inconsistency is found. +// +// It can be safely run concurrently on a writable transaction. However, this +// incurs a high cost for large databases and databases with a lot of subbuckets +// because of caching. This overhead can be removed if running on a read-only +// transaction, however, it is not safe to execute other writer transactions at +// the same time. +func (tx *Tx) Check() <-chan error { + ch := make(chan error) + go tx.check(ch) + return ch +} + +func (tx *Tx) check(ch chan error) { + // Check if any pages are double freed. + freed := make(map[pgid]bool) + for _, id := range tx.db.freelist.all() { + if freed[id] { + ch <- fmt.Errorf("page %d: already freed", id) + } + freed[id] = true + } + + // Track every reachable page. + reachable := make(map[pgid]*page) + reachable[0] = tx.page(0) // meta0 + reachable[1] = tx.page(1) // meta1 + for i := uint32(0); i <= tx.page(tx.meta.freelist).overflow; i++ { + reachable[tx.meta.freelist+pgid(i)] = tx.page(tx.meta.freelist) + } + + // Recursively check buckets. + tx.checkBucket(&tx.root, reachable, freed, ch) + + // Ensure all pages below high water mark are either reachable or freed. + for i := pgid(0); i < tx.meta.pgid; i++ { + _, isReachable := reachable[i] + if !isReachable && !freed[i] { + ch <- fmt.Errorf("page %d: unreachable unfreed", int(i)) + } + } + + // Close the channel to signal completion. + close(ch) +} + +func (tx *Tx) checkBucket(b *Bucket, reachable map[pgid]*page, freed map[pgid]bool, ch chan error) { + // Ignore inline buckets. + if b.root == 0 { + return + } + + // Check every page used by this bucket. + b.tx.forEachPage(b.root, 0, func(p *page, _ int) { + if p.id > tx.meta.pgid { + ch <- fmt.Errorf("page %d: out of bounds: %d", int(p.id), int(b.tx.meta.pgid)) + } + + // Ensure each page is only referenced once. + for i := pgid(0); i <= pgid(p.overflow); i++ { + var id = p.id + i + if _, ok := reachable[id]; ok { + ch <- fmt.Errorf("page %d: multiple references", int(id)) + } + reachable[id] = p + } + + // We should only encounter un-freed leaf and branch pages. + if freed[p.id] { + ch <- fmt.Errorf("page %d: reachable freed", int(p.id)) + } else if (p.flags&branchPageFlag) == 0 && (p.flags&leafPageFlag) == 0 { + ch <- fmt.Errorf("page %d: invalid type: %s", int(p.id), p.typ()) + } + }) + + // Check each bucket within this bucket. + _ = b.ForEach(func(k, v []byte) error { + if child := b.Bucket(k); child != nil { + tx.checkBucket(child, reachable, freed, ch) + } + return nil + }) +} + +// allocate returns a contiguous block of memory starting at a given page. +func (tx *Tx) allocate(count int) (*page, error) { + p, err := tx.db.allocate(count) + if err != nil { + return nil, err + } + + // Save to our page cache. + tx.pages[p.id] = p + + // Update statistics. + tx.stats.PageCount++ + tx.stats.PageAlloc += count * tx.db.pageSize + + return p, nil +} + +// write writes any dirty pages to disk. +func (tx *Tx) write() error { + // Sort pages by id. + pages := make(pages, 0, len(tx.pages)) + for _, p := range tx.pages { + pages = append(pages, p) + } + sort.Sort(pages) + + // Write pages to disk in order. + for _, p := range pages { + size := (int(p.overflow) + 1) * tx.db.pageSize + buf := (*[maxAllocSize]byte)(unsafe.Pointer(p))[:size] + offset := int64(p.id) * int64(tx.db.pageSize) + if _, err := tx.db.ops.writeAt(buf, offset); err != nil { + return err + } + + // Update statistics. + tx.stats.Write++ + } + if !tx.db.NoSync || IgnoreNoSync { + if err := fdatasync(tx.db); err != nil { + return err + } + } + + // Clear out page cache. + tx.pages = make(map[pgid]*page) + + return nil +} + +// writeMeta writes the meta to the disk. +func (tx *Tx) writeMeta() error { + // Create a temporary buffer for the meta page. + buf := make([]byte, tx.db.pageSize) + p := tx.db.pageInBuffer(buf, 0) + tx.meta.write(p) + + // Write the meta page to file. + if _, err := tx.db.ops.writeAt(buf, int64(p.id)*int64(tx.db.pageSize)); err != nil { + return err + } + if !tx.db.NoSync || IgnoreNoSync { + if err := fdatasync(tx.db); err != nil { + return err + } + } + + // Update statistics. + tx.stats.Write++ + + return nil +} + +// page returns a reference to the page with a given id. +// If page has been written to then a temporary bufferred page is returned. +func (tx *Tx) page(id pgid) *page { + // Check the dirty pages first. + if tx.pages != nil { + if p, ok := tx.pages[id]; ok { + return p + } + } + + // Otherwise return directly from the mmap. + return tx.db.page(id) +} + +// forEachPage iterates over every page within a given page and executes a function. +func (tx *Tx) forEachPage(pgid pgid, depth int, fn func(*page, int)) { + p := tx.page(pgid) + + // Execute function. + fn(p, depth) + + // Recursively loop over children. + if (p.flags & branchPageFlag) != 0 { + for i := 0; i < int(p.count); i++ { + elem := p.branchPageElement(uint16(i)) + tx.forEachPage(elem.pgid, depth+1, fn) + } + } +} + +// Page returns page information for a given page number. +// This is only safe for concurrent use when used by a writable transaction. +func (tx *Tx) Page(id int) (*PageInfo, error) { + if tx.db == nil { + return nil, ErrTxClosed + } else if pgid(id) >= tx.meta.pgid { + return nil, nil + } + + // Build the page info. + p := tx.db.page(pgid(id)) + info := &PageInfo{ + ID: id, + Count: int(p.count), + OverflowCount: int(p.overflow), + } + + // Determine the type (or if it's free). + if tx.db.freelist.freed(pgid(id)) { + info.Type = "free" + } else { + info.Type = p.typ() + } + + return info, nil +} + +// TxStats represents statistics about the actions performed by the transaction. +type TxStats struct { + // Page statistics. + PageCount int // number of page allocations + PageAlloc int // total bytes allocated + + // Cursor statistics. + CursorCount int // number of cursors created + + // Node statistics + NodeCount int // number of node allocations + NodeDeref int // number of node dereferences + + // Rebalance statistics. + Rebalance int // number of node rebalances + RebalanceTime time.Duration // total time spent rebalancing + + // Split/Spill statistics. + Split int // number of nodes split + Spill int // number of nodes spilled + SpillTime time.Duration // total time spent spilling + + // Write statistics. + Write int // number of writes performed + WriteTime time.Duration // total time spent writing to disk +} + +func (s *TxStats) add(other *TxStats) { + s.PageCount += other.PageCount + s.PageAlloc += other.PageAlloc + s.CursorCount += other.CursorCount + s.NodeCount += other.NodeCount + s.NodeDeref += other.NodeDeref + s.Rebalance += other.Rebalance + s.RebalanceTime += other.RebalanceTime + s.Split += other.Split + s.Spill += other.Spill + s.SpillTime += other.SpillTime + s.Write += other.Write + s.WriteTime += other.WriteTime +} + +// Sub calculates and returns the difference between two sets of transaction stats. +// This is useful when obtaining stats at two different points and time and +// you need the performance counters that occurred within that time span. +func (s *TxStats) Sub(other *TxStats) TxStats { + var diff TxStats + diff.PageCount = s.PageCount - other.PageCount + diff.PageAlloc = s.PageAlloc - other.PageAlloc + diff.CursorCount = s.CursorCount - other.CursorCount + diff.NodeCount = s.NodeCount - other.NodeCount + diff.NodeDeref = s.NodeDeref - other.NodeDeref + diff.Rebalance = s.Rebalance - other.Rebalance + diff.RebalanceTime = s.RebalanceTime - other.RebalanceTime + diff.Split = s.Split - other.Split + diff.Spill = s.Spill - other.Spill + diff.SpillTime = s.SpillTime - other.SpillTime + diff.Write = s.Write - other.Write + diff.WriteTime = s.WriteTime - other.WriteTime + return diff +} diff --git a/Godeps/_workspace/src/github.com/boltdb/bolt/tx_test.go b/Godeps/_workspace/src/github.com/boltdb/bolt/tx_test.go new file mode 100644 index 000000000..9612f336a --- /dev/null +++ b/Godeps/_workspace/src/github.com/boltdb/bolt/tx_test.go @@ -0,0 +1,424 @@ +package bolt_test + +import ( + "errors" + "fmt" + "os" + "testing" + + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" +) + +// Ensure that committing a closed transaction returns an error. +func TestTx_Commit_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.CreateBucket([]byte("foo")) + ok(t, tx.Commit()) + equals(t, tx.Commit(), bolt.ErrTxClosed) +} + +// Ensure that rolling back a closed transaction returns an error. +func TestTx_Rollback_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + ok(t, tx.Rollback()) + equals(t, tx.Rollback(), bolt.ErrTxClosed) +} + +// Ensure that committing a read-only transaction returns an error. +func TestTx_Commit_ReadOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(false) + equals(t, tx.Commit(), bolt.ErrTxNotWritable) +} + +// Ensure that a transaction can retrieve a cursor on the root bucket. +func TestTx_Cursor(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.CreateBucket([]byte("woojits")) + c := tx.Cursor() + + k, v := c.First() + equals(t, "widgets", string(k)) + assert(t, v == nil, "") + + k, v = c.Next() + equals(t, "woojits", string(k)) + assert(t, v == nil, "") + + k, v = c.Next() + assert(t, k == nil, "") + assert(t, v == nil, "") + + return nil + }) +} + +// Ensure that creating a bucket with a read-only transaction returns an error. +func TestTx_CreateBucket_ReadOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.View(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("foo")) + assert(t, b == nil, "") + equals(t, bolt.ErrTxNotWritable, err) + return nil + }) +} + +// Ensure that creating a bucket on a closed transaction returns an error. +func TestTx_CreateBucket_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.Commit() + b, err := tx.CreateBucket([]byte("foo")) + assert(t, b == nil, "") + equals(t, bolt.ErrTxClosed, err) +} + +// Ensure that a Tx can retrieve a bucket. +func TestTx_Bucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + b := tx.Bucket([]byte("widgets")) + assert(t, b != nil, "") + return nil + }) +} + +// Ensure that a Tx retrieving a non-existent key returns nil. +func TestTx_Get_Missing(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + value := tx.Bucket([]byte("widgets")).Get([]byte("no_such_key")) + assert(t, value == nil, "") + return nil + }) +} + +// Ensure that a bucket can be created and retrieved. +func TestTx_CreateBucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + + // Create a bucket. + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + assert(t, b != nil, "") + ok(t, err) + return nil + }) + + // Read the bucket through a separate transaction. + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + assert(t, b != nil, "") + return nil + }) +} + +// Ensure that a bucket can be created if it doesn't already exist. +func TestTx_CreateBucketIfNotExists(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucketIfNotExists([]byte("widgets")) + assert(t, b != nil, "") + ok(t, err) + + b, err = tx.CreateBucketIfNotExists([]byte("widgets")) + assert(t, b != nil, "") + ok(t, err) + + b, err = tx.CreateBucketIfNotExists([]byte{}) + assert(t, b == nil, "") + equals(t, bolt.ErrBucketNameRequired, err) + + b, err = tx.CreateBucketIfNotExists(nil) + assert(t, b == nil, "") + equals(t, bolt.ErrBucketNameRequired, err) + return nil + }) + + // Read the bucket through a separate transaction. + db.View(func(tx *bolt.Tx) error { + b := tx.Bucket([]byte("widgets")) + assert(t, b != nil, "") + return nil + }) +} + +// Ensure that a bucket cannot be created twice. +func TestTx_CreateBucket_Exists(t *testing.T) { + db := NewTestDB() + defer db.Close() + // Create a bucket. + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + assert(t, b != nil, "") + ok(t, err) + return nil + }) + + // Create the same bucket again. + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket([]byte("widgets")) + assert(t, b == nil, "") + equals(t, bolt.ErrBucketExists, err) + return nil + }) +} + +// Ensure that a bucket is created with a non-blank name. +func TestTx_CreateBucket_NameRequired(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + b, err := tx.CreateBucket(nil) + assert(t, b == nil, "") + equals(t, bolt.ErrBucketNameRequired, err) + return nil + }) +} + +// Ensure that a bucket can be deleted. +func TestTx_DeleteBucket(t *testing.T) { + db := NewTestDB() + defer db.Close() + + // Create a bucket and add a value. + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + return nil + }) + + // Delete the bucket and make sure we can't get the value. + db.Update(func(tx *bolt.Tx) error { + ok(t, tx.DeleteBucket([]byte("widgets"))) + assert(t, tx.Bucket([]byte("widgets")) == nil, "") + return nil + }) + + db.Update(func(tx *bolt.Tx) error { + // Create the bucket again and make sure there's not a phantom value. + b, err := tx.CreateBucket([]byte("widgets")) + assert(t, b != nil, "") + ok(t, err) + assert(t, tx.Bucket([]byte("widgets")).Get([]byte("foo")) == nil, "") + return nil + }) +} + +// Ensure that deleting a bucket on a closed transaction returns an error. +func TestTx_DeleteBucket_Closed(t *testing.T) { + db := NewTestDB() + defer db.Close() + tx, _ := db.Begin(true) + tx.Commit() + equals(t, tx.DeleteBucket([]byte("foo")), bolt.ErrTxClosed) +} + +// Ensure that deleting a bucket with a read-only transaction returns an error. +func TestTx_DeleteBucket_ReadOnly(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.View(func(tx *bolt.Tx) error { + equals(t, tx.DeleteBucket([]byte("foo")), bolt.ErrTxNotWritable) + return nil + }) +} + +// Ensure that nothing happens when deleting a bucket that doesn't exist. +func TestTx_DeleteBucket_NotFound(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + equals(t, bolt.ErrBucketNotFound, tx.DeleteBucket([]byte("widgets"))) + return nil + }) +} + +// Ensure that Tx commit handlers are called after a transaction successfully commits. +func TestTx_OnCommit(t *testing.T) { + var x int + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.OnCommit(func() { x += 1 }) + tx.OnCommit(func() { x += 2 }) + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + equals(t, 3, x) +} + +// Ensure that Tx commit handlers are NOT called after a transaction rolls back. +func TestTx_OnCommit_Rollback(t *testing.T) { + var x int + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.OnCommit(func() { x += 1 }) + tx.OnCommit(func() { x += 2 }) + tx.CreateBucket([]byte("widgets")) + return errors.New("rollback this commit") + }) + equals(t, 0, x) +} + +// Ensure that the database can be copied to a file path. +func TestTx_CopyFile(t *testing.T) { + db := NewTestDB() + defer db.Close() + var dest = tempfile() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("bat")) + return nil + }) + + ok(t, db.View(func(tx *bolt.Tx) error { return tx.CopyFile(dest, 0600) })) + + db2, err := bolt.Open(dest, 0600, nil) + ok(t, err) + defer db2.Close() + + db2.View(func(tx *bolt.Tx) error { + equals(t, []byte("bar"), tx.Bucket([]byte("widgets")).Get([]byte("foo"))) + equals(t, []byte("bat"), tx.Bucket([]byte("widgets")).Get([]byte("baz"))) + return nil + }) +} + +type failWriterError struct{} + +func (failWriterError) Error() string { + return "error injected for tests" +} + +type failWriter struct { + // fail after this many bytes + After int +} + +func (f *failWriter) Write(p []byte) (n int, err error) { + n = len(p) + if n > f.After { + n = f.After + err = failWriterError{} + } + f.After -= n + return n, err +} + +// Ensure that Copy handles write errors right. +func TestTx_CopyFile_Error_Meta(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("bat")) + return nil + }) + + err := db.View(func(tx *bolt.Tx) error { return tx.Copy(&failWriter{}) }) + equals(t, err.Error(), "meta copy: error injected for tests") +} + +// Ensure that Copy handles write errors right. +func TestTx_CopyFile_Error_Normal(t *testing.T) { + db := NewTestDB() + defer db.Close() + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + tx.Bucket([]byte("widgets")).Put([]byte("baz"), []byte("bat")) + return nil + }) + + err := db.View(func(tx *bolt.Tx) error { return tx.Copy(&failWriter{3 * db.Info().PageSize}) }) + equals(t, err.Error(), "error injected for tests") +} + +func ExampleTx_Rollback() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Create a bucket. + db.Update(func(tx *bolt.Tx) error { + _, err := tx.CreateBucket([]byte("widgets")) + return err + }) + + // Set a value for a key. + db.Update(func(tx *bolt.Tx) error { + return tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + }) + + // Update the key but rollback the transaction so it never saves. + tx, _ := db.Begin(true) + b := tx.Bucket([]byte("widgets")) + b.Put([]byte("foo"), []byte("baz")) + tx.Rollback() + + // Ensure that our original value is still set. + db.View(func(tx *bolt.Tx) error { + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + fmt.Printf("The value for 'foo' is still: %s\n", value) + return nil + }) + + // Output: + // The value for 'foo' is still: bar +} + +func ExampleTx_CopyFile() { + // Open the database. + db, _ := bolt.Open(tempfile(), 0666, nil) + defer os.Remove(db.Path()) + defer db.Close() + + // Create a bucket and a key. + db.Update(func(tx *bolt.Tx) error { + tx.CreateBucket([]byte("widgets")) + tx.Bucket([]byte("widgets")).Put([]byte("foo"), []byte("bar")) + return nil + }) + + // Copy the database to another file. + toFile := tempfile() + db.View(func(tx *bolt.Tx) error { return tx.CopyFile(toFile, 0666) }) + defer os.Remove(toFile) + + // Open the cloned database. + db2, _ := bolt.Open(toFile, 0666, nil) + defer db2.Close() + + // Ensure that the key exists in the copy. + db2.View(func(tx *bolt.Tx) error { + value := tx.Bucket([]byte("widgets")).Get([]byte("foo")) + fmt.Printf("The value for 'foo' in the clone is: %s\n", value) + return nil + }) + + // Output: + // The value for 'foo' in the clone is: bar +} diff --git a/storage/backend/backend.go b/storage/backend/backend.go index c91492ed9..b2b85b63d 100644 --- a/storage/backend/backend.go +++ b/storage/backend/backend.go @@ -4,7 +4,7 @@ import ( "log" "time" - "github.com/boltdb/bolt" + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" ) type Backend interface { diff --git a/storage/backend/batch_tx.go b/storage/backend/batch_tx.go index 45bbf3a24..5df76f22e 100644 --- a/storage/backend/batch_tx.go +++ b/storage/backend/batch_tx.go @@ -5,7 +5,7 @@ import ( "log" "sync" - "github.com/boltdb/bolt" + "github.com/coreos/etcd/Godeps/_workspace/src/github.com/boltdb/bolt" ) type BatchTx interface {

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 z zUgex^9_B`7pi}ENhx726u-~&jJ0c6=N30n~Zgt;0%)bt7u|4!C4swg z8S);zM_C_Z10k@jw+hy`aeS6RZfQC^C%OPz>?W~g8Elm0RC#$SFIi0Q?Sl2~?dW+m z+r>}$oq`E{cT_e~9i`oQ?C+yEgo1k0dY9%=Ior;icXg_#H29m_BjhvhmV6=2*`>5F z=7-;?0yg?{mG6AZ-+3QomBo8jM^(4ZdjyN_ireK^(mq8Ce&u=Drbh`MM#BGKlZo(p z`8#?>30l92^7C3Grug^5yD!HCsr}&oVQSl+J=;qAw(X%_V)U5Jy_b)Sai?MD#e3z7 z%Dp_gXUs!w!?Abt2Ep3ev{#P$?wy3qxqlT|Ca`&K67|4Gf`bmB9T&)&wDK-_3Afsl>PtE1m*736z4=`x6j z91|yw3@?6O_}8%ur@dZJXY+ZF1kXX?{cCH7sXFZh4%c zi4QHX?PsC%ul0H1F$j3zzPD5MhWmZ?hI>9JLh~#+5i>bye-I}-K)Xs?p6;(w8K!bq1wz-m`X?e)b6Je@8JD%|rd|3D9z1 zmi%Q;b9?eCN<-Oln}YvuDJ|Yl*!`48MkghXBt(vsk*D%imF0ZK_tnV6oc`KM^&979 z#*V>Z1drQ4aZHD(T7^;6c5zSk+gOrCp$HYg7$x8$L^3RxHXf96L0X)^>bG+`h#8_lt~9c$B)>a$H#i_ae|GU3|^nxXZN2$R;eJEoWtDY+NrYA+Kxtj z%QM*zt5m}DUuqz9Ynsb5&^)bV9-7xu9v*ut4K_6&FFN=!Np)N2{OI)$<_w+lBdkBL zl^;@lU72%V^+xHdZs!cQ+zM>8Q|))_5d8M?pV{y@H2PfYL16ors}8~1&5P*{vvFog z|MOHr1Ka&^2BPVD)+i!dADvLa!pDzh7XrUvYl)wN@$mpPH5Uit|%KurIHb!RrR$Rrx+i zU|w%M$2*efkBtA`dQRT}r-W|`Vf5Lye2DUqZ`Txh2NSk*W`t)xsBcF`|J15;#CFL? z_5<6S6Kr^&dTI1^R^!shDXUaobvAeB0ipe>QZ@;@r>o}U`r_dZe z_Yf_Kteh)nUW<4$8+%flEmKlH%}B7}9Bon_UYxY6Y_b2!4G5FkVW2KH>%t@Nbn|PV zZKV|*&CgMKN-H^ATj^@|O%NhBilzh;wiF`pk&yD;W$Mf8j%7OjuyG6I6 zlfUHZc28;Eex5^7zd~OGhWBig&IzBEmx5SnJJC`kXd33^RygY)k%qzd#FG!xS-0ONL#Z`)FDki-D<*?k`e|Yo? zTMZ7&67As;n#=J`2`?^c-p&h!e>c#nB5Pt5xni$kC+C&Z!JPSjC3QM|COB_K6Tjj8 zYJJVq4ElN+mp|n}tk0Xz(`teDf8}MuzwC6Pv8x>e9UC1bKZW~EI~N3-cUYdIOf%O7 zDYAuI;HTcp1?$)6s`T3K=)4`A(6hT2I2S*^D}Qa6!cUb~N?u=fJpT9zTWYu8%^7Z| zFK_f;8jHBtc$MVos;{}<drd8f2 zGQ<7|FTnl-b6vI_nJTv?|uqT z=sf_s=;V@4PxgCWK`H!hyf$T#gFK6r_{=mps*iiboV9SoL zkBe3cEw8w~(poMbx4pD|lKMknqE86#G)zhJnNJF)>Beb1MzT8%j>|QF$4C0Cx%*{5 z#vbR%6XY~MBRoRi?BTmMLS6n{FuA}dZ#~Z&0rz=6pH0PlhQvEe>vMwfea_^zk{x?_ z|F;H$DLYxmXpDU?TQM_YXFnd>|NO8_p40pqV;4qrG5|XVUl44XKY?j}@#2`=moAQJ zXJ8O##V-q=EIW%@&dvWLSnoG#$LuP%ZeOACCeLD?K_gS}Z+=DcGy^}L9QiZ@Px3X$ zJl;nfo39Brr}DUEgzTKsx{gm!7at$i#oJt--q)3%i%V|5UTS6Q9*C18_6tZ*mfw;* z{h;lr=pD=zd&T;Vu8wxicUnyc4r|}XIA~|^^uh5iqC)@9s9?MDhx&l(w)dPHeU8P_ z|D3ifx%5ADS>{!0f0Pq&GvNQb=jBlc`n$r0(BHq4zZIJcejhws^7fP$_c;rEFBHe5 zF6cl`cbi}RCl;MOS9jzSuFZ z->2L9Udcaj`FZW@-K=MHK+|AT^HG8gZL;qh1#@o1Qu)z>h5z}RQ(pNsl{RpC`TMGX zj~*lWyPAjnw`v>vRoNZ2%9BfKoakRiF~!G9p8mH>0*?s}*`(QH=jyZRg<=EP(c`zF+>1+Au{~m3~C{ zhTrdxjox83JoYRR25hb<*p`cP`d()}c0^xIJ2HoIZSNK=bmMZpN_Fpn_E1USI`+cz zqffFz>3`(5efpnOyNX5s^RzMOV6GOvk&6l5dn6ZwP3lJv$c*-=4$@RmUFNpPuH@_) zc`bWm&!`@AarLBqQ1awdS8m%NyQ8$eqj5icm>Jb=(bAz&@)}?(hXvbqd{{p_eyvjwP%my=-7+@|wijTd zk>9bil)R?(6jKR&Jw19g#k9ZsrTBE=lMC#ewvD#$>r1yLW!baawEG3Jaz_PI4)i%Y zCmWEQeTp%GJ~dhMuW>!#e-8T$;g^Ml|0~A?o3|Wzj^M|(O{F2G!uF}7w1LaV>u7%! z^I`io;hlzouC3#O={!OhaeersbEBVmI7b%!&&$bPU`ux>Ki60Cx}030eLKAq${c_# zt_Zdl=y%pm8PB?R0)REA73+LUV?%v+^mthq6qQf!PQix0U2d?l%eD>V%Q5NyM`j71 zN1j#5)70PGex26)bD%@{j9@}vt;)^ntF}#C9a(@5rL%(VJAHYs)@8vpxs<$S2evi( zP6ht?yChF5$P>{qF3uF`VH5E0+%4Fm^E0of{%?jJ8$Bk?V_9th|9(^Q_`1sN&9^wu z9@?r#Gy9-yo+H@2(}njgzK^kc2}?D@W6M7!*e)m1KikLIc9)+HpoPMQ?OzEsgEvOY<;9`tpT?EBEfc?jl8ZU4GC#o;$-Mu{$;^-oquU;CF_KT z}zE{mZ>r@`zN8Az3zed@G8nIKI5s!8&tQ9_(Bl8D59%zC`%O;@W-; zS+$Y0IiUQ_WJTp?eoL@nT|cI0NREwex8-$gTEO6+`(4Qs zs}FXadv)Zs%GY6kPq2}u+wzjW`0RlpY*Vq#0J|#V;#KTlaC&!yZ_o9s$F@~;Ygc7d zF0QVO{DI{JU3$MSc{)LipVaq{PL6!VV!^-pM!}YX7@CoXw`XQKl4f|+yvOFr+y5HV zeUtLn-%>ALXeU>|ME3}$9m7yy(5M=9J@HBnJSM)9Y&u|G4B77yjCrsmNEz2{+agP2_K^@C zJ?^)Obc~9A9JK$H4G*=7{IH!4?pM>apRy#|PSj*CNKG1;+Q^?+5{;Ue_v?cnH^PUx z_lj)*~lUYuX$p9Is_Jna8S>NutlE-p*|oW_sV)Ps5NKr!8bUrpZv&ud!eUxZH> zAGM*mdh=f|jwydYFea$0b0Z&&`Mvx>!3+X@=6I!w#vIV6)W0~N(!X7tPw_)ZjD7Eh zKANEX@*fsVJJ5N-zIw_Fq*GQ)V7ng?Y$d?X$)snFAB*BG<-q1YCfF#jb6Lh^%ewX4 zVOxp~eWLeo@V>VL%p$LRnjaUwUHvU>@UO>Wvh)eTg#3p0B!OS?lNaYVP)s|Jxz^o) ztxpNRu%4f`d(HK+BDphI--lVY95D}Se_HZFw{RZRRa(*M;MZ{nN^3hB_e<2F1ogf3 z8R6ZDVV-Zjo7c3`zYC@v!^HXYGcd5D`B~vpa(w(+cvoo^N29rpj#KlRmj9gOF9#TY z+MJI!0~2Ln5QAOCbOSzhdDSd&S66c&GUGAxPHxBQ&;xv<&kHur*UmK)*y0z~&o}?Y z^<#5iO4H$2tiHqbtEbpr%nx>jy?#v7U|ajk!Z(cH1vyi*a9{}A`9JH&cE2K68Cl32 zVNTBp;ZZf{F!-uqyML*-Gy#^d*OR$uBi?LX+7A6q|mpxCbR zkl0Drp);PQZ_Da1yst8PP#QMf55)(sA3IR&dSb_XoA3?GtuB`YCEBP#3U;kB?tlCG z^=*HLVAm7B?eAPa-^xP-8;=JXDNy^cU&|8lP<&__-?qitMPR}MJ4nU8!eZ@2Fu-=c zD~)eDHp-=8*NBIQ2{tUZNN(tkXc@`=gTDEP3pVcGe_(y-28|)?Ho?YyMpJe28P;&Y zcc9q5^5A+=k~ATw;xBy?2zxUcW8}8psUa;$F`*M#HY&_P}`-{F}L!Yfx-+Be%+YjP5k|l=->u~UI z=ke>;q4@;C#^WqKc1l06eyq7fu=!y8a8e%kJvrQ-<$qAHS!IFoeSU{vi_Q;zE>c!n z+0pzyioB+^Q!sbww`gDn85sDubZOGQ)3OcdbfmIM`nPhKU`uWdi}ymxoj`iY09i7j|KlN!|wJEt32fyo1ZBy^a=6}lm=bG`(%nglJq6=RWfL;3|cpXHprmmcdo5V zIfK^Bpmmg%X8Rz6R{T*dFX!v??t5XBLF*_jtsMFpv|Mp*d1a-g@oZ+$IvG3%8MNZA zwRMRyXdR`c>DkYq<#w-K?xhS`q_niM?PTQZXV7w&XXuhai!x|!rR7~L`TZx|jC=#7 zrP)`!Vr@Mu8MIagt(!p`WYF?YTw9lN2Cb>IH2b<4G;`(J@`@R>iqg{LwKMYdGHB+< zM3*$4r3_j#gVxQUnX58v&!AN@XsrxdS7~YXnI~oFl0mCv&{`R^ZVC;3@jz*9Bma2L zu;v=+kBi=&7}lQfJ#D|^=zr~(+0!zzLZ4WAvgFOXyuL11l$O^1wUkzJ`FwxU%gASb zBE!cSv`Pl8l|k!f&;}W_{8QG}v#hi<+glm5UIs1qlOivTXIW`!<L2GBwdKomcZ*5(QN=vgn%Aj>JXoCz|@w&BjsbtVvN=wtT zmyyrxUt3;LX=yy83|c3HHprkAuU}i2N(QZ!LF;DF21-k_uXsa-E*Z2|2CbVx8>G_6%B-L2GBwdP+<4S?=ZxT{37<2Cbbz>!r}pE|^w+r2je1i;H{>a*XFK5u28MICYt)D^5 z-MY3eC8ed=-prtNGic_h$V=l{Qd(L$L>aVp2G4#*zT7i1Y*$*Ep3MweH-l!5W!SE? zRNFIX?F?EkgJy2a&_!vfx@6GW8MIyo%^Xjb1KNe6(%MG;Wwi@E#kOMD>~^8@Op%>; zd3?LjR9c!JI!Y_Ke7;>6WaP`=p0pKhR5^pz%%F8LX#EUY?!?-ecN#hwQEv+2d8MIyo&)h_Y?HRO4X=!?PGH8PgT5&SNcBQ4-oni=^zN=vhEkdZH6U0cs`2CbPv>txXS8MNHY z+Pai7Xpz#=Z0}^y1{t*Ctmu-)Gg4Y=>}Jq<89Z}yYs)KV&{|4M)1{k18)VS(^J|ww zS!rp0X=UW=X3z#1wEW2oT~cW1Uz}PtGvR@d1e|}N&bOQc$xtF>=yr-n6*g=3Deg`zKv~ErKmK^rr zwzG7Gm-kCTwpkKP%VGH5Oxn0iXHZp5w|}{%*h+w{kL-z^0~n-Y_7Xqi_>?1&*^lvg zyFCK|y^43J?!kI$-JZk6tsx`F@|r)Y3pO8MPud$JO3uz!Lok&96Y2Yak=|1ceuHJf zMuC2(`Obur_giH}F#dj1zRRIF%8r{E-D{=5mcbdt2D059VxQt1wPna|K1;C8K=$$o zo&F}-7-N~c1e0?Ze;-9oX>CX2@}!L_RG!B*4SIDH8^+SIyj!%a#{^AY^R(|)8v?!y z949nE1;64s!L$QRjV}r!1BdS+?kTnxVC!;uMPhGX`@Hb&#IVn2z6or(DcEq&_5z<- zqWxqiG(YrhK3i=H%4KHsT6<1yW=X)n=6)(ohx9$$UB!m`zE0a4YfsC|TBk>z2EM(Y zPU>49`GB>}UMo{S?%rQC&rM>_-oenbE8AB0Y&(79wpIH7Mf?Bz?EhO9XYFUov-Y&$ z**nCpqWYrvv%)hxTVJsk&s6v&>#OM?=3eWN%Cb9mU4Fj$BJkUSpcmv=_kyjd3w0kG z<^`&Iu$SrN=!-0Cx|hys1D_OsLHVnW+@7z>LGjf|)@k(ycfPW(SbuhLa@*16ZAbQO zyJg?DBm7X-3C?j;ujW5WXC-fdoOVm(3<5h&j=ofM(s!-%szd9As(+xL-Qbk-H$^B2^(+n`HaxcLu?x2KzEyafIT3tRS)p1z|u$})UeETuJ_Ev{goVy0L z^&-KBd~s)roSyPFb$(f}t$?pyF?nZR(@MW07{nBp*IjfRmG`*=6J=n~uC*0YQNH0@ zMCQfAGJ<;$GiVj1MV_a-N2jN>c2NFv^0w}rT+uOi3OARO6$rfKim!e`?PH(=K zMc%qSPUn*7vcBtp?Y>I+IV_#Ck~?wv)k%9a1=#+t3%2O$D8G3pPi!34b9MVwuiR^t zufy{FY*skE+d8*r+swXgb9_&nB+30ECs$axlVncp-l5`e3a^s0nRMi97U(y0ixkrh zFgR~Jq0h7cTl_8IR|#yMvG>1G->mmR0o(d*!S(}eMV_yy$hOSNK47EY6>KNaA(HF9 zBGQ3Qj~;e?bpH1Qn|D~hCR0kGK}JPsp+3{2m)cO79(kGNR#Kj&*NKeqKANL)v-(j! zI?Jsejn4Sb`{d8>*gxFP!`n*qRB zEo|2TI(T`*o^AX0ZM%Vg*y?uRprxF&T)?aRHsR&(N#Ha2uMJ;j`!Hvlly`6^rPH3Y z9myo$su!F^t-M2c^;J*y-${8d?xZ|3cJey3Z>2vGY}sLhyFQgxbTr?-b(NNLG(X1oRn*r9wFWCc3@lV&rAVxci$p>|2_?->#>;0MV>jpAwd}mT{-nsQI z!E|Dn7uhi{_>|r)81FkeV@*R#E>mDyipk{j=NFeXP)wJ2^FJ=r8b23FtybQq(7l20 zNwe#hWA!Hbi;H85e|d3z`ikkQY|%$#p-kF;C4Ay#@-YtMx!W~gUjKIgTCf%U&HN&2 zr@1o#zx>|_ChYG{%DvSmxryQPH^3Hqf-S}3f#xhEd*l!0rbS?*_g-92U|WB?er)G` zf*k}l)#N47+VH%m{da;*we4kccss9rI)5+NZj7(QFZ7K5A%owLubS`Az^ZKUZQU!_ zESsQb^B0q<%Qp{x@=*+0}v4za;t9`Az7Omudc0Fkzjv zYa0iB{B#r(>Q$E!LtUrlPGUf|#8AKj?Hrm zer)u0c95kn#vCNMh^@+}gg@lPzF#OUjDw=;+)`S2pU=_Jg%K8abj0>qM{#Bod2*i> zSp((4^?ub})w3#h>#XYKU1k3culbzhG0rx=N7){eTCjt;1$&p^T&j+7ri|x2BdI6jJhG6}@S^U0a+4}yLyTrM` zcE2Uq$noX2_A{)1ePk|srPE+yO zf54hC!FDy>j#cFRZ3HaJsH@mkpzld}*!!fdAt&X&#BeEH45ZDXwX4I|Hp>-})SHe-6<%FyVbrh#u$vBf}dEI?r06m_n% zP571^U;jqIKxrLE4g}1LqT_OHCzl;9xwdDG8+EYgR;&&L9k87cf`Hz z*iu^F(R^RpQCiN?e4pP{TI6WH&oBOf$VlsYGsceZ}As;a&D} z-CN?N9~4@eP93F%`A%$okT&UCx6Ce???GX2*&%#b#K_{rd~GNH$HhYT@gjT6ShZd^ z;};(GiF1V?d^^=|{wMeymmQ=Wm+m~gQZs;;t`x+Uu|>}G)w>JlA5RN*^iL9+=Y|rV zH=NKKPI&QfLVGyjH9VEHAMBTBdUY(g=eaD+Fw6^@ z)s4!+`~=)c-e0QkC&0pdZB|Vf++Ao6)V8_mLZqI4*LyT=rok!X>c9G|rc6(A3iuWPhG3SHFU{99w$*l?JlNX1aPcb^=eDdnB^Fxoq`Q*|x z=aXAqaxUHN|sdX?%|Sp@!h_pW|(dJ?!xXu zyq0wD_TEQ9^@6mZmh^*UEhwt4XgN_T6hy;G)b0%@Q4qN#t*_1Vu642=x_+;%>n}cE z_|hlDL0SmUzfV;xRxaiGd~LbREgVXvr30)jV~tbuQB<8~e|`2@g}0*RnQt7JXe=L? zui0YzTtHcxnQ2s)ZLvMe7v{wDwC!A)@uFnd^X~G-Qv-gQ)82ho;e%+@sXeqp`a#;{ ziY-AZc)*6eai=uJpZSzJtIof-7asl;trHqul(@rbIqpJ{l8Zk1T>T2peU;PGHS94r zN@aoTax|Rge_Mt%Tf4Gw5yUDBc(iAgmxcnns2lfWqVFIVy5`Gv98|Xssr6&%OsHlJ zwP)l~*PdA)H_BQT=2R^?Adn*4l--x$fOlpQugE z88|ljS=2}C;9op9R1se`TisKs~wRA2oUGkIUVT3wiLEE^bWUJx_- zch3(Q-8t`#o}ae86@~w6)NE}9AE5B(3SppNPakspZ`XOP>6{0q^NO`1(s{vk z*7p9*%M;6S?}JI@Rj9UPRKokzZ6~}>P5Y4d?@4&SoAiD!*&|TdI_JyWoVyMxOP{J! z(PmH{K`~K7>Y!RC)N;D9vL;cNGMv=)Nm@)VzE8yz_p1~WJlcn6hb63COna)-jl?Pm zn3P|KVyaggD+|lE{iGPbbFX$AOVRTDQcWfS=L++CG+8PGImK0mbvXs|lU~A4cRxWm zZ*0mQH>^BSZ&dd!Owc+D?5g|`>`Mzns(UUBWl@6)&{cRl4y8eYo2^|EID;yrbB6Cp zUDRmOAPA(TmE~wfpvKg`qHwK9pUY8TwH4! z_h)^jc58ipx!N#rW2qas(~jx9Dr3vsMDH(r`6?|*8F@O@C}eCCj))nDHz_seoH>p- zq}1(&_h}fC%9nHQl$EkIRKB@-$4a%fJU_8upmg6UKhM0T3-5h%Y)bq8Nz=o$__nlY zpk3)5aIu}aQd$4gXLJ}NzBBB!7O}>u-dlhyu%CQRUD6+gf(GIzdww7*P5P7^0nNu(Pu6<0O^3FHx^54YdLe(H^{$8+X5DN@K@p&=l*3Z>-Y!s_w zkk5QT^T)o5&=40^jM=epKNt&Z3-t*Mn9l0gPFvGr}T-E50D=-#`7HjF(%ORZnJ z-l-#TLjBE+SYJ}_P}>LZY|s%`8K}{LI=1d?xqw;!P}n@l0617zhFwJiVD8)1;7kd- zb{PQ6>&vj)0GN9STzXP#nd=f{=goOnP-EdL71gsR?Sq^BOpFSEK1|*UiaMLRKsb9$ z+71p`|E+6`8#@Xb-*t~ozT-`{x>kH|zM<;8>v99r+7FAFcu!EzXgJGOQ&mAUj#;Z| zZO$cxR#Wv^!)gk#VXK1>L+do~QRf{&EgR~FU9n@0g0H*QIYa(}cQ(^uR~R^|{YW^> zwHvhX?c!pJ6{I!qhu)~=Pukd>YqYxSy@u5`!nV#8K8lD4y-5w6^QJCqwgU$(S68v9 z+40TRnEiZ9zI8sc9mZGBxmBt$`$3Wd6o`#g@Lf+da6tZ1&Jk=gu}s)Z1?6pa?t0C6 z*ZhgTv0#sf`uK4BxYm$K+rwQ~8tB!1jMEPtXG(O(f;lJ_3g*;ep-^_kl58z$xjOZx8uA2SXWu+ z*rU0E`>m7v?Jfmks&@oJz`XbPR3UfB5HT(^O$hc7L5Q{Gwq4JpJxJ6+PfS(w&$`<{ zNb?Dyut|KIxIY#Ri-L&g2U10;U2)Otw#)9f4Ohku#FQ@y#knQ#`(s&B7=+|@qzY5p z;==EPZ8zz+DTvAaP$THZa389H7_%$1&24bK z-?qhsK}dIZsxY-JE_`FQ1v}Raq_i&&rMZoT_uI5k7GzYOm?}#xi_6}aWx)nk11Y5| zLuqbf?ESVZlm!{)s#IBOSzPwUEaUmKempji(vL}VJ4o)gWuYv{X#aRRN_+ZGcBA^oSO z3RBzS!q;uvZBL5#*bvexg~HAq)LHBOv20irL^Q8X6{U8?MX%qk-Eq4hq_`&(_AT8V zIex$F8WIH&`D;=|sa$mIjxLpv^iwV02-}&#CT|=TEqAM4`(UxdluXLi+F8AAt zUbkI#&|_B`c}?FyM&;Vjhi) z+XM+Sm+uxElyl|!&9-6Y$}6k{a4z1k*%GEy0yuXeVa%@cM};>au53Ns1g}l)+I^KZ z3Zlw4s!CF~tr;`#4Dyx5BvmIIE&&V`uwPL_NI<(nhsNT>fD%wB=*1dEQXh>aw z@u{jcruu#sj=BRWMFaNz2U5&c2JCY;r8;bLtfA!}@Gm`(axUL(z`yc9%DM6i1OBZC zQVvyE0|EU9LJ&2i64c)O_2lsy$3=LnrIOP5v9WqfJs$eysX|~z`T2NC}iPXy83F{wOqmd*7fUr zusH-x^1N~cr_$3yj^_{Q+)6pR-&q`KS(!f-fm3v=avZC1Pq9$=Q@yHWtX`Yul&FAF zlNo_pQ?pA`6AKHI6H}*V4LF#i;MABnU7e1mICsS@DUaFIM#QOej_25{O^6CV{}u60 zx{zH4+;hhug;wU5m+H2EyUDq3Oazp@SP^j42^gEQ-%~4vSE~2C#Fg5ewAW$LKt|^_ z$ZAZ@RjoIU79Mkxe#Kd|npX<-FKW3$p)D71dcw0_oH$jTnwzK@@GRdB-c{O#!A?0^ z_`q9*)0n#M^(tz7nZ~YH;zvU}^{s_{dQzG`cG@q(xdL){!7P+F`aoV2a>u8LDe&WV zC+gP1AAL-1aU4?$pEx$Ewdq|3yn2pjOi^paR;SZA49&UHkE_W{4R}TK@Xzut{(wT? zt6=Wfvc1rNJ_EXx29+{_Xn(_lzNJ3YB>DywBr%A-KnuATv@AisgZeCH7IPJ$iN*A7?j7tQbPh31<^l+0!dgU2^+F048A}rg%j8n?KAld=p%wC;r0=BQEJJ3%LfDQbT9 zymR@Ogf~U53uXy#3S5_>u^f+F8}VW2QZY!}x?q+R3R;))|0-y;U7vGNoM`ATQlRSz z>jt$bQ+%+2g4p+-u|j&BbF?ocj<6|??`ebLF{=o(FfhlfR*S8!y&4ZC`pukH;^}!& zr~^ggKh9N@!f>mrYF;VFYMREN%nB?9U^S+>BbR$T#@ub_L_PM*>8g#XXeF{c z+N-odylTL;^eiYkca}88xXx##Dxh28rC~ybGBSGT&DG^=%1@V_?A6081)$=2l_KNE zWq*{*O2sA^&q}pjo~K?4nY)gOUHYpOzWPZWhftrjV~ME>5j{Yt*UqF zPP%KvfMxSJ(9ez(Y1^=N*LDf|)!(NhXz3fbI>BqPuAZKsS~g(X|7kEsyNWFpW42K$ z`M#DH(wsD_3T>=}DsF!=YV%s+XBJi(a|=te29l%aLIX~v0IU?Q1J{^H7eW^kFT(@FL|q7TJWzCD_7p zK~b;T1CHC>h9xh^N2vjO^NT7*_XH-jyY8lgS061OzUi8q4Z!(da=MAIIoH}Gdotb@ zj6f$LyQCpNidXK?%HnlPbvk{@7urBV8In}JWHu_1YVEWE(6pc$Z4G2mN8L$P`WUt4 z!dG+_;Wa^u*JO4{nSxpFgv8c{y(W}TVX0;JJn96>W2$HO9MGUKf`s<1F-vdm_+ph#n^02Tso@!4V`nS| z+;SIS|EjdqzGWTLdCmU9$Mg{Km~9A;7M=|A?Y%k`_j{bLv?A3|)5g*GqwyZ6(_y-9 z4hN0fOQ@`}F58lwW~I%ZMEiz;+D)jxrfAo;xuqM3@jkikro%Vgbc+GA+{@u<4r}je zpJB&klZzA4r90imcVsELtdo@S2X4{oVO!O$gJT1ZObKB zNOI@Z64Km&Q~8xB{yiKpw-){dMQsDIINGgQUatN$yhO3K?~VSZ|mqWp~pO6PuaNco`Lt)Gv& z;T3IRj+Hp=N~hlssNcOY$t5xlnnq)OwnhgH)QH^cLSv}GrZoT;#rAX=HP~o?#_ab* z0#QHg(j>IGt*4gUrJkm*cAQ2F0nlTtR=v~i%BKb%b!+UD;;0*UxKnl)I<@*PWuB&| z_2tv-ywY&0b@Be;R9g_`0)`mk_@iE~27Ki{2fPk))(H4%nuXGA1m5lbe&}Vg;=0hu z^n1Veob@p!1#89XVoLmf7+SG9KzDpl-_JY0)sp-h)grrI;u|q8qOGpo8>bwUkSnyc zSxGRh(cu6CX05ltO>|kK4Zc?lN8_&s3AFeW2B~n^XM>z;3*_|zApG)E^h^I~N zLY5FZQZeB?Ut04G>L$2@M=5ntS~iIAF^KvZolquc?sVI=T~~C26ayalKVMfoZD@QE zO0&J2ft2XJO3P^618LgGLrV8PO7pG{c>4xdx#r)4IwNgr7J1bxm_n_=pta+ zl>#2+zuZ{p9s0QY=D3cbEu=w8{;xMnnjg?5E838?v_rx`aO-`D7o80RLk=pe#fdYM zb}ku=Jao*2CV|>hYS6(Mz0_XZeXTnKeg~T}=I!A}3WiGI!NAz?nJcUu)fuI% zgKfF+^O|W~mtMBI4F>cv!K`pnCITFd?DeP${xgwmP2Ub^g7*@ZArQm`jnd+kkob z<0@obEHNogVR_Sy2E3Z<$SVDH&CGU*|;JVS9!(~MV4p<*YGhE z8TJ6l-EAPS`MJ2@xnaRU`?68N<7;~WV?VnMkR1U%%s}-Szo@iny1`rO>NAGxs%5)u zCvRX_^o+x3aVx?8$`0%Ww3{A<2{M-*6aM<*>PZF@yJrd6N?(Mt?aVG{R2vbUbthvg zz5~_H&vl^k8Q$+F9A6+6E>D=gQnMl9i>0rVGnC27E_JI$rW*#sMjaX7-a6R#Y8u{I0IZrCz;kK?&PI?uqr+ndJQ`vL$O)j zl~9{riEJLQC~dtcD=6qYPu)9W!`*jw1lHt0uNUhNWVSWlO5Ys^1y)g=JZhS~wDrEm>b14^N4>QZKS zrblTsGsO&NY{qh;s`?V`fyQR2p=T7;Q;%Zbl-z)Ktg3Uy{T^c7SN4#}iH3RZ^wfJD(}cy!w1`=s|#xFZUSeo*3-#dyiXhALcSUbz-G9zgnB1aR9dm zU{C?0@fv*w+H&CuiJbN7EPJnBURqkXhK6}H8nq!;+vT32yl>H$7`^UxSQt^ph5@wy zSk>I4CTAOW+L4@+I^Umw+{sS>Oi~vzPn-E^We$)opyNE)5B5vaHT4`YTV3#ZaUm~S z<>T4_HvJ)XPgHM=J9gMg>__(${Tj8mX^`-I72ZJrZ;r z>RgV2lCS)9`>-v9oZID0Z92_L*nNIM9J92d&YJCsBhq&{_2%1%@`>Krl7)hFIRuF<;Ewm2OKYmq~A@rR&-?gPVdvN&&R`&K7- z*e-sW&45)GEa{@ypkAbu{|sfb`_lcIzvoPY)IGc=!p^1bk9LzkSeJhoEUJj!$7ark25ZyvYzM;s@{=6hl8G)kVGb>Uw1jG7om6uw@mD3glK--^b>s?eP4luWdHMD=xyN zs?81kj@)lsJ>EK@MKoVqX;hC@>r323_{Du%rlQ|@CnR%al_SDH>(UjeE?Bb~hBd_? zbLUF9z+MecjrBJsT|+|AA2!z9k~~tWqW1P-wbPc#ZkeOW%k(vN2BUFkAh!Esuz{IB zZc2Tn^B~j>^+_6YcQyf>!Lk42FpN%DlOeQc$n{IKcbZbd<*C`oE=AF77Hu2PWe7z5 zn@fR*oSOGhXFgO;r(smV&Xb)B_}mbb9G64kK~I=ivD6PPXaszyOH~2m{8QqdpfZM# zG4TWyvP-G4)im{k@6``9?}i`7`Dk`<)i?E5Lm{nwrw?kc+H#$)8;~9jdi9R;)Al+M)34Jf z)H2YcyAS%<82-B@XNqk8yLZV4wX7%imkMT9Tf1dj-3LpB*UV^&9T?a(;kpqAG_Ez(LYXze6sd5-pl+U>s}_LHFL>I_Z)>ojf$v3osAi(VkL!4iZ| zVil7Hh7>+ny&9j0@Mo-L%Oca|206U45j$%8WVMnncdArTpT;1L)4 z8!yHrCg%!>$%IddYmwpsJ+0T-o}80rz(9%K(^MHdi0piQc;RGrNn8P3@m44=U3$29 zOR7?z9`xX%TFDjn7!2O;b`*`-kSQ0Qgy;>wihI>*|C!AT@lB{fOWS_NMXk7Q2TmGK zpK)kXLa&?{=Gi3I;2ZqCL|lUWdGPV-POH~I>H?DdJSXKFe3M_{@jHhn zMn;~kZ2}FLHJ<_f!;`HZJ-Z}$;PS^pJPz-9{G>gA3{)Rzy)|gAaMzr6ShAZYDs0sR zd$Jb%=t2Ws^-i88wgEU}z`A%_s1QDjdWB}~Ql|l|eO%$X{7>Hlv@5ie`!&STy0Ydg zJu_RJ)s9BPz%_yQ8d*qf!GP3FLQboZAT?*8wGADe5TI;%d61LB57u_Qs~L=pX|obR zXu-?vEUMZR8esbkO$?#&HFoTbRXKs`B0_k~etq(9eDHHy6lAX0s19&{mA1TTE#l}f zFs2Wq>_th*omk=n+v@|`JPAMO(`ttcA3^-^x2tdb&2ZCWnegFwgS_2SArG?eo97B+ z^E$F*CfF`LRAS5ndGia10?v?JZLm`3=uIyGqs99sG+MHIMhx<|!N<0=SScIQRKGR= z8`YpJS8dM4!sG6=(OYBA^gS%o`*8sy5~ z0S#)jr1o^#OhjBxxY4#8LiT-{XCwoZD-3v)!OKJJhvr$@BfCJK?F;~wx(fBc>z3qZ zGLV`{2={Ju&`3+jsvVz&xlvCl{!STEX`6KX24t}W5p-qU1dBnuj9V_$o>dhV|7QD<`DXbx ztU@bI*u~L@0R!B%)m=E^okMLIHIB0Ah1{iQJ1#UDT%6$HGWMx@UOzc5ov7!fJ6KQ9 z1t$#yCXr(%#^BDAWHuU2Gz{SFi)PaWAH@xT_k4F;Hplma(MQjv`Z6E$0>(TC_QftI zWBqJPoSX;@-#Eq1&UFTS`rwCar{;VE7uBn$FLD``Z6nj}xteI4sZBNL;s$AB4dmp1 z3i?z1;sM!*^o~YvJF;psX^^FS@vMPBp!+|g0{N!McnDkN1AFUBw9|?pQQ`9#WDO}f zPD?Gg4`i$B-o5H1A6i3h|7Rh8H``=~zzltae<+oDP$%m+q7+ z$iSxae6X{g*m5E61{+@}F4=OGbHS3%AD5hgbMNQYlCWkVX&l*O=LY#(F909fYUL-g zUWui~3A%D2ny2@1f$buXM=^xg5)EkOUsS#_Vk^5DS1gacwGYrr3t9MZH2EmF^^Dv7 zpgCUi=q`1|d_e^5wg$HzxQ-Jc)k1DYWpxwS@(ZB}pXMY@f-h{m^^8*d21k43+K2>MXpt_qa=QZdQo6;NUq ztQita6N5D(t9o!aTPEBU_vs;Si!PdPbvoipptDSOrR{JCZv`ExnVMLZSxLjdg5Har zC3cn>9ExAygl>>vXS4KbAUZJr+G;OIw7ab7Lm9@%a&Hq&f?WbOX1fHt>4TP^Tz}7x zSfEEjh2QQNq}#OHz?RZW)TVLfa~C2(SCrDOVG4aiTb(q2H^%3}5TD{j^tr+yf9a*6 zKCkNsi@WS$a}h>QG+@w;F?w^T5HaedF|u*X6aHno1yQ!YDU+aD}6OOe>Fsv}Kw}K+pgJV{1HF#VZ<<<~*9Rs}|tVy8z|wx9e~%gj9tg;GJ`k z(_o?zpT@Su6=YKwBVcrBS6yT zgw(t*)3O##V^nk>D#T-MO_s@_CXH*BYIGb$8RcKAHhH6WT(*zaF)rOn1!_Pp0%n&o zE{vOh)g&IBVLIajk;U%gSZS+{s2JmN)G-JnkWp~Bk*vxJm)c3{Ym1hU+TdLDq z4s`B8cfO3!k8XXF0iSp#@Z%wVE*|-d9reK)jzp9s*<4#&uAec;U%CjNv^l2~>pt2% zcz`cB1&eMvE7^~-)vZ#k@6tuDH=h*Y1u+But=Gf!HC&hsqG(E9S4Y;)8xcWzG0k4r z+VS?D__$R^*JwYi!y#gv?$u&=uqT5*?$OQ@%f+wF@h1wtQJAp7J~nqx9%d4O*<`W} zE$Eti6U^pSK&OEFOqlY`X^H)2nILofB21ED!z}oS=PrZ1xj%&SaP;%I_a4unYj(R{ zFdvC29Qr3UDsbP$eR7#q2^v}+_EnD z+QFyoCW@w}=|usJVHJ}9bo&@gWHGWtBq-t&V+oZG(=L-e&Co}VPISn6dcc+P}RlVrO z!n{S2`i^&-l+_;o{&0GNuje(;E&oOot{uRO?||&|Y#d5f z4uF++!q;>T+q%2#M+G)^{klrbm06ClBJ4gbu+P04V%P~XJV8e~#wX7xi3TWGv>3C> zP+B-fk!nDRG)!?ot8&Rj$e8VW_7@I*r$h|zNnxLt-IsFjbJp_Y3e85LT=eHqQnqdQ zmy^g?UfxfBI%&+$EUzGtG`sl=u(@+imZtW5eQkvcT+Fj!((kCZKx6)g5c7O@3C3w& zc@{jqbZ6}rTbd9V{nfDOk{3NZb+!HRCa7XJ?$Y<5*pL2`6V>1hOD>`jy zckZ_Sr=yB?Gb#v@?r@A}%;%9a=dC;9FJA60DAH*mKimpYA#l}@(Y><+)>V`gf zTrNqVMCuBIm%(-w*&13^OR136<*Vzn*Vks23}UC)M-0iXzH-5x*%Z%gxo{JrQ^(A3 z{5Wr}AbtmBB|GiZk_`hn(LFs$(-#$1{1AjK0v!t@+d?A|z8T+Si(~HK-X<0xpjm_#(w?Hw*QkRuAgM zL&H_d;H0aol(`|%e$9@$)+<;UUzNS+#@y1KQd1za_zAei#~;!m=X_aukaqVhEAFZp?hvnrA0}YFxMDSR7X)DkfBg#1%QPOA- zO!}XO+59vUZ3AGB1=|y70KB|nm&WG&>et08E^Q#?r~~ifXCY&O&Meq3J-;2eRlMSN zWhQTF(18{PN%Y7?YQw?P=XboRSlneGu>;Az?5b~A3srkorMcXe5(YG3HJv22 z%KhG0rGW< z$0`*C5#`a)E++cj$4ubU)h)l>`aB2d7F>tKyP3Y*l2yzPL3MgMGxC5_^#WbMtMfLe!SH z&<)$NXu!Vt9ibR(a^4hM77ds;zbjRU+7cJKVO#8`Rs#{0Tqw#tKfW0?NCZJZ?%}C| z)TX%L4cp`&8#RzKh{ z{%!+JI{8qeS8qn8yHEN+5A(QGeNgH#{nqWF+pgTjjm^fr1Z_Gotv(*p;y#Wy@3T(O zrC10(<#bX{x!?D#B|C_FOChBflZIHX=S&(6#5L)JBsb%i>IxIuOvg5Mw_N(~S zYLHfTQgt~4H(~kZ41cRw%EVuec^R-NUJ@FClU$qPFqH%e#T}`V)Ln7O>#j2J91h_a zNNL5SxuZ9m(fm7EkWslbw9Ls;%iQmE1VT_=w5o|gl(NrV7K-_yrOg;bIU!(fekfIl z+7cJK?ozt#a@Yd)otT)?rr6?yfO-3eLtC5>wZ;A3V7XiYTfn~jBcYh5Z;CBW2$+|4 zrV3G8;zHM7E>DClU_Xe7Ik_peI3Zx(|IyGECq!*=zc*GcXbI@t*lBuAfIeYCOtTn@ z+k;IVo6!__VGzLzXiyZ#({D6uR^1boiS;1N))7y(%<6Nw=?4 z$U*x`%!;pXhFAZe*#O;(PYg@K*`Ouies8QKZo3L?E!g*CVrtQ5^yf|pnD?#>ZE-@> z7WaE&wx9*l%T#Pw7)UDqSSazQHp8q`d5~kSN|mP;#^tZOWr0L{2Mk?4s4@mm3T6G; zX4AEJYfmbkn7&b#dt%FS9ATC3wL=O8c77wkK_d zZLZWH3o<%;Q)Q`TaoHQUj5d}}bz1sVApQ)Q`TaoHQT zY>~^)KtyyX6!iz2X_g3rfZolig4CwC;0@b!=TiNYJwFC1om)a_f4!MzIa!cVIg%<% zEsM+Eux0k~CTkkRlx_{heQGmJ^THsclP*kciwj@3ZL}hW(3kBgkWx7sn)cxOCiLG4 zS&)%?Myf2eEG|3SGT1V)ytFt!MK^a&8!*p9h~LoXQMCOK^kNo{Hisy=l!PtJ&~SF@ zRJ78VGa%=WscBv+U`tftfuyHx_Td%36N?6j!BhfSuP)MM#32}<@^k_$TZInOyL<}^ z#1@E761hOfajI5L7O(W&OoF5B7IX&^$hlbu%=>>SYE7D+}LfTEKrU>TsDxSrnCGXQimfL4v0dAtgg zsjbcS>2xm=scrGVbu#e$Rn&q3YDJFu!E034>*&rX148c(0R#?hAOu0H)EyIeiNf^h za)UI8?Q{@dG7VBE6~a0jkaCSQQTrxV7M2ZYQ7YzewNb5~t{PAWsVF|j1WIQ)A#30K zs)V&IPXNry+CU38K;%!ajkI2_Ircbw6*=w}>_EuqGe!^ z*ljr?B+O1lwELeP52hPLxC(RyJ5d5|mEiEC?(6}rUs&T6!5 z0P6kEHNXU;6ZIhXUzUK`(Zmwn*a2GQbOJvrE7kQ2U+-tW*@;4@08B z#n3>wAoCkhIIw)bg(i2U2HdfqGX8WNFqL2BhAa5HbtIT-))1CMz5n zRl4s-Bm&WSRYGUJ7Qntf3|jfu6PQ_gzl7RpQ1ZW#f*^g6UU{{n&(gEu`m5iO)WG>H z8#+>cAX={r@{32wj5-C35{j=+u;Sq6Ip5%tfKV);&)3v)WK2Yj_8xvS9f0Or62RD-vY>Z8PWDLHt`Vt~w+WY^97UXM`#~+gJt4~}#q21= z6_I;~LkfaqE=r)&!BW*#RSV2bZ?*nkxqua`am(Elr^TmU@4gGB>c>8~AT4?S+PkE$b*I-Vri z?LY;oQO{+JYkXj7=@dN$40=a#;n>fPtOa*);>;usHxyKUuQN@&ZF@PSw*S_N^i=XS z(kt(C^tej4s|U6CcTPqUC7uRk;GyCHW)wIY^xVBpF!h1-;^S;}!A6;;4?I0C@@7RF zAlmsa3V+qjvdb?&2nZnRR0crkQ!h+%V zOeqe5YJVt!<~W9)Ae)aQVBFO4Hp_+qvHvj#qBeCgTAGg-Jykm)bbGW9-WV_(?%5} z<~}3&sR)>OVzDu6kk*XT?EU{p>-@XR2Y1>0R6^={Aex_b8glV9?6pWpEDjQEJP5?T zf+zqWL+|K5F*7m0U_j4*KEZ4VPlt>J($c>{{aI?9nXfKP8<09l2-O?D%o&u@7o27A z0fh`BKHRmX!ew2S)>U%T7)5DAjb3%im0}64>;T z0j<16mL~&N_A|DGyb`041c>S%Ek-QT(ZK;<@IHZGHsX;zJyEHI=s^h;Er2`=QZEUyWAUkm0jcs}$AxcK zp}s;8284kEf+m({4>Sh>CHHNP1)`W+{IgZMN`Yp&R3m`sCXsfgq>cl5kc3T5G-m2c zi?ce*W;X+s(>tMp@+9=~Qiug+kcvgYfm(TpGl;G)RVtZQvv=l!+EP^D7?L|XwG^F^ z$_YU3p&>iQsJ$Tc6hNHVwE+T@;&%y)Ko;NCMiVn7baGAx%AigoTAJTcYooOG!x9)~ z;z|kh!8V7Zk){;2CgmQHq6Z0aJOF5ZkK+M-c-BngB2bEtbO@y&rL#RD#I8os!Ye3` za(OLf))-AG>fgXo9M+2lgyN%JRwzalyShp@rw~YqmG4V{rt3=)t$8S+=K=fzlFe?A z7(K@6FYg=)8Od!=Cdo8_*Wb}&T{bQjs>Pa6&N~8qcA2kHJ27jJ7jxdFx>}v0 z)jory<_<@q(dV?QX-IGFbaV=8>LB3+5TYM-fce@<+DJQVXCO!}7aiHQ^ec3o6VjsH zj>bhyk3eZc&l3_ zctFZO(easGVp7o{sePrhf?vQk_?`PPmkuMSWu_r?ow_nR90Q{CB*z@c7!LHd$A$D0 z)KD7GazE~*#xUA_g4|vMMytGZpN|2#@?^&?O*37HR#5&a&WupB1)abWFhCUr2aN^0 z6|Mm}_f*f*lV|v5NRWCZr(?i@At$2wX$m(0dRM0biw5brYaE?h#i>)aeKSaIdop}M z-}7b-(z|<|s?@gV&<=_1YaMT7R*(UyxzFVvg6uM&b+31r*%?~3|G(6|3!LOfT`yXR z-8v#iTaO;st5@5W6L+JZq4$ww@pUHIJa!@3^vP~QB*OOWOwZ1+^XN>^WOtM7rUilU z9(m>*f@kjaL3}}rC<}-V?}(s{Agm9d1s_2XM#WMOpXTwOm_ZzCJm8k-gX~orqo7XsWPQo4M~=#i_Qt~x`>JFp zQO@Z1vi?OcbUoB#;+JL?Q>r9ObOSC}b*d0Qnp-oBVd%H<9lzAIMC2GW0_2xwC~*Wa z171QQWG!I7;WTC>J1rubu2ZerR2(2~JU+tCz zp&Q|=*Q#~ia@U&S*EN0H0*YO*or1r63WtssY@guo@<~tg1eVBw`EFZ{;CAlk zvxeV#*)l>w!KDRHL41%!Pgpbc&DJBV7rv1zg4&B7rG9G7WBZoi-csVTFr%P$Gx=$G z^0*0r;G=y8YFwM(m^H^5Uf|^Su9k!TGv#hyM8IHJVl$Lf zWaIIDqx@WNIgX>AvM_~vX$kLUzhi9~6Dx(6S2FcaEJ+D|>E)HMt3b!>27=+|?rH`R z3e7EJBFazZo=g#>tIQd~YvKD*%nGiRgcqc-5Z*cM>bn+@Yp|r>8Gb0=pCN!Cr`4El z9A7$JuB{t7yN?Lr=bN3j2YM;v#fvKD@gs)}4t9!vlkAB<8meCcR1;cOVfh?UR zP4VEja<+_}$}cz2lKfVFP6iL$stqRKFAcv=JU>&)&gW6m@RNB#rijF|k^40))6JH( zzTCcM#!ux3Gw7z4akre|hibNf#1yj5z>n=vsEJcCF5V!p^dd(BhG9S2X}$5V7yEC5 zRrX@>(kBvjjL~ns{4$cwV*JOKdPMAy0pYPJ6kaw)%WUf3s8>c|62ES&Wi%tDgnxc) zzS0+(oPPFdYsJ4_tRFi17s4kBV1-A&)L!d3cO_hQ0KsdoOMRYNIgOD)q22UXS&oAP zQTY19soJt4hPS;H-b;U%>%EZsrSSUeef_W|LEzfD|45xLBYK(MWB6r5OGKJRv?yvc z{I>oEhb1mEH*YV1H2l=b7Qy7lt_0ZW2d)5Sfzl%xT&-DLtbfvxOc!l#3BNT%U8>MZX5S85T(TNBEU}p_ ziE?%@;g|X^dOnB?CGbDPFTHGuNRNh}%fFOCwA?ra*1hnCMK*Jau2hemSTg)lePagM zWXo+0@Y6)L2-vbyP=0CWl>iaKH?rU1qoHShsJSSmI#qs0%fI`R6^tO|;Oeb45ehitP*Wa9>Yjv>uYQrz3U(GFn z>qGgaonHdOJilz_m%!;2!%xk(@)mU{`Fim zd#d~P8-DBLm)Tc+%GHM7Cf=HhXaDY}>@ob-%P+J0>b?8-8GdY^&qcI%&ox)?H~d(B zTW+DNuexgQ)rKE8@(bcHox96hTbM>Cx`}P@rHSfqRb=97Id-m@){JNfB zYB!X5)ip38{XFp-xybfZpK{IatDr9Z+{-VvZ}(I7?X5y#`nmniTx|RI?%#iP6)Mxu z<=@OLw)^U9uDNCpES%pr^2_brd(~C@_QB5iz5ZLd_^!TYcNK)8IsI-na?9=ByKm2K zP=@lfz@3Ve<~grJYk^YW9TnY5HY7Tf$Ba-A*h&cCv+>NLZp?#_Bh}ZwxGF__;f<7?@*$ zUcZ7%%li#KZe|NTdjT&-&0uoDZ>9J8HqqggkO}<~MJgDhk-;ltD8JT1{pc&9-7F48 zAg_P;&+qe0Fi44tA#jku&uFR5Y-y}CoiK!(_j_y>e(b~)!Y_rD^lv1T3*78Bs^Qma zz(9U5kF;_(mYY+CpC<+sgR$~+En5upvX!~1lgO&mZ}n`M$p%tP5qI)avu_a_&GGA6 z-%`hyu*J*I6Cdz8qJ&Bh{*WKreGA!cq8~T1g^(kPSBLnamo3o1QjENW%WvgJGwcWw z;h7)JZ)XZ2(p60SSk5gZ?|B-2o5(L?^}|oK4|-Zscl^-ebmR1Oc*WQ7Q!^BCJhY-h z{J0hhQO^jO8>cN&*C1M;`a3CtH{897#VUg9;WP0}BU%04#`2Qkx8{dDinxrMFzC1T zM>A#YUV=>}!aBTu>|_gJ)pK=uv1<5fBU{An92tJ;W=o(+r|=jFzpVX1h8L8uCwUA% zmHyBdIkt=`#N@*C)%%d~w2X;|;m2wyw17884S!DrIQ3z-Pz>Sq{O`LBKeV$2mYR5C zitzR9cO3R=VUtWhbg~6(R)QhCoBe)j8CMS)e%Q#IKKsU)QP@QI=6RIOgDHFE zis9#GZn4R!l{uRjqaW9E3)wC9rs22ppLkwKZ^2%LNq8;iyUo*X8h&YJOJKe?Igi(w zZEh4luV;&`x*Rfo>19hCZ%wbrPSi0?Mq`=sCo^n^vLK8M2NtOhDvA|Gb3vh6StH3g|T}^DVq3<;d4^N?>1mW!~`1TDHVVJmi9H zI)2#*C8STNF&;+$GW^y}m2odK6530B6)QL@eVd;)Ge!8&BEOhVdyOXcFOFc-!=^+^ z)oq!%UGq=BIW)?b-~=QNVQKK5Jp9(lFJmvGGW@oYEyJOdpSn3kCYzH}Q;il@hV^4F zzfjBeAH$EExrOjtB+lR&el$IAbyPC?yS-Ld_6Yd7)VJ8l1`-nWYq@W!MPxu3ey-*g zvrWP;6WJ1TGdL1-!=6Ki-)h-1tBbA4nZ~ihjZ=nS>w`*NySzMk#;`~;6kTeKLzS}E zLTEdDlJ z2_h(eW-ubYOqNA-GfaiGCx&1NFSn)HISM^Y$pKeIQTl8yL-IaWc)cyl&TTd&&9HVY z7fZI*3489Dg=>GIqzeoBFeLdd*tfUvmK$F2qGpqdPqBxF*li!`DEXJ~vZUoC6G@i- za(hxgT_RxCE^u_1}h=h-syjwc>nC94JOhM|iLY#fnptaAC291?QGcX}y* zmZJqEuN;}5o5JBRWuX2ylz9>Tj^@GU4m$3m!K0XfDu(J8Dbk|r+Ay!^r9}4t)r6Nb zX>O<7D=?qeQzfHI6#R*_sHJSkNtYZYX~_d@W0gPo4VTkTSxcU^KC<4nitHWYEdMR_ zmhe~FGJLPy$q_mYTV}@qTGm!@9K@k-|6MMbOV9xh+p&}AtAC$MrmqvA&&X=Za_<^J zQJOF1qE0u0cA`OzU{OmO5M}!xa#5$-Kyu3xzH5|bxP5V%^hl@lk4lfvs|9N=tU#Ub ze(N4<#95Lt4FmBF&aK3kY>E zc-sVi1b%b!USZUs_!e#{)EU7eTXj3%MDpb?=eF;qBWWe)7@)Lzq*?Hy*Mk^a5S?)b zZ7u7J4^FmfHm?OKSxU71FBI55{>M&MMB0!og;v-RSkZSyvi4{FXXZ}^u zvWN@971{}38;es*)5tS;@^Rb|v3zD+%JF;s-#iwy=F)O&+(yKNR{x!>+nxaKz5G6M z;0R|f*ZR3{84^+5BeXA@KKEvaJ_LlsZ?9vRJb~vG?cKX~OwO-1c8woF;Kce}kHlx(;&R z2o)HjX%9gcUfNU%v8xv;j@8ZOpr9d_{RZ-xz};W!6fPB; zXx4_HONrgW{(&9OT80&S-=zE$=Ipfip>uu_!U5JJfV}^XLL29N6kb4jroCDX(B8Sq zvZ|^eNBIDI{9NUUt7~OX zFd0^_eakk{=mj>czmbneTCb0z`na}9mPPCFiLkeWwqo1Tw)y6{3ab|EGz6e_SZ*mM z8Y+iAT<5C1oxQ^w6xvfJdhz;_rG_BXTSW~k-7D8OX6&VYSmji%s^6BUK9wk0g+=SE zqNR|)V{zWznmmC`TKzcj9hBO3Qb@S=K!wI3lU0DQ#zas;=&U{uTPX~2)`>e&E7&yG zjIwyHT|R-6&5pBPK9)IWe#8N+y3Ckz3Xx_HTeL*CnUB`HDk9Eh4rl$fdinp%YnLG7 z#QRdgyl-b4ecyqD1jMkJk4YD7KA^Wu6=`UtU{v1F%6>{$T$NTvhuG=MWhJpJ7}9Nj zCoMrpHY=Xw77U#;gh0RS=|d@dZKG8^<}62tY~;CY$V=_Ja=>!}YlI@XvK~>@@Zb2nk@_8yD=3JH7;03vp%1x&{NGVTxmX1h+4aKkcj$|lM z3R1U7c;dTLmf~q{K`mJZ^3+1iS+(2_FKM+xW=fSoTKQ`orG|8$x9jyzqnV0j!I17c z>C;v`$t@@)OFvI3#GJ1bXDno=`8|Ww@{VsE$yg5SRa2v@1=d2!=1D1Q@kFktb%<+(FBt^}j%d{}&lMR7C=s;hdu{n#|*Z6nEJ z)AN`dP}$R?Ntz!LqSzy+r_&|x_n5Oh-H3b0W%Xm(ke{_H1{u|tN9$`}{ymM9bNK4Z zg(2zk_a>UJS@Bd8jWt*`Sr+oFikP!ZUGHaE7{-;MO){2jBej~ZKRr^1o6!pxgVhWg zvdD%Z?e@-;ay;2BC@0H9o^pses~j1}m66_)$&ih9ZJ2pJimf&B?4I*sX2IUshEkYy z`3{s|-P`wAWnQmR^Br-p$!8h07p~3VnM227c@J6535azT5N*09TNy8TEllbZ%QHS{ zLz5kqZ{eP+Uw;qF+Ey#^9Kdx6veG6?31V46t_UYpiAue;W$iJV3!MF{ppmlTXq@%E_v|!BN+y8Lfi{nN7r7FX=WCiqnRq+9a7I z;O7$*Mw<;gAUC4X?F5uH%hxN@&XS{z5D2lfe9#{6wihi)pxdU^t2OPYaLpiV7l-Vv z&cwdvsU$j7j-$*_-BBS`r4crah_!s9%8)9t$M8%25S!)-NmY34T;=z5z~Fon^KQ;J z3)-V#RhWAFE+tlb*~6TjD>2!0BL4PMJtxs~z|x3T@rK{mpGK`WvG78S7xi*;AVTE5 zTXKoqZQF9pcRWXQ@Dm|33oEj@_U^atHpE&x>_xSocV3DA-!(4B)GaGGEusb5EGRbm zbnTIh(_*0Bz#}dQhSyO(a>v-*{x&b9~%m_N#PPbtay*pP&5XF z{(?zlLG#N|0%>yQd7%wHLBzqZFis!D}iR4L*rhLV20|8se<468DsC z`;VUs#vp)CM1YJ(7C`LSY>WvkaBbd8DF`Ex2Q98j25#SRMqP`a%Hm#RX_%7d&1M0K zq*3Onbh(iCnv@*P)W8A`rR`GcWSgW2XHeV#6s$UNk1B3!C}x0yRXf{5VNYhWYWdW* zxVQ-@SaofCC}xfW2kZ8>hogZLwyat^JxG#`KlghMNmp?LP_XL8_E5~&dk?f~^~|=o zH~|!_y1qRWHvt8!mhRma7c<9!gLUiM!!dL@up#!dbH;d4pY9 zoH3+SU8B^xZaMVGfGS`V%1Kw`6mCed^pm7KP~T~>M77akkhX3$rCCR89(O+|na!^# zxtg^lP$QM@D^$4RB#g&z1dQmkPuTZt?K3V!v-wKu3M=*266%#b_cOi#0sljCWTH_) zjiBs{J0p;N13S+k;*D34Uz^fKiz&Lx1jKoT?t~M^fJ8(rB0!>nZ?2`Vo!;pc;j)Fh z?0TJbFRP0uajbOl=$U52keQ9wQECZ5UK0f%0(fl%aE>HeGZMgh8t_OO(1`#VjGT|= zVhX}a9BtXHJz@QdN}|h(XLZ&n(cj})-97Kdi66k=?ATh_MYe=z)9DsV$Lr>UuJh%MnBg!Tdn03v&UiUXm&78G>ph1SXJSSB*FR)V-gGMFfDmvSQ%3qy8# z@vX>k?}`189x%kz`x$nG1jat=2FlYRNtR*N+8c6FXmfJu!829r$5iz+CL2VyNu&kb z^|UM=^Hk_t30{?uU%|t2rCnUF%Bi6IC)lDn{5(y{6I}EJ3pN@-=z{A9 zWVBsMezD%58AiW6?x=>?sx23AqmY`!d%rkHm0m)&Z(mi)q7G(%#8?02L3lZv_D$5+ zZZuQE5MS?&gYfzp$xwdnMHHC1K@-Hd@uoqTN0@A?sVZifa4O36&LGqyOgI&_&SQwK z_U1uo>07*xv-4PXcsct|Z0+|e)`AQHKY71j^m2e#qyeu?174K|ygChdO#~2s`pEqu zKovkI4LF|$Y@`8?rUBhF;6fVEO9LKD12)ru$0LA_T@RiOURyyAWkHW*LFcoeMKp3Xdpm>;)9XkwCoF2F#7duBuK)lwP z=dD=UTWeT2C}OYK`n#Q#*E5BG8gF3B4riDFq}*I>34YGbUDcY`f0tIh+G>d3N2KtE zXa#1~h7QokqwjDFeQvul4qn7Ap&&n#62L|TxOBsMdLMLHAj7oyF(3NmC^A+NF2$Id zt=WhC3{_M51XUy*{~ynWjxUnJ&XS_HBhjVAgK5B81Ypm|niI6n(@G5Wwr+=#B?CKT zFgM%|hv*b(EY|9f4D|s`s^g%N??@##;7AjT4U=*Lv}LH!CKa2Ep_*6+yu*>;azIfc z0ReukAMoR5vv-^0o~{HLqTjf5WZbg{x8QBRrRkO-;?k#RAfoKYqm~o^mK{H)bEZN| z&cvYux`6y=2zPT^+cRx@7rO9va3*=imS~u!f zIa7yi%!EdAAVHvLc_1NBd;s1pVcHl&n&Gy_%sd`#b8=Ch(hq&LJGad|rGLBI+dV=5 z9)ZL&wU>iu62OnA0nbSTo|^{zL>lnCG~oGZzzfoV2h)HTrU5TX174g4yd({HX&Ugd zG~neCK>FR!fD36rFAaDs4cJTr9!~?>D=AJNOas=^fQQn6^)%p-G@z3PoKFKb z(tt{vLP=9$n{e`<}JvP*-iwIXmjIK7_bD; zO#^yqz-AiIKApm`mIkax03B~Sr-J|r+Q@>sSx_$v+RTF5XENy5vY_=WsFMY4WI^35 zsFww8Mj(!iNb9cMmzpF!k_K#~0T+%n$rD&Z`|i7wt_kJUokMVcRZpP=FC2VcDck6;J7Rlpj7*8ATnvIA<$1&LrnjX zv$}qs2%NCI?oRLyoT_X+(vSsrgnEZp7mg#kWMEPHVFnnoG#;&)Wp`QRHgFsCMIol{ zHAZXkZm%&M3ytGVM1`cUbZbAN^pml_E9ioMzwV#A@g;0W@gtV~A*F0qML`&r{+;X= zWz~=VeoG+Cld-*q7ocpLVXrJN`kY>>xotbLK5?8Xlwj-pnN;-kwlv`F5nyr#vA$f` zZb`o5j3?<9lYZljUz>H23i>Mb;Q)`O0qDBEgoGUzB7nWD6?D*-eHm3XppWN5+xO;` zeK3Mbq_TEzYP@?W4OmYD9!Ue>JCZZ#^J&0F8UWXltkO*bE~Ei)Jjp7Lr2(6109=!= zqT_P=zTkir1b^jMf;gZ@AaN<3`%+^GT$rCx={V7iDk-R!1;MjXCfQ7vz07rb104%2@ z0oZIy0Cl z909wDeE6IWut*bfLkXLD^gJoDBFRN$qdLbyD?uimImEQDXt=Z;6}s5rRT_)zl6#1} zo=;@-DhE0MN!1Thh=5it%FMVe2kBt{cmS;@-v zljLsIYH7Ce=MQKLCXo8`ZM4f6E#z9ldjg87M~q3fRQR#nW)KY8|5(4eK+Y_2^h$IA zQjagTJm{TyAAxq!(QGtM8j`E7Y>%uRzo5-PGnNhZd&8|a8shGd zMxx2%3ikB@2*HA8Rhddu&_v5f_JK?+oxH;?TH$VnwngcTo%&ZI6W$Tl`5Ocp<~W<_7oSfjxnD^Zq=PlXdA5XKIzG2@ zWbR%$-xej&dS#|FQYfF*CQ@DOt-2&MaW+>*Dlozx#EvY*&2eEFAt+1Bhm0aaD$O>< zi}Zy-@U0K{amd|mhf$G26v)d&m_F**6b4Dz&IB8GhQT!OJKJY0&FK%3VxwToJ2&!_ zmQgO#p>WOTjxHqge*V8CBzcO3oU!+)xbTAF^`4(=IXZ`nrIAJZ3*lZ*dU=qR1dsx!)^xy#(12p)^CPvtC1f*5L zBwBwBiOZ_Oo1#<3ZtF3-IuK2IlAH`wrL}N-LktNv-$=r;Jc)%S-#cZy7I|vCZLA;w ztUK-gaW}nj0OYCtxz2YS0LxIkhsyzwr^egu9003Q|M;7lxgMo8S~nWqx%{x5|)=#Pl$md}19XHYE~$1t6@T`Drb7B5WzF z68WtQ(cD83z`n1HGVri0lQfJRS76tW&`(RAL)SxO)-CtVV0VHhviT;Oin|ryVCB0h zXJbibzQHROB(9qEXzh`gCT6lz+GKG@oL)KtqclXn@hc>w%+&&xL;#mw-@;}?4eu=D zY65qbJlcoQQDdjqXG|Y2TH=v5gvd&`{1!6Mnmpxa`FDlE6uBaj0RCg%6%^zVn!4{h zNxkPTMy8Ht#0)uw;3$$ZQaVqDq|!l8reJpv(0sK3QJqDaPv|U{mDIXuF|Ej|N6#aS z`%{Vx_W+UCCV7SvuA<@D1Du>JzsIm#cck)r4a;q^d=lY4!w(y8qtdR>)~{7)eFbO0 zcSZ(m)fklKkjhm!#ADv6_{`<##EtQB`^K_8fnfhN{MutFS&H=+=14d;<`Z9vk`9`8 z&kqwiNu+VNCqdNJ-%>`BB=jnwB*{DyVTzxUqt(Lv%Mg8OBPMf)x;Pj%6m=1jI3h$o z@vdAVDoc{+U|HstWRd#Xm75!QmKe|8JH+NaBw*Lk{Hs^G1|7XJvw-)1Az8djX@3tk zeIJ zYU0gTj9M7TzV$ge(&BL#KrnUi!=FpRj6xoHg$|5GDUUt9fC2ocoJ0DWa^Z?>!P%6QWVX@kW z$%q|YJtG&>OEa`cqx8GEw6wD(X%FkHPoBeN^mFs$(~Wx$qxX!v1Hq(FjVPgwBaQ0v zOfmMZ&JQKAzgO|ai&&Pg2rXO$%-cj&+ zNn8d&8d!j|ZruOG-mJcE73Q*T4+bY(D=KYn|E7U35ZP_WV*O)e^$MBN-5HuJ9m$0D za2F41&DtL*hFB##uT)dtrMAverH^ar;>zrtjn%GKFNop&qHI4+QO%$9x_#+hWOs<@ z`W``Iolo==R+nx32rZ+|4sXUBb>jOtanb7Rlb3NRCY<$c__J&LhSN}P>7E@EmxRwijj;wmnC*bm_9L&qvl`x_^%xje`Q+=kf7pJZ#< zSmCmVS)LBERH43N3~Y=e)O(NG)%##FtiL`454~d_JXh~sG(^$;G;LyGQf$2* zdQ(DN>1xrfe>qzq!9Li!Xp_CW7xDhLBhu@oh)sLLPj)ONMtuZRBBYOGctu=EtpBN! z%0)~C1;m8pA!hF-&eCUcaeIRp72gvEn?w@HqW~A%eBfQn%tl?hHeu z+_O-xeCaXuT6xV%@qqs4@~_FQ%KGiU6s5V`{? zRR21rH1%AK&Mro_1RdgE%cr9fCFzbX5e~?EiAZ7M^RYztT@s06I>f)8Pe&z6(j6?( zQVXGy4a|3qFJrQTXxawZEkg>uzg39}yv*$j8b#xH+g@FN<`f8^Jr;!c+=E(YT2qr) z3;}pOgza|kXK~2_u{7<=YFs{%fz&(%u{*~BAJaqN-A`rnU4YIK?K>Rw~<9z(q5OT=%_MnrQYKbmva zWG)wt)DS)2VAJyuHcOTsF_iy-nC$DhPy2~z(kQ+(h3ANC@&qcP*i4{$CDrG>Xad!t z)(xlUutdd5)&K4JK%VAh57ThMKo(XqA)WnyEuKuY8|!!f#q$li z9~x!?juYFt3~QQyR}9<;@~xNPEPY#>L=@5DPQzvB#)~_t?tCrQ-j!D8vaiwOxw`o@ z8qK8{*}IBX1ci%eC0MzLS3Dyw+|m_^Z+_LbnAn=&LK2dbSo5p5Mf74NM-+C_koM*n zd621m%}+K4TL5@yxhwjj8OW(wJSQ%V7`E<wK*;nH*WtD;}N{ zyIkJ#LqzJptQ}Q|y!mz1#6Uary^>}s{rc7>7Tk$plbA9Og3Q>}H5vN+@TgY0!;hYV z?*In+6)Y4ersfl=06Ws4bJGPEN5-gQ{4Mr&D5C3nwD!U8r#?@|j3u{%6{gV%oh>ZE zUueb7*N>z#R1vYqDxQWP-x6wMm~&tjx5yb{Zofo@#Ol1GD{9m}a%^4l*tNFPf#NHJa&p_B9&m z%ii5I?ff609l_4oKL@XD#~o~b3ESLctM+YPIw*{~KrB^teKa8)9*~hq!jzz3)s1hb zglYx{y%{(kAJRXl!c&ah`_Zu~#LlaFG?Gl znUnK;IDSS63btuQOccci3+`iP$Cr38G&6URBs&5*HgB+0EvLA+d=o*-G-51Ln+B7iZR(FS8FyuH?|!^6{xj z-BaZ8lfeRQEyQd({>gXg`~E|eh9$t0hP2l5X@wUdo5;9*%uRPASav7fk++5mS znE2_A?<|)>Q!R3j%4VB+tJx$SZ#yVg$`!oaOn!#rfy}tjxi8VVpm@bQJ$(h|gR_ym+wavWI{81%8QR zw;PAKQy%GauVJm~)mq!1vhZDbsf83vi(*iOB}na5AFr@Wyhnr+L@c9nN=bI0v>`Xf zN?dq=C)Ty_+J15)IWzDgo*SFwY`iRwQ!_b5s2Z`})r*TrrM2ywz!_f3q4$w#^A%?YKm=c{NAs6mz zVeO4!SVCSX#0uFMtk?DRy=P45Q}$d~sQ$y+q=`Kj;EmTP4NI9Hp#j*f55G8hF&h$T zQY2CRZ@Hv&1wTo8@Ctsk%VPBfBQQi>nuv+`$onGY5fVh*%O|07BuNgI1I$||fj27c zB!zfu*HQ${g_#*`{-E;|t=&#z89Ljstk`a3XCmTViDKfq6hq(fpdTyp-9$j;+ypUf z4#$)*Y!~i3rVh2}MTuqoz)-&WViR9V1QXW}MHDeu$q@b8;aoB*Pm=6l zd9WyGBhn`~o6Acx<2C~T=T)qO#dxVi>NO>1E>D(TT}+f`xwU@fZ(dqDx!N@RUj6SB zqVJUDm4D4_uq5T3S1OkpKoM2lqm=PeYlju35LNcYcL2A0tr#MjxQ#sKBV=HkR!zj< zwRn|?XqvYxI=xjiii}$;@&wbt%HyBYg`)(;=+-xeCq;WvgFLBN1PH*Fs;tSsA`b74gmZuH1Q(vH#a5uEOV;-I9WoN^2zZUk8YzKRJ1Y232#0?~JR(I{JKi5@o z5S&EijzmH3)k0+)M)kUtRCgRk^#GZtUpQOY%k!%(eH{pGMmK8TSV6M;yWc8#IA|*W zLDT~hXeOA=FkG43)RW4hB1>5>Wj(j|#^b6fa_cgZO`tQ~AX5>l90q9ks? zjxC?=%(CbzHCdzmDw^lY(uz9+eBqYL!;{+KTsOt>Y2Qs{t-gJ>GWIMjB6|W4o~?YY z9(Ph$t?#6=MbL$HE7qi?6usm3Miv>>8_qqBD5U3Z`AZbA3d)>wKUewk@q}}aA~138*b@F$EpZ8) zdswC=YZJdj7O&7<2VCX)Js%fYb~_X%jad3#K#Tq$v#t&|3q#%t=%xk}~O$vF9 z9gRm=dtaSeDc@IaAxCrkmerNU=^re+cnur)<>O0B^FLUgURrFFr|>kG{4Sq0DiFfn#W!A?T*itB8q~1x+IzJ5b`bU&G>`ee+G;f#R^$-Ke@7eHM8Etw<(I!B9jm^wU z!t7Y(UDTnZPDYX<(`^|H$qqnX3r(&p&0M{&ae5M0bdb&RN2yD%K3psRmrS~Kx(m*o zx{K^rEM!NxY$5wD4fST}@7?3*lWy;0mxw;kTx+|1M^3vr`i3NHf5Mh>&5wD^Po4JF z3f4*h`d<;~xUSve87dxpC=m8D5zMO+^&dIyO|f8G7@*E+-^A`TX7_aEdD^Hb!&{U- zMG*8S3%*fCuYz!o63t({5s>3xfCo8uG{8RmOb0;$*bpRwB{ z8Z7^Q=5!BLQt|d5n{nrrxa9kW`0OYt)&GJN?b)IiFlzBJKaDQ9Nnu;AerDbJ=V=wX zZh)J?xJv0?cd&gXvf-92Fho|JG*RAu9p;9`NC~mix8Atyjf2B(eEyJ15XNzBfFZvV zUn1XXxSx(6Y?duJEW>!an_7jVbB~rqQ0=mK9fqo6m&MgcX%G|>K%#+IC+M|X?djXp znndE!`AIdMJgr^3vNUI?sSRo@NmtNCO*O#iqj2JgOLZa6=9k$TAr02&$xp^Z<^bcA z>(8IjSY9$jw?VXeo1RDMSFq@Sf{BB%1;dK9e_;=anFxg=iLPz6?2X;5vG%XAM6lC( zrSvKdlww@Pd#n+Uc}okpm*-B*t{j=2n^`eLRx)Gm%xp1%Lee9~DsTS_ri9Sy-6rIr zmYqQz#k9o`!G=dL#EE^Y#%}T8}I$v{WIOxLNSkam(ub%3O2)j3J`+e1tO58XLl%Q|$F__GpNyU832@s1Z$^FlsC}Ud&FbE%ECVZ%EklnJHKCnsr4Ds6rHItkBMZay~gvg$5H)I=4(No-w4+{HA`i>?q+okDki&zx6&@|J(BtBCJ3+mi5ND(~W61 zEs3vxE1AG;monXX_<=B^TEy*gxL*#29Upmd6kTvg7cMu&0))F~{5hCJlk2MiRSu>y z<&N6fClO?q9biv*f9+=6I4tiIh#ZEDoBu-vkSTgVzbZ$2!vKx!J0(e{R`gwLhaZEB zzx!*}ZlmDz-11cxGR%;U%q}e>S7(L#C0n&J_3PUy+I!LbfrBB&7^pMvdP)`F{Lb}& z!yN&pZy<$Lm0%DlT^jON|L$BhPOUEEofGKYUEdL@6I<+fX^$TwKaP9w2;C9Jm(}?u zRg=^&K3q4qIJtbrY1uc+}Dw2n&o&w7upN;cYu4&+D1m7$Dz=Rw(4on4SMnH%?ZV!}6 z5)#=wfD!#UZ=CGom|(Gw7wph(F+Jc1NIWkC047p2QJ0>GTtq*OLc}j)#=*+Z(j81E zTg^ViAT~|mieH&_J3eh(y>2f|?2N+&5ETL-?NpKFqow0%Gp>}hT!eA(N%rh2)*(~L)l6wWL4eVYaXb4rjIYmDw38Fg$ddm(HNqZQT3Jq zW0z1OZ~VB?P77A-LKiu!K2dsxro(d~hYgF8%)$~7}tNht%T^>ofaCy%*iU7!Y+1oHZNrKrIXeEioXP;b1R$t#9n%kgJ!@A{XlNGzq%8P~v znU{;>gdxF147HQQlrkwf^}oZn6maX|nQU+OSSc!zc0KZKvPpzQWEL)-+XHx(6bEtc zmbN9ro=2SDwj7XyZLBWh%`?M#wM8;!7Ylv3s|%ODf!sv-iQf1Ey4x3pp#!tHS%AoD zD~c5Fu)}7jye;FMF8mG`Qo9wV+0Z{EbEN5iCs(7L^P275tdlk zSS+qg&Pl)+9xvstLY&>qMNk#YP?+`mDU{;_eg8$#*cCaBmqd;ODXu6O$F+719U!;~ zzm+n~E68LdN)ym!_`D4vBtbw-JUU5s%~>{Z!a#I^z&H4Snf38jV{&*SjCvr+Gv{Yxe8?}L}296k}ZI7#i=8Q3YgeL72+=#9r&e~ z?@F>A)Lo>Y%x^qLg-E0_(nh)YXIO0gxomBltK@h6WFocAr=l{nNTdF|Tw0ojl%zd4 z4JnzbC3!s4y1Gar8wp~ZSHVBPy$J z3=EbLLLs*pm!U6CH%`mUg}668jYLEy^OjO(-V)XWC3+H^PhG-YaYWO5rLvq|LgjnK zocYKGuD_ta)zCys&i@!(?M%*@h2&9WPTUL+f1^#jB+2zxQCkT~G!5-p`XnvUrY5R_ zR`$aLCvmO6n&M!JZAbTzXMp@09NDw5dY>6Wnlg3)F-w=IlyMfg*=r$Tg(2v5Ve(|- z!0HOpVI51#%EW8P(iKP*(mS%7{zYS8+-)(IDwH^2q}mK|Y!X*;Y7_8AVZM)_*+2m= z&wX8Gh_Lorw#5i>rs^K|02NuZ zan=)hfSu@IJ(B#xLZPRS-&mZVJcHxDh*Vjk=(1XzIz6zpqN|b&`im|1G9IwS#wwg+ zi43c!WOd@rRLj;=uLa$_yS;^Ys&DD50-4)RcwsT!v{P!|-TZEa7fahWS`Jj(tOg{y zSc!#t&K9+S+#;By>yfAO+sT_wDA5|+gDEC*fpn(EoPlB!m$FKqh~|UROLqEoDw4HX zV0uRzFTLHzz1RlD8RRdYg#N`A(pvo=ScX&|_*Aw`1NW2n8aIJ=iO;4V&#o}8v zCXcrQokyaw_+ZO+qCHA&)$?a7?aOtsRg+EQi!~G!->adZ=vocj-|JE@`yU&bwIr2*?{0B%7_ zR@n%EqD@ME2D`CsHz;Jxm)8!6+yOj*ZYXK*3+#KzaKomo*!m%*4+@n<-w-?jqQgFU z0z|ug%Cp+BxQUa?hV<%R%%$sxePUFu<$fyGY5pzix|PadLtSRfC*$!FrMMQc3`6|2 zzayROnCjO^^I{8{E$PJf_6VJ(wLnAsoyynh%P!4@BRDn$yZhPuyw@*aofwdxiy)IM z_J#;(o!qVNxe*k9do%(CAJol-UWlNJcH{sry%>fq zYlKLEJ{ChQU^4=E=lOUHl*`52k>^!+`d|c-C~7SN%sTHHL)7E0M=5WiU!-wr9yMSYOp@|kWZ~_#ANr0|k6Gdoa_y|y&^Nf-hDFO^vHrYfi-`zCtm*gbLF3f`u`aVz#wHUWMc;^$js!R|D6-u=5@sB#>^!4D{z`}a%FBw zqZKw|5f@juB$u7OX@lP)Wk6)}9h;pLMO~5fT^oZu!$unHyUqWqeYlwMNqCRo1R?=( zrX1mO&JYI2aMLYE4e@PULEj+R@<4LJ@BCy*dG|>=G0!#xM2{3xBiho=zHBer-5!}- zL_sDtLBK*Z1f(nu9|!LQiInp=&WP!f-E}7erCnqsF%D^v>v!Ro8~Shv`v7;F;?o#H zLtOdwtIN&;h`zL+>O^O-rW)UbW&>`3;)~Fl^4K4GB^6q5kT_VAO6aG|m~weo2+=%1 zV<^O9v?YdBk7hv^vY^MZAOv!0TnOaSAOv!0&?6CO)ruR(a5%&*52^zkM{*H34&@?n z9L+`GL`)ZOKNxrU07k&aX6<(pD#9JlftPUh!y0Co2FoK8fJBeBBn->oT;PHtk0;mZG|{S`pqg(tfw|%A;@;c!SX1JY-n8`V`u_jbeW!ezzVRkNJ^5 zjpVk5T_<7f>JQMAah7!s4?LjmF<-YJCt#yDkrSjOv>U6W`47RKlD>8ZH_phq4XM?C zkW|Gr*D9WUdr;RSltrVl$~(W1R4zP;N~;7;ED3gE-5~ZNl3al=+)vt&<-)K$sP*Mw zw7m?FHJks9{JDwNvCwl}qGbfoY0~%h%_sOBo4Ac+}&}x>{o<}cH)ts9MkzxyGTX+rJDxpon&GJVo8QI>q9WmsA3G) zgFn{m45^>Tf!d*A-P*yyQqUx09u6J3)uJ)1Yo5l&KBMXjn->MIW$P%8$c(|T>c%!ugo%e?_3k#%*v??Bk#(zww-Br1Af2ABdwU z4E=~psoa8u%m@$YlI*?3vdEF2k?OY!646mVpKX)6ar3evOXb@sp&dk{bH}nR5~cVG z6G_8blmIZ;RS~agqeRA^fu@~@kyLk7l73N*s!_xBY7VX5GQ`^R*z@(ld0rZqGeVr4 z(E80gsF-{_oOz}3xc<;GtZ$yaJv_E!V(ih{>s!Mj1ERgkpY>{Yl8Z$AAwl|%Opspo zt0A$gII?=&5Krw#6(4T@K$ABEiUj_?@eQMR#eZbZzE(`6T_R69I}L#YyD@VRRz^(L zE#E~3IY?f-|4uJV$S@$lD9*$O~%G4(QQTKCd?v>~QZ84VlSN?Nw_)YAZ6LV?dmOWq^LoaV80rmneHV4ZBiq?EP62)TL~^S# zo`YL%-5i|LU%xbw_1~%M9&knO0+O+? z$e~(@6XI9wbX+XtrlsRIEXr$_6uL{{FIKxijRVW}C3K>!EyO)z+dQj5KK010hYeA# zEwRbe3=W2dpw^+@JH0JktaRRXgbk8kYmO?RU7!L(`K_W79>tQXA~wHlTYaZ80QwckVf@_OUka%)BOL}r`M z%Vk=}hu{fvP|gq;UJ#l#MARLEkkf`7gifD_ZO#F))LzJDbjm=Nj2A3aZGgtB7WZmW z95yk2|FcmxgYD2T1P?3^2Jj$a1F&iL)^_5v*q(}`r~rhbDI(u z;i5BPTMkJQm3he^ls+@mq5N9E?xb8=RO$wZsOJ&d!)WP{H7sf?hWVw*X=~jWcqR?& zHXo)gZBK*=AQgwx0DU_x%DRz+nm7$d0C5(MMDU&aD@`WKTw(3aYD19UUt#kUu2?y3 zbtS1T$chPYNwY*wrH9aBvGx8GTI|Yc3zf>)U8n4YmD4gVovl2V1tp~g`{=&N!sLlL zkra6@9yr%pT@fHQ&Lf~^Mj@@m11FCkUvAuEsUUVIwCM69qDIhV0QyI!CS+nYHi~^r z*RV0#KgCALhU(LJsXW?lWH*ewrJlh}lg@0Yk@Pe0+#@Nr-%iT5w?N3XGd|qGoJBwn zMWEA2XtBlCBbdDO4%j0R41T~C>tsRaBajtF5pKj_TlLWhu+VVXwA~0MmUtloVCNCl zdS}7|bvm1R{7i`J74+b}8PG#n&?8yU`7G$sEa*Z6;!Fa(J$A33O8Chtz>nvHAG|NO z^h5dJNAkhv^TCfsVBPkb~g5Vnb%v3?}1!)ix@I2^VF;Cli_xrx$FEENhwyDtN z*`HjFFZz2D5chP+0!F@DvP9g`r9|Ax1rT>|0mPkK07!yKBE@;-BmfyMNkHTZ9P1cx zlO>{*0hGYF8jV`_&Nbx`!%Nex?eS(CfX*9s=84~6r(U_&k!FC%4f~K8LrB=dk46v1 zwT2isf0LLcK@urG^g3MNh*vYL$G#r!3vG=R4bMZ=BcLS@*4gcZx28;J>IZZZ<@7F- zwv23bv4FCICz29+vbtzK!nIA-jhp2 zGF--dFy@Gcj28&H*Rqk=V9$}|C{prThBVd_wBExw>5>TKD3L<*y|GlDl1k-&3+1gz zbrd0kA^Ot$VlsX)=%NJ@B1B%#C!(?>i4Kv)E}3!RP-8h_ufCt6=mQ@fv7c=1mzF(LljO%L@~Sep-iwy>@MMkNH_Z;mkp#bzZ}3|JHGu;jGuU!cB2S49_`2V zRuQ}88{%90?MsDM6JLn1_Q8ILeS2l*a@MSNjoVEc)-L_dP%PYBPPIDLWGo^gFdyoN zhyh~M=3!D6EmK)+@F?LntrS7b8XAUVx_!xUgDIMK`Q@roX1OZRPf`0(o9sd=Yai|> zoY!?~ZH-oTi=4Y+{o3yi#gocNI%?MVT{|_CA9?9Ols-d(vsIg8s*>bM{8(HyX+Ps=xrO3 zOD`})u>R5QaujkN43X46wq0blKZp@3hSDEw7n4mkU~Tj9epqD5EH5cIwcbmEv?&L~ z*6oY6uP;w!84#<_6;O=5PxRy0nz;`9?0hc6PD2b2q3 z`myjIvfECc>@GT4Y5!qAmVBq_(`q_R(E1a9v|T*dQD^1qANNCo5z9r+QM9fLas$|t zeRU$;?2Ft>O5`b*_6$rt46Aqlq#utX4wfn8x7#fnB3=7rKjfZAuCL{wk)3v;sDEm^ zsFM5b#MAurP<))UhWL$h`4qEZ)0bG=y-SBZ-kv4iwLiV&_}%8H;$8pDrNi%cz=(A1 zv;B~7)zi9tFyd?f*~Q~!mYzMCV((NjL^|>3Ddb{8uSVpX9W? ze;a6=>2VQ9FOBQ(2jNOBC&(GP8|*=OLp&3oCvSHD!Jjt2=;?PviX_Yzb4lqWJV|=U zBs|E4>%ipo6kJ_J{G9}yuX{-E!MGTaA}YjQ+Ki>~R8$)OTVt2#+|S+ti#~Vlex}T@ zWetlIHWHMsyCm|&bcnz7cd z^?xPkj%9A>i%%kZS+L1vNU?t16WpCC=5qc1`lfS*S2ef<=>P>?!c>i(`q?Huy!j| zl0f7)cZ1WxWkIv6$H%9Z7M^^3X?|t;xctG6+V$7%8oy4iB_y);QK|#m$Oq)=HSE!U z+y6)&?Z+-Xmp6*j_O83{+^GS-dk1=~^6DQ@fM@hq?6&Izqs`%%g@gUj|0O-s5H5*FBevVD*J^QUW0NtJtQjimAo}M)0jVVU=nAk zh`o6ib%&O@>|x(5$oGQ1ja8oW{YpidDEWr%O9cTP&g~L$=b5n>&=1aVvZ)Jl4+`jn z%ZJ=$MA0!4dn9vDMVYYkFnjN&u*S7*EUC$`I0|d4NE!!oWUBfsFMUi#ZF0;r+E>BXI2~7-Fo? z(t2m+C-LYTjP>);GZRy@bMx+=&T|zu0?ZYqVC5bl`I~V{mYna8QnC_Uhg|_5D5?RL zJ<1UTvG={GFcf0_*%amq&-kMepOy?*M*`XbH7F+wx+ekRyeXL80w#XvqIf-kgljzN zD`sxUWw%LggX-@OFMPOReZzH*Dk`ZSy)*Zx!du_8sb-hIWm|`Z_d&7fNn8J=enP z%2e6JGF9i=87))~deK2EI`IE|>KgF}F2uFn~2$;s~tO5FU`FiF0JltNbmo%585r ze=gOpaDyT(mi;QuQx%!wJXPsJah|I0LQ$^jFuU^?ES7z*V_37_2Mi-f?<~(y@bxwo zAX~%-V^PslYF^S|{CT&$1tU3(6Ou<7cds_=%?9LT{l}G~Bt^gH!mKRrla3J7h4CF3 zdpAtt4s{YK|3nZUO%3Os>`2I=^-Znu8S-Z-BHsK$rI80S&TO9hIv=6zc5^l&9HIS= ztW3hWk?)P?k^ko8iN+E8t~xksN3)XF>Ty@aig&K^r9+Okdr<+$q6z4uZGIksGhF6n zbz1`?hI~ytKesWdi8nqxax4;IKWtAW6Z6Jk3I|?4GKFJl5=7m3kV=-54xLE5a>NB; zgL$&5RgPr98@!i*xkbw@ln<|c(;inUsq5wm_Zq}lg#jhr>TYJPDs?*BQQ3k-t>&Da z$SM2PS5XY_>u`N8ml_K`3c7HAuz49?aGh?lS3DM#;4y=CbRn+x6dWR;VRLef`#C+x z#~*QYA-*z-ERw47PJl>8Fw42cc|4RW!8bKfe>F8RymdUuEkxva0{oCrbuo%`OVV5; z?LLxmIbj6JPGM4k8HFNTe+`9_WvDxY3HqTUx^^HDWqTR7Fp4fWj^p-VaokF{`&wln zA=wCWNDpD{`s;!i&bhKHCD0agdJV1w##`;qqxwo3Qtt5T7=fXgXP?a3?sInA{kM3joXAq zlI?l&b}g}aP(9t!$}HC5WL7l7P~xVtSW$G-3F6%Jxa}na^hMxX?_A^%J)jMUSq>T- zBAobX>MVgc8)y116r!&Yh}pGtLmIuGqhZ4eG;X--W>wQyguD%}49S)s`HG5KvnMl2 zW9=8dqO^|KO94s4{4&)#G#E=LxurJ?M)Of^_Rz#(P9MKn-FHSx8`BV*oK@dQ4wXRU zh7&A#dmdqQBP|hw6xKVrdf%?7#SkYLA191p_HzE-keTMM<}oz_nt9uMSiAG5ZElmq%tnrV}Jx-N>+j7uXq@ z@!%sO?dH!q$6Am8&%NpJfQJs_Rqi$@`vGzUUU7AceMs1l!S1`rs7wehL=ysOK5P>G z&>NIR+wGxCtQgD?6u8E+0ii><9)U}=${myQtGLBN*{i)**-Ya0j)?If=h~5L)VOL( zMlXRLX|8=Bp(0GHX&Z%M1ElAVH3rCzg|-E_i(TV$t(zN@GlpclBrlH_voS(UL8BT4 z^_1)f6Qg;QO0`?oS(XKx3 zK9V;DN|mQRPlLs!rahV=DNQ>nr^CYudu^Ou_KJWl@3WARR@1FvM>}s&)9av|6y%mIg&@ZK*7Q1v~_w-Rm5EIZfnsJD!xZ^eIYgd4%G^ z(fkx~?|;be04G7k$|3+sbU&TnJw(-@oY=rsq3AZytg@LMpR^y?=iQ_0O0oHwSV**L z!Wdo0LEF&ryN#r1nc4v&g9QK#NBei^kWn_rR#k-qka&`dT-H9DucxhI#e%zi=u5Hn z{ye3FEm_`HXh}+5C%qiR@aAtWinpbMWD~TMBCqTW$U0mOM7gNx1hp3NMk# z`RGz@Svr{rr24d^Px$aF2_tp`Vdb``gBdbW`#hNu+Rd*VZM;~tbWa1MNwW7vk`_I{ z1bhce%I#KtM#>_vef{>PJG7|i*Z!7dQreYKM0yUjmvS;(Blih6TUGZRbB$Am^xJ?luUonc77@rT@aI>dR~ zg*HQErGLohboeUU2viOsM_~pFgoae=eW;1cjTSB(^)SEV5V3QVDU1wI4O|jNYHNL{ z`qp6VHAEyNk>REUyF#r9>yOh0Ws-|7=eJEXD!@SFZBXyu>N~Qypu5jtNyOB|NQ0%W zYT5(UWVQ28WO;hd-J^wR8m&>%FTd&+7?p*UP7m{4mQ@C*OsP*|O_fy3|4eJMYpNb= zw5Cef0KB-d3%B@T0dr0q6LFd^6SsZGhD{26>4bvqFckCDQuB-SNxFh9YgPF5tu&k=4xC>4TqEYUdTN)8;J5OMw#={x0TgiJQ@V zDIc3`wHkQYowTZ#Db1pN0dP*vSYP(AAMY1h@_<@&V~D;n@hwjp>a6Up#XM49c8yCI zNlHym(I!eh;VLy(-_RWP`iijg%7EE*I-=YlYFT+f`!>TMdI^YGvd0`nQtFao@e<(2 z4AZ`Us3eHGdpWJbk#;dMwN$Vgmf7XG%6aPY67XU(Zb`ZH)#QN0I)PYW&OK3z+1L>J z{5(>_dS^}I?I(~4JAatN0S+hv(>?A{7u>CX0g!BwzBhof{zzQOMjSb5euL*o(hL*K zIHh3xpwvlrR!(z-KF)My@f~3oY$Se`v6?h#=O@Za`| z=I4)3B1M_RJO5dk7$)*a=&i~z0x8bYH|OH!l5&)?;D#b?ACo%#M10L9Ta2Ff|hUBeu%i;&kJ*A(!Sm$!(I0$NTu80YvN)Fzyt# zY1YJABle;_U%(~Z5Qz{n6f4$*p4Pz2GDO%Of|x#iC}J5;iLLxys*FDDZVBtnjaKXE z?Bt>$)^0v_i30Lgg+}OYPUUtQa|71Gks%>VQ6yx_mq;ARAG#LJstCK^or~C6R-dqa zDHl z3c^TAm2#I910F$1K~e+WP%+%VO8z%~AR)&?(VN|}*AXZCA$^T9_|(Y67_e1VTFrTT zI9XY!{t#Ia%IBjU#!1^$6W${fY}3nz%E8L>RhucLzx=TdRW8-1UFJYN5g+ zG>D*b%hA2Tj8^cRH_l}MiW|*o03q>rEf0uG&a)-g^MJVbJX^980fVvJ?~NrmH{3x^ z3ktyVXFV`s@Ix)bt@q2AZK${Itm-d;s;F8K^P~Vn@lQv&oWxsNWczqYHzJSiMlC2G z6IU7u?FQ~X4T`*Yg5RO6$)uUQbjZ_aIK;Nc?E!pN-0%qO8sz@n$>pOF`l>^DL&o!-}PgnOc|y7$WZG6Yvgttg`DP{@N7X zjAqEuw@r3lnM)MM@|0SsHCS29dKyaMI4*c`r%rTwV~BbppTt1HKC7eu*2&_kJ*C&q zr|X9RCZ`RhG21vjy}AGcQ-sY`)fpdhh-0{f&83##`ckru)RO*A+-=g3-Hqj6*>Zn( zD5bv>SM?sYwe9a7=XU!$nMQvn=Jjn+*iwJb*x9aeJLr>g=@ezO5iHFptYXl;_ic)u zSEf3s!%w{J1b+6vi^K0mBw{wFV+poF!LABAVA`)B=p|B-mI(ixjiS{BT(kkDtG@}!xJZFv+8ym7k2hS1CUiL6US-WX2 z!3#6s2AG(od+2&YY7?YdOk(t|iZhTQD6hZH5LIm$$`QGg$rh0{hanADm-Zd6t>{l@ zmJJcMhanzeea#|v>G+1|*3YsvrD>v5w0-oX>u^J`>S-II zn>a`FPcnOvcQJ^X;=2tvw zxZ6irCtj4VN$;{pM7&JIL|A=sF5)5lxy(w|ExnWt!kw?0+had$l~NBY5&V23b{pl} zZ1&r=Hh;+0i?Rw59%%?`2W(;rIck%$RC}CqL+9uJDmlX$DPPE1x*bs(N0$uocV0ma z*amUKHV3DIq@`m4Iowv27{}ARNDv>r=&5PR@k53KM?0$kdEAgpHD5*MgcGdUk&~Q^ zzl5q?TDn9ToW8-w%5>*pWj=*kLqMK{Ee1BB$dc!>=(q%IM_|&iRUVZspDIFL zy051~Wxf7RpN~bWif-3QTGge`;j?|xZAg%-`u`ocLz7`oiYqf55wIggr%BLy1d{2d z?aHtV&RsbH$6&&VU8+I6jS}^c#ulb;kvvRgc;aUgjAO2!W*i-u*o7f9Ye<*GtO38H zv!+SaZq5D{tMK-Pz7A-aOYkjN&9A>{}XMI(inThps0)dD$5 zDueFT7~w7wYg{#}2eP#JhR{S{EwX$$AS3#JzWS&XcT^Q;SV2|3g5RrQBM($wls`(g zI*+iK>_qnEZ`0{_ls`(?D41^6To?)?nh5uWraQ58uQ6YKD1Unl`KtXA`MW{`i&|ys zJ$g1y9r^qRhJ@u5d#@q7&0i*34Z$O6iYH-)-d}2FtN*R$UL9SSeTLM^ze1{_?DwDZ zYu1G;;v0~_46mlZ2kX?~Ljy!y=0xS_Ev~09tu;7Rx!st)EL_tQGINGDz*UC4u94>? zQeC;@#t{GducqigjWA;p z%1bb~NZR`iY1ZDNw2K#s@+pR>n!iSIG-QX7c%vLfWvMlOrH!%OMBrLnR|`i(jON$L z>|`~z{7LDxQDpCu?!#7B(G8m;oZM6^*j+UwHbJ7pT6Fhr!?Nv>>%f0#+1gtv+%O&W z@!ez{zC%%&^Op!EUX@W)olAxCD%{oJxLbdlatS{!owZqc-X{G?2P4WatGq7}tbnA}8DxbagE5ChZ+@f3M%8k9k95~QNcwhP(}%>Ogl)daGmJDz)_*6L z^xf8+$0|uy20!uAhoapZcNeyD?cYlg-nT8)*^PEQ z3un_{h_TyM%!NLEovRJ>GM@59sMhfzeVz0-KGILZA$0OoyMX&E>_J>Ztfk+lloDMx zD?Bq-Y|Wjpd*$?$Atnt^2MV^slZOql)cRtxhJ4w>sj7=h%L_R9h-*< zf7dlt|J)x-ls}QZ=fR^x3tK#1%D1~4B8T_GEP>Bz;@{mY*ly^XWQWYT}kMa=iHl2!ml4bwApu`?^=89wbx#2?RECyuk}#Un;I!IbHPV7t{;_4@)lm&JFNom zWH0;(eVCDZQV`euu=b?Fqe&@grDzDJbDfRh6LK@kQ17mn=>AdT{TZ85m&EjW|Enrh zzqLdi7}ayB4hx?>#Yjq@fl{!u_vCw$dlcw+l>QyWKb!`dHOcvq>H3#k>o^opQZ`Y`AQtv$h6`3$BI!fY*Q;m72x9sWf zeD5iJI-8}NW+#;^a8m$RaSEpWpplK~0Qa4ivNd217S= z>0r8QVvZk;f}C5^-1%{VaPfK)J!UvgmAW%dzoH5zjEd{`{}*S16BGavqID#O%;H#^rjT0R+esLdm5rifS&(m zDv1>RR|-8wLEZhN%cd zR{l+iiSCf(1~YUZbLv{?1i$GC0;~U?AhZ!>lP^jt;M})T#bwJB<~>EV$T+LoDn|a> z8^I#60$^c7KsVECxIifW#~HK4FnE0KKNI5Lgn3qj38x<<=Kc#DkC0OcE7{s@6=!L* zJY0!6C_sw7lVH9SSJLPm8dxNiw1xYTpy>B$5X*z8*g_-GQm+!AF$V;A%iqOdQXLQ@ zlwxSs;egQnt@QorBjvFH{&Ev&u6!S~@3MEUy%XOFlH-A2Uml}L{Dzum+(zxcJW10k zhhJ1}^iF4R!*w?8xRBt+tu%136rHDcHA$%_MX;~?8}%?5k&GvKp)f7(6Ojpxedaqe zCSCG0c{9c>`N6&db{5Y9Tk?V_RT9B`U~i?`F=J~~-o2!nA+(69c*at8BVjImFKQB2 zus49OdLI0V^3W@q#@~tRG?gw&#o8k;?tS&URGPx#%8Pr!73C4=6*rRaqe0u0wynO{ zCk*%<<^6IIGIf6J#l3d`(XLUNdx>ux72Tnp_r1h4p%bq;KlqZ~2QjShL z-8nqlkWYOuTS4FHVY*3!+GrZ~DfPI7)AmGqJ$ZIQf)uX<>Z)h#iW!2BAneu0LFnV< z>Ah1m;ptt$J>@bNbYO?Mh%<>*61PWr5{+Zc~jbOfvEplpJ`AHEXWjkK+ctAzqGgSW13Zx23o1s zKt&khT5eTq&{-ucZYuQ}2kE&2L_(gO(Ww(VBM=_~6O!k}SB|>mMlEsp?1*1;RJ6$6 z(QJ|6pikD_-6_)%fafpOQOfLro32@AzT1Qa@%6Ow?DkG`N|}pFNs7Ro`w>WSRxpQb zscoF#{@T#$^^WYJR$2m9Q0rh@3-F*aOk)W$9!DA)N~rwEJ< zfx)gZJ~HU|TeS*$2hpcfR!JO*Q6r!XJ_ExQt4Et3te&e|SPmNGYh#Zj8&-k_NmEk} z#%4OsqFyqIU%hEa4)(TMVzB=Fb;_MY zf!xBb6tXn4AYo+5*|9dajRy@R0LPixv$#lXeLeX0cz~NvwMaITl5Pcy%V0GzY`I3o zAIE!n^Qpq~%BT5D+;}$Hi{a9)SaJgWqq~iX&SRW9rlI`t-MvsTYx|RwwzmXrwb9Y( zimVL!maWN3Tr&Dr0Mwy#M!L|q0$!v#-FZw_9NiRRCnTZP_;5)p=6Z5=dS+iGLhoff zC1#0~-y8^s;D_G+@a-mYG&jt<|o*KNZ_0vxM z=qrSc2wn3>@knBlRiISn@s~BYBVD@n3yYPKX~f8bL8ga&4)HIjeJN=7jtBklaQK6;zWicuk;xYk zXO9w1*bO?#2M{lt5>3`dAL%13N;4s2*6CU(m1He5;=|2{E$W~x1Z}u4aWQCfIlH^f zD0E8013`m8F9i+LqHV+z`Ha}v=zC?3&AUxeU8M|lBlpj`)f&|?%K1|(Ieez%F*`-o zG_nL>_q*Jh==a?@v?YY4$eR43aC^fomElU2!utqXTb#w3XkD!19(M<4#6`a;MVHMu zH5Y9scD}_P|2LJxJJv9Np0#Om6)U%J`4G5?PJpYJ1XKXc2)rO~l+7=~qsu3;EMx1B zoCWjX0;hM-w|Y&b0Ufddbh>)}z;h5ir9MZ!O2Xp~YM_Q^NGrG8kD4myfxGRpc^uBj z@25IYu)ll?!%!Eg?swvtY|MkgYW4C}RQb*k@JgrCB;522rD`VVzE<=ee9?Nj`NoUV zw;(x(23+AK3D_YUWSE0Ahbn#GSWC%4xWfX_SiC!v7FDPPE~z+%{ti2MaRpnmsdR7% z05U6cASd>NTz1S)f*SJsJ(kG^#bP^(;_!h`@#P?h^bpRf;{=gO?y-0i^wJ9QoC+mR znL(@cinY9JQ5HV(vfuVScsmf6I^`i zVet6UFQ+mzT^^ON%qPA{_vFoxf(2q8+v%QxA1KoWhyX7BN-6;x@t2wsl8QEcQ*|Q3 z(?hRX@3dq}l8SZcV>%HK=YYJ<8IjUKJUrh9q&e(zgXGEvJiGF%>m4HORB|G2EZ5!A z0p#L5pq+n6NeJ&By7NIwj#`NB(j>GGKl>p~iX7+dusLMM_UPVo4mRGW>UG*jd#^$j zaLjUBXpprd&=9Dcgz71k^QBi~1d|gaGj`3qopz~c%Ev$;o$3Y$!xV3uY`d{c974`{<=i3+ap5<0sBxHeTQy(f z0L0R7r6Su>g!s}K)Pg~Pf8No?iG!egn=jFQ9l(_C(NGdj0z7VMheLf+gCMa|3#0d?Qd< z`Csd!h8=9})NZX3Igp8ddwt~W4I;Gy*@G*&vg!yFhW>Yg(zy3R<&eE@FFRx?3L=Z7 z7%A#H5dl8`J4z-FqPhT+#Z?9pP-UqCom8HPfK_}0Scf$+lOr)xU|gSifxG_O{wzKbY<42$MU2o9}h=wK0^?5#(vu4T-o8iWV5e~FuJ+F3`Z$jhz*iQL@lLW8xZ&pvSW__A>)62?8<%^;PEt9hfqSP{@tm|31|(X`ny^FJr|g!=!>tdQ!Nu%mF|6PLOG{%ndecq2D^ixdC@- zr=Z2ZNfnGiH9K85(mS#4BnHo}E`dS2*y-m~5M8XgTkgj=yEp(OP4+K$cku$ImRKrK zR4+4U#pRVsap`YCSrla4@*8qT5fUlzjnj^ZUr=dK`J}?+9|9Z&p~TeDAk^l+!$QFL zxKwe{DBMKf0tayMJ(&dbY(4P55~6EC!X+f=d$&}}NOg>$viN>b4R`z;0!KIu~Qo}?O+J(;Oit%{7masGoL=fsw0 zGrp3PA=57vQkvDJ5pd<@&GiWA`Hw3V8AtF|>~ur21VLqwl{M~szgyvc#qvAi>33{ z$tGoPusm27R)E^l->;7<0*&=h9X>H5i3lZC|CEw!x8NkRoHl0!DEkI7v^CrNuR1v%=Ug?Qy^OlO?{IJmM2z+!roV*n0*ZWDkVrn77S zEPj3yfazUu$~{HED*TILx{H9ay*Ly!j+?9EPDASUcf$C&IIJhM;;qczkzF@LU}otH zV9I~>&O3X~`3n5knDeFk`I_n8Ky*Q`@TGJCuV*NFUu1Dt1hjcW<@=3oYc(IWIewDM zityOnmz62+M)mK|msIU?6?7VW6eG~9*1n|rVFa(S^5D8;WN z(0(3hdhX@X5I6Wk{1BfH5sg=%t|rlc7w9Rx(zI3v2B;=~d;qsmxauyT%zqWUau9{2 zGhOm5gGOl9C0F*RU7>^?QHLW{xhp{k1Qx!QN=WZ&iW5#F)I8mGB?|5{i9ln?Xz6qs zyom^xlz4HAT>KS7z*tRU^?blywUCJC;i$J6tbYer<hiYY8?n5dmWHKeM1*nQ6B#K+rw3U@fV`M)fs-m;P&02}lh# zFjpVT!gfWo!H(%h6DuSa2Pv(P+*F>=YCvQ0J6W`B@gUKkCKsu~1jf*JGqBR0M3sR) zGx)uXXT8&bJVpwdtG`r;;(xb=YO#o2eI+mo-_OF5^N84`lJas*T1L_YuN8-`;0Vyg z|H&kQD$4GrD$2BEZIX->QUbmBgDfg2ItjE&mqgk-BxywCjvf#wMCZHfE4p-Fw~fZ? zCA*vIC0k2P%0qy=l8J8$i$q(BqG+v`Vk~dT;`K~smjdMoi1Qs;$i`*!iLA*sUJj{H zrL)>Xwy=)GoR(Jtr_h;&r-MggI#rB{CgqDjTFpeXK{r=0+MsWcB1T{=c4cvASgl5@ zg^NI`=Qe^S<%@tQZfy(I!Ykvmb|9>_M`~eu?W`Oy(b-vyS)c{8hd`^P6+u}ca91<& zZAO}__H1_beFlK6oRh`unXEitz6acebF=V`*;cZZDnl*e1JuHKS&(OFL9KER$V2C6 zQCJJpsBS|N5NO2UC3q1)v8^a0Wnh9+nBfG9jJ3rc6y*14;8 zODh^QWU0IZV&U;w$gcj(e?+J2ge$!BJGa*O^;?NriuOp20Enz+5=#st1xRY_0I+;< z7S{0R-WZfQ2f$f+Vis%7&VjD%md*jqh}cfx&i!Z>zAi!7&h(+f zSORA7Np0X-By@;19HuBr^kZ$%kWWuz&XvX~LR82?O1dqHZ_?1NByoAmkV-4mKqPJh$9 z29R@4&Vn{6pmrohcVvYCV(=+#p<1kwu#!xHqNlb6Y~fH?@e*JPPs@S}N|AybftDim z_+lG>&Q|c}d0KXnRgRLH` zb4}uCHXR5HnMh$ay&asT(gC-c1)I)JkVnUpgO?{nhauufDt7v%K^Yzz+JT4p`0Eom zkJ*glFQo(u3r|m_q~~98%44`^@!^J=%&ilQ!wLDjV*wR&ww~G`Aajl;E+y5<)apgGSnU|%`kX0xtj_o^X<{n zB59B2K0pDOrH#T#4%J}-YjvZTlHdVKVW90~q$PO#fc1Q8Is#IuJ!0C19uT*Vr)x&=c?MwRi&20?_W)UG57yd5TD})Z`CVD!Hul;gk|+T)xCwClVFcjRH;Tt#09nigJHvUV_c!R( z3&5^q!kZ{tZ;3bf8<>HWzcOoj)^+o>S9|ZT6X!r5+-xcuP3eu-fUj>p8N2ry*bA97 zY!cG!QWZy&N$*|ZmXfgcAqazQ_O@f7feWu#t4Yi%K9s?jWJ6cd3)y0@R*eX>;_igT zG;^Bf9V9`;nOCTx_K<1Ld;-#W^a?fK9x~1BBp}tTSFEK?!3=$S1zg<}VCUc~RN<<& zvy|rGC&ur+e1$8uhh2mA!_`-?x%QxGb}hjxyjY+uwMSipo{HxJsOajpLR|wS{8^wC z+oPuWvx(scPAve3+5@j)vc$6m)Ixj6G-o5ht8;IGwVa8Wxog513*Fl^8o1gGB%*7w zCXlLj={guGfyQS^$kUW+r}WRYq>~eM0hPf_YMbEbX44mM7qsUxdDskZH^Bt?X`r{1 zNjGy+*PuA;_X0WElQoyNW3B;_onIgo+as=F&oB=da6_8~OX3CA{AOXY`wFn7O#x*@ zAVt?^&Cy1*zN`wiSKrl`1YQP)Zv`+pk|$2GCr4z_eh;k2i>OfVJ2jv$gh0 zhy#?>_GoE-rRUH^H-IVpRMvbX^{i#`J^_!w2I!@1D(ekwnkb1vfWUkvp%j%~Z}L8s zw1hJtyPQdWGr}29pImK_$`7u40$b|`2QdIGWrEwj-x^Fx^Au#RJy>fKX`u^{7B>Nr zL7?mI@0i8jkr+&JTFmW|UB?joj65!O6c)uBbAuIbp z!XPa!0n%a;v6;g(ZzlxgzyvTW?cve_lK@U46TsxJ$9!eVFU>v$a4s|f&ftdeg4hIL z^$ml%SH~1)p*>t$a1xB!q7y(Zw}B?V0J*==XD4cvYW zQh+qn9x*LQ35Fa*DFB;q586hHB}@U#a(lQm_axxa#VNpv4rNI(sctRflq5a^6~Gs> z$*ea}X(lCV0Sfg@N-3(n-bf{#wuCC6yO>FTGeVVs0d}yJ)@mlr%t>scBpj>&wRl68 zirBhsgT~PcP=?y0wK13$t^jI&GayNvz**W1JUI_hpw$fnG8#~d&&isPGo5W0vH*7| z6W`{$%{CdtEC8F&1YMV#ALxH9XaW4vrjvA<(g~1>l9}W=*tBgx@++!j{Q$ zT@F%!vt)Q2N8qDAn-a8u6i7rjg7p|F4O!x(*BY`YjUZqFm4Z=Ihua94pqc{~h4bMG zP)bR(Ly1$A)$~&o<4@m!0M2|8ubI0vN5#W&r~;6s_F!qDih)U>0+7}AU}?74z+9LD zl)_Dz^UPUji53JYfGTYeQbH7f%(Vwg3sG#e7N7uVu|1$)pFTh_Kn+g-v(g?e&F&hU z4^DuTzjrl1TC1))kl-U4$hdwVX-Pj7Q7mDc&bQ z@};&CZwZEw1UQ53@zO#P8*C7e0IJ>|vZdBaI0BHx_F!qgq4DQ}5umJOq9qlqWiS#) zM<@dD{7+|1(YlMll7vJRfM3d_lcLJ&4Mfr?OBe#G^O@8)BMdR}>@_Q;(3pW5A9m$$rn*hHt zq=XwhoqWLna25=YV}QPo>2123@yazwfkg3EupT3&;YOVFTEh*c5ri9{QZj1l=o$eN zRCBnYa6a4s%3KodZb*vJ=yYT`J=`$KAPu%hY&pLgZUAO36E3;kvfIajF^TTapG$Y zIgCmWbb!vB(NpKyNSL^qgAN1qVFz#)lX%zbw`%dONJiLUkXDohq}3#1GlyxOO$f-L z2Ve?62LWdeI4$%D;3W6}OsPFwnq>;$T=)T;xeen50SLerHw-Ev2w+y)!=;5F!I&)w z0aX6ZwzJ|_tq(#1NDV^(G}s<6%?<~EJ`e#`y**}|xzQ4s0%FCXw)5F$(TW!enEHm{5Rw3Cp*><+ND>S=2uc99+#a-z7E4$H zn0&dd5Ys%9fJYaY0B0~0FR5-V1Ct~^LKDE(v&pPCG-)O!Y5@w1nUqpgd%eL)I&BG0 zKzB8h{$_+H0R!Y&gI4iamQrL+VjCsl5Cy39OmuSx+Msce0+faJXl)Fpg(-kq-V8_* zCvc+SEOFX^+p{R)g#r~f49I9esb`{{>1?}j1-J{D_%{4D+hh>10BkuEbX{J4p#QOu z1@O^G*3_LTnRw6w{NfLRj-8SKd?=HMO+@O};l3alzrz(+b4ko+zSDgfTzql4og~G# zH^jiXSD?it;Qb+B_8S+|hUvX~g<4HQHuIS3D1?aO-YZU_l2D3fyj1r-z;ph+;*{Fs zrP_x8PaS*(n%g*F=;15c;>J;(i?28{8mjpLcCuTTr^AyZxbVAP?nuV~BdQQK*=bM_S{Ki*c5sh(HJB~_y+N+}a9sdDD( zw?k()5wP=_@U~mEgJVAtFiY*>+ATSA6oIw6DVXedD^Q`@c7oQxBs+INDs3E*;Q%wA z33tYG?wmycFJ%(2S#M`<18)&%tC^_lbK`=A5OWuSUwC2G{GBnKxW5Pjr5^?%a~Od> zmr2DY!`q*fJhy!8;rd3S)`$RAI1UMM?)ejVn|3oQYXWMZvXV|sGu?6Otux)h=$xln zcyZxa;TU~0>bk0C>(L;yJ1Jii6s6f;rf(F3LR3>q zQO9(xF*9(uQf>^7M`)hM&zZ?wTTnN9V3lcXQ)mh)X|2 zl(+6N>W4+-(-DZTf{Cs&feyY`>(k^q$evy}LllC^*Nys{Kn3nFpF&}HKrGcmIiEMH zv)PQilLyd*T%DS(G-j%`slz0?2w=s#6x7KqkdeqNkkLqahDY=m#8PG|UMOA1_;3FS zB^ApW-9NY^k6xk-N0C(HF)%2Q)>o~FzU&4Q^7>I<#GG>Rj&QuPGs z3Fxez20gJSgMNPM(vL6>`8J7jf;ko43g%Qs8OTv|I1r;uR|_e&*Tu=|i0kBK*+p$m zdHRi0T`hObR)>#^f?}L=FUEK$9ZtaAq(f=JUmJDnnk=6>P^r&|IrI#|zOkJE{pcmi zM_0lQpmSii*tbXjygkQGg&8e%Qv9M#g_)j?@cd#rPIBps;rAo)X4X4HZs!QtJxod+ z0e|6cj5Ee>8#*c6%Paz|cuyLtJ~c`olz8`F6^mC!=(cR#tKr6^v6}y+r~>rwaGQ|q z8kAylyCOgqUJBZJ;+_9MxN`&_D6=CHY=!CgJiP!d&1Hd`8`=(xCK)JmFH^M6Ivazb zUelK(>oOnRwtTuWKOUHv_oS$J>OnRC3Q!lcLx#RlZqmgl3Idu-pp9?9W0L6E(^JC( z{X1@)ovEC_9C-zv3^Ve~pOjgNmsy_0DfN4vc7tyz|QkN_^Cz50-uj zW0~M_4EEjz3|@$T_`cAO>hASlT37Knz-L#;vr(YvS7LyN46su?rjlWF#R!<*W{?=8 zk7Z8OPDX$){wl~!b0V6u;19mE7dht6dR4ZZL9a`qxq)tx)ZKT1OZExCPLaS-V>r&B zUM!x$UcE}Lma?>BtSKA8PLV!l$UHGm1S(?&;KF=z%nL8|BV=MEh6jQsH%Mw+d};3m zA5`Qr^+-G8++Li-6HD^56t7iuEt4H%D>KjOji>gSbU9AZ1_tgjM|K{9+7a%WOYQw=ut#Z7~ZBO5Im{;;F+Q9XY1ve@he8F6BYgsvfdNr7o9#f zJ9_zmdm9u_E*ruz62$L)NLNO3ce5nzr{4iPnn|EsuUDocMW)& zQUK1}|4PL(tBC+N>WFhFYdFHw`TwIRog4&K#9qAR9=~-p*nlkFV~W~2C5AO<7^%(B z|G0H2Xg$Ua%lGs`lAX*KH9c~VMc$pv7q>kcwAC8bvFcQLqNKk)7XC(?6m=)db?t{? zxwzYw`!QD1e~G{HMkG1L>H&0!EsxlmbN*&a?Mn?!7Bk&JZXKLjLy^3#E-nxi*&>bq^y=f0HD+qXU{*N#^ zvIox7DPE|0Up{c_RP|H@&_M&A zVf3R|fYUUAG{@b&_|$wCCAXw0Z%uvzLin4?Q&g?5utOQ}X3YTav2Ll9M-EgQl_^R| z=+lFL3JJtCs7vR!+si+Z;^?Y0WP|SSZ5GL4T5~fK5wPojfjJdRNXy(@%*m=)J+elle1IICfHjsHhJeWCD&2*qyX?i`Am)F ziD!!sW{SPee2}XT{qB6Kt>=eq9%$9bpjylXlcO=_ZT4DeMXB7FuBiHfxB0h&N8ZIq z-fCxI$vWly-!Ti@E4mp7h4MhmL@*!xkj{r~Aj7q(=~>E6a@Re6HiyaNx}7-kjZ>AA z4uS|j9Q6XjFQon*lQdg(_6Fr4WL9?9HGd(ZiZvyT*qQ^S3M%xN-dIa4Do z2&|z_k!K)r-UM%bk6IyGqQrfWIq+KRO-Gm4+CU`G+CW21Yy17kp|!;(ttB~t$#gk5 z1%?EM-VI4eHe}GNnj1Eaqhx??)Pb#!jT$_4$9W=zwAFq+OLc($pAHAX#Nb0KOTa z^eJ%uSA^%64Tra!v+s2y^W(r%Zqr5Y#rK$eX2hrmZcB*cW2I&Z@!k>vsQ6w5jQb^& z3lRM^d$x`}<+et3rV;^oaq|hVw?LZ~keAXP zHt)0rBz|TDa)S@2lU0E36uz%NMZqkdo44nOYa_fyVA=gR4-SuyR2va`4t`+W6bWIn zHWJ~<)eHpcBOZ5m@5eP1h4}L+!yr&T`UBYF2h-V_ttRC^=2`;ztFY3x?Sq_ShyY&y zP&yIfgeNet{0f=M`1DMfzQn6g#Sf=LN+-d5!OyGxYl%sT+z41J8JI1U;vki{ObwT5 z3FF~~kEAo^x39oMZowJ_V5C0e(>AKK=>v7?qv`0)e(kaHbVck^q1P{7w{)SaP?KVc znh<%;8G>HnW1!2eY3lwwkv#epm$iRqMZ)l*UTjC5ch-x{M%`PGWVDSr%=aeeFiq8N zrrb&ddi9TkE+rX=%26{(XTk_pR-p6b9BHAZEjH)A1RjXaYFY?UYVdvnF6Tc1sm6_8 zazF9@P{Bf}F0sskkE2x6CbM)>b{UXc{JZ}*WM!-%w(!Zd5nadLdCMdlSO72nUrhZO zs9cMMc(_s_OQzuUzfT{9pP^uNpB%5ykqoP0pg^=;`p!LmI+cU8t?RHDKBYYOsSONs zeJhJntJSIF5h%_-vH{911gy%b=yU&&F5%>wScjf)P!j>S{*S;fkBl_Plp$yj0*r36 z8Wt7@Gspo3Pio+IG?{>UOnsiYIcrE_Zx_E9OYe^>pZt&9z>z$VV z9oKW9ak)ks=n?%h7|=uCs)m29TxY}b@da=e+v7Ed7#>ff44~9M)0Vq5G#50`*}RK2 zfRg`g0`28G)=*0Jtcy7C%yQPVt>t78_{GnG!5Eplcx83>#>u9U z@iQ8Z=gM6e4)BLQAJX~rO&N}-0`$_qq*Bq*#HqF(4YIql)0GIQLqPX4&$&o0!^BU^ znO&}q@Y~=Qlt~YBOZg;_@asa@Yijt4GN<2$2i(0LmAz9VT$^*l)XbH;B6M9`%Okf^ z)h|7RzRT&)>>U|#*!X=Vv!4Q@L-fU9be`|$)ygB<6Fu^+ds2mcgf4~bt|dD1nW2MN zbSb8HJv>uuRNRozW3WX}WffgYZMrhA=rh!!FPKH2y6;P&L$x+=Q{|+jA{r5XTK$sB zvr~#FXju+gLakHcwo>oczp7~gK6=fhgeg%mdN2Gs;qjCAbEfr2ngGBwySUsGQ zz*Ais90E7$NTM8^n5E-8JiVNbV(BlR=S$*@3J#th`YHx4Y1^=jf_K(cm?$pNP;`9LrN*}4BT^6miNlkc2l zU8ds_%&lA1gT32d?v`yQ4Oyc1k|hY@)2~wNc(P_%WcFLfG>&0$L%~}8JIW$?43$$e zSIm@;o#c46K{Xn%7v!ryuS(O1zWMKk(|Gf%U}rJ`8e(wp*wXhQ6*;Gye`zluWPtdi z1w%J*X$xSAKS<-Ii!$MLN`{L=10zO-##1M&BkuSum|Gq+nuAnAod(Wtj}S%>>Qn3R zcv+-hw0aSLT(_q;IIg~$Cz;OX)-a}#*~xl@v8;An5b-}-IysghjK}WwiXycIb3tvv zuu!?D_n&`NRfjDhJwzu($clGTFe&vAWKBx{pK1(S&oyu+`cRC(Q`8CGbWt9PD<}|~ zk9%9psL;460`?MU#5AI7x}jzW!*Y2TKV|JGlypXcU&`rN;&fP%lgZKH%EW}U1y+gN z#3SWnVmo@QR;L{gyp*WIS1H%ehcp336ZhG>4UOJHp@x;@^gkLj$n=vwB&Ywud;IjP zMo=XXM2AWss`{}eC z%vcLuo2}CsXXQ3AYrtE4JOrt}QgA4|Mq@xptj5gs6#mc+cmZCs zo9NT04e6Y&RGz91N1(N`9Wq=}&4m7V_$ zV$r2(^1>lQc%+s&39{Ws02;guqo8@D)%CG^Y_sd6#OlO^>`P=&Y#qwJ^hnSk+dHjF zzas=2PV@GVH0EGFOywt-_kk1GT>;y00D{mc-2MHWc7?ltXt4b5?~N7}C))1cZvyeV ze=)xMlm73q;Wy2tIAUP9*sJoUZghRkz`!_FM-C*$%W{vTU75{&Qm;vH!;K`Z~{kmeCxL|q#hVg^M}nop;wql|OVdXzkW zSBy@bAV->tgs$FQM&Jz+i$;p;A#QsU+~|}C4>Lf72bNMF^jXfEzU&eMQAY}tTjhW# zJ_P~}d2p|^iSfox16vp@g_P>Z6ncmGB@mDqOebfNJ8VfR=ll3rTi^gw+6WxUGy=ft zQ&Yu2WyKjnfLH=XWioLri$*e2qn16N(Q?_`iz*Fn z7({(xv@Jf$Pbw`D1m!xncAg{uxhLAXrTe_wcijO2K?eDY&c=UsL>KK)may|~yI33Y zJvsU>q8x#8j!SMxcBZWt?EouOk5HSOtWAmBM|3dTY(8Q?_g|WmN<>07A=HnL$$>nf zTifI~9hH$Vp>w%O`m6sbDi<$?7&vG@{&pGno~UQLpPWXcd^&AFh+K2z-Z4e|9i2y3 z6GL=&5kxnFzL#PY*+8{Zajionc`-qoZ1;DM{aqbpi5E89V;n1Zy$4i7qb2=Y~V)HRnf0r6vQ_DC|xBecAlFY)) zI29Sa4$r2_61{rXC`>ofK$>1UfC53AuPQsgg-dh7Gpoj{^cBe*(7J6d$df+Kll8~w za*V1fXm#VQ%A8q}Ct4G|(#!MrF?}T9hzWmR$M0t=F1w%B-)YvMg~IR&h1+&6^`|A@ z)!D`3O;|=#l2E$m-M&*71~g!c|9MMvA^GK0?0L1;{a+kya}C?H!3&NxCCZbQ&^SnL zCKRbKrDbf?yd+)o|Xv*n2&Bc^8 zxWj9jj+uv`kVy)27(_s)o2XKy1EWVaYtxm z=geFJlZmx*0l(Ybua@}f1^W-0zo+xfH2(jt-hFw&cNFPg9zA|5EVlm-SmCYB|8Y=7 zuoXpETM=kQ+cw4sdraC!W%JIrM<-|kDY;}OX2c@>y|diHhkkz z%=vk@`%_YEXmg!j!3$*3gVSepSvcQ!c_DS7^IWYkzH|SbJkotyHQw#}bwuYTI?*bm z-BcfhR)1b~ZX4-4y}qsQlSX9IPO{291Ntk8z{X*EQH#_ZdY9v3ri!+nmuTHD)%LUo zOl@87+sfo=b@W|~W>sELuIo@7Km7W3bl#=1wR&boYLqk$_)rMx9O*?iw85&Q(6b$K z%*pq&d0e)MtIL2LwP}ZyRpfx~U`b!}bzMQggmydKaXo2;)TRdx(p!}`OpVr_?(~OO z2_D+|?Dsh%kW~DZ&oAoGE)2k__bpu^)-w0eB(JV5Pxkp6=L+UarrO}`C4I|t=upNEv z!-y+B;CRt6;!_{gKXu`SQG|^G-tZBQfGD!S&AvG@%|~iS#;eoRx(E03S#$x-ArB=s zY>2~)iKVoc!kp(Qb6!yRg}ed{v!d5y1eLpHMMb;&br7Bq9s{8660tBZ*fMqRyd0Y- zX(yQXne^Bhx{ANx>J`(r<6gl_V-G#MJR`p&;+P0Rn9BKrA`A%Y+o zOfaOuLC^Nj=%e0f&cA()M$;Crf@K6`&5V;WGS{{~+}}O+cl&@$myZ(07|y%hYTjUn zhP)ZdMVHW;o*kZ{8w*1};kv?Pf!$1qW}FTzpno_5gSty4v_RBlU8H+1c&h5Xz)tl9|CRy zkB7tqVqeAs()&0~yBZa_-t68urHRABXRn@K2BCQ1f{*H$&9Zr!MHq}XZ^x=L&nK%- zLC}xugWkaT--s~|>>~5Yuu;L`_apTW0kHL4n44G6 zM|FlVOZcLz7mCu3ep0_3>qUZJN|%ze8t#`QoE|g&d;vj6-ysn2!olMJ_M*wWxRYFG zi8x{Ma-2Zxwp(z{yZxHt9itPqGRGy~Q+^kN7~o)ZE`ILpzTlFv>dg4;F}l)V@`_`% ziJ6gO@~?rL>wH7vbVTtXzmm@H7t)AEm!V5-9^0xN&*c>8z=7FDnc-ZV)aKEj)JL~T z?v4)F=uNAETllWMomWR6(jU+Bwxc7uWH!+&cWLf%01knBzm$rqFxkYIF4+=2uBuS=Zqr@ei9r7q|Uqj z+G{A;5tmF}`FLM2)n(caug&avwdeS3>bSGW8I*L;M*`3h?wi>&=Rvm!XlBo6`JU%A zL(*`6S4R}gHA7w*M+`bX*(07s9d~8-d`*Y%x}CaSo#;x_4S9Yy==xL4XQFFB|NbDA zbUt_86K6F*o$&M@$33r(_Y6Rn0?<5l-Mu^BH2}RgVD;(LHNk1n^KqU$ODZ|0pyy4# zClBeWOyW=S9lNOGuI#Zt5RB-F)b;Abh=Re-1?n_NUCFd%spuPnsOBIuklpo^XZ2$0 znIInwK3LP8Og&CK;PZ$_+)5pHW{c?szUPI_v;)YZ@0db6U~-4=$h5Ca%z6O%sz5}S zF`K)y`TSBK`CsQ{m(b9FfneF?sAF>31wDT`n0a1yyAq-gcwGo|xrce(m2GqWzRQc? zG{a_hy~p>wgnDM{NaQ<4Og?+~fg8)~b0-}*WmwTe9`iivnGk+3_`o#sTH2WqQy|em z@h;$=*(2ZQiJwb7lWG!RzAu<1R+Gd^4)_d)-kri{&@)`~%xD5LpdRQwV^TgdOPrx) zUwQ9`3HhM@n@OS?D-6BQy+D`Dw~1-4p6UR2D10> zPXt|usq5|pY9Q2?2dnAFsq3x;uR+(}3TFRO?wT#u2Lsd}p{_fN+0%M&utp~sHe0Z- z3^>@vT@!XUVD@)|u1}z@S7vwpOwjcy)b*;w+7Hwv^mfQ~yM1SiZRfwY`gQdtwv*Rp z%izPogdJmU6EX-`m>9xSQNS%Phn+3#`$7O)r@mKabNg^GzfYyES7$HCUkJMHrLMaZGZru#nxp|{_L^+i z*9T`gZ(+sV*}^LQ(FI;@UdNrUyegr)fi5fsiMEwwbaq7E!r60a?iPB2BD7C_MkBOa zXdINSc=BiU@8?m(NH@RBOvHH#NOMp9ge)uqCIP^M-NFnVzFmC z!V-^n*;?^<&)*T_(DDBU9dy5!au+4$Q+htABi$CB8>Mx8&6hN(fovOS@X1UHaL;yh z@Z7=6W<-xA)?j*pV|DAp0 zJ^Z^%B9;q|)^&wr1nIpqpHhwdQtnEn(cT=+CR0^5>)$s@JGBfCSg9513% z!y}C{B~9*9I>AEN5?zw$M5hFNR{Bpaz-nm~C)tUqGtz~LiAz9)se(O_$m(1!~> zSq^+i8%SMfLE)HoxBvZol@-01?b1d^Q&?kZ6C3$!|3zgt!+Eg&SK!a#^6+@&FjuWp z^WZ^9SembwspX7uHWiQBn&^3Q21|}+_GyCatDKpWbFFH*NxA`ZE^+ zppV3K^hFqMZg_TvRueUKLq1ehkV%6U$WE8Vr6sbYgrDw5d#)yN>DSKA^NHarn{vJn z2J+)z``VcJgOKQKKCM@&^=yauy#nrh*%}p4VPu!Y6nU7>e_t1ByOIc+YNrelY62bz z_L8SWl8~ix*R86RB7J&u>mVn+qi=l4kqNcW+4y)rnxx4x68@?ImL%xR^OSM zsz^1fw{)1WCThYHCET}mpG#cHMiwWx`^%242ZBA}Hr6z9lu2RfQE;&k%-h90H6ZFW zv1j`$R3*H4JAQNRvm}NTSW5p;$oBZHpVGnmvc5zOT>68M*@gCVSh?gI0q+mmBKY*g_tLgQ&iG3E!B39|GM%P ziz!k;qRG#xT0zNQtpnqlF}>3#UNNSPH!Bf0`L3)J#UiMW+?ps2345K?=gCtjUc);X z*@A-)ImRD*ir*MN+ev{Fy+k^G1$p8ld~P@reOsU1c1hv~5(vLqOw)M9zp4zjCA#3* z3w`_H+H8ZW27_TX{RTMN#>tg{xrMO}D>COK^ybqN8WWjh?3+z}IKpZI3SxMPu@HuZ zK*>Hki+AWt5#($=LBB^6M4o&YN5MU@6F6f*im8M5B;TWFJ21R4J#Vc6@r5`umuiPV zqOta$S0>fuM30A+iT+%Fxo8L94>oX+{_ikdaq>lN-gZf>dFayItwHdsl6>-ILPW1N>zbVR&GoAm> zt?JWyNkKzz_QW0P+IAU zl@rv^Z4L7BGqvP@4PB<{q(?m4J>V-hN}nj4sM7ZqNp8Q3e$yu_mHL=O`TbbhTqr`F zo^GBtzoa!xAH`t20U!C(6{i%!Qri`#h$z)BTCb@}WklbQ+G&ma!3%x!Ymf2g-p-h= za>a8P5l_)@>AONs=MP!;iRz@(QI}B4pOaV7==v+ZWVWO4=wCxOw4J#h`VSp=FiWwy zuq|$2Qrhp-{@c#g{bqm#d&2>Kn=R-oub#XeeZ7uIJLw3f5ONR5#~$^N%5;?fmYZ~{ z=yAK|fc@fOF{+&9L%MD9^cA>sAbd~SfRuzMJ{kRD6WPh=0V-P=E0PqWSN)f2;v`*T zMVGfwTlXja+qAPbOz#0w5i25w+}O0cO^>G49-W~VwaMgM@;`tQC6?Ex#!-|>K`Gtu z+|gIJr-sY3W8*UfN3Ex0aMN44u_CzXi!03IkYA*zBFv_Zr_k zGv273bglRK)-mmPzi(nCo2F+MeA9GobVfEnYJQ_{9y#ss9`H@h6|0QDhq8Xn`~^9gEQ z+F}#Jt<>_cCqxY-6KY%Dve4m-H}5pZspXL^-DhbF0g1kz)wi;xp(>J_CM&>O2={%| zH&2pvpc~|8sCCuzGdV0qzl;sDS!8W_pz9UjnC&7_Zj_nsa+gglwG3B|acSgPeIM__qRlb- ztbF)ylzw=m%T@^gpd?p(D_;XxrpxYoqjYgvKQ`&b@yWgPhq)oBP-fm$L z5Oi_BQ0hP6lT8bkuIQmM@H0MT!Y^t=i&Vb|AN-9kfCyQbNbT=9D49&7Z zI%Uc-#&0vTT{-xWl9nl!{fTW$teKQ`n(7DH#=!lEt&4>%rr4A*KRrD|1(zgszj|qt zqYp0dV)?_Mkp)tl8ZFOG@Gox)esSGto|)*I{SRZqCu@!464tSC@p{FUZMr@|d*)ev zf9%^?-N-nT9jEp`+46k|mDyYLi`lIlZhX);vKeNxVpdf$1iT-xX+fnez2iN`HIhYY zUD;wYp{+Zq_0d=>%@|t@>o``EmdAVx^E^!Hbha1PjVH$$%6mIAa>f#@g!N2jXQ(M34;0 zi8-akVJo3g8Lpj>YyD__*sPY1k%5)va2eV>e+fPU2HmPUu1hLl(EUKUBJ$3dKbu(^ zs}kx2Aq>JKlasaP*SYNFJ?BHCQkJ)l(iV5Xdz?kjJHL~`pLpn3SkF9uA$LnCn{YiU zy5M1(`mq{oEstBK1#|620=ANi)%UOQl)3YPBvFOKCv;DALJH<`RocGM8$!8v>FYmb*1ueI&j%eOi zh{h5<*1*0wk0KbAc;9?>L+$+sA5v>LrEWPj7EMoNJ96(~?*XJAczg`*jnp6&K*u;P z+sw&76PwSSaG@KOnvrb64#9aL=T_h**Q4jEKj>vukCrZyxA8bYh%7)5Z?)UTV0(do zqf-?%Z!V_zJTvqSa02SFEkpMlZGWP*i$Kk_P#1_~X&#VhJAc2Dg?R=1FW!NMHO4w> zzMHkOaibm2exQ-xMF&CLIBul5afU7zrN)U^BQ?~I8YK=6+3b4l9^)qZDhstf=3il@ zYlf)dzw>kYq@Pv64iWm9TKbOyRP4DBq#-VKzTDb*<)MAG z6KYK_{qa`ow!6nVZM`_EjmUBrf88c|Ubo zhX~OxZhbMs>a{5TEa=$rYq;){%u?wJ*1o!p@EL>Tp_G18rqa5OnaP|BPQD~r$#vgi zhv9_>A60OEfOt)P7=*DxgDY>%3v@2|GZH@OZPVDNc#lc@}A zUZiTT>BKr1V&12s5W$e=GQ~H`xr1Um5wu1&7qm>xB2nt5Hhh||=HbQan`_f(?D37$ z6O@YLC5k4m6`+skNw$I5dziM_$94mgo%qCMI`O`D3wZ~#6b_TA0i7H>-fT`h<7DQF z%reYePDVm4C9|P3q^eT8arB_=h`jqzry=V^qLK}G#9CyH#80swHvu=Pa1^02#hgu!hv zuBRw5LhShsksJ71gd`*DL`~C`yQt}6YjO(VH%Ru{L*GIL)^9$gqf`8?oDQ1z8_FaZ z;1oqp@}Bab&7Ny=ln(jUQ1wc_*{h!4QKz7KL+Ixvn-E`8uEa0zxPPhqCZ(%C*DuZS zHKU=<*+9I~g#!r|OE{2Vx%h$Dg2~xH`Y{m7;jjRUP~_ym68vAZ!wh45X9#Y%8Ldu9 z{waF1YNj8w{Y364DY|-1(XW{byG(YsHMm*x?uEPG>0)!m2#~n%xuV;tgXi8TfeAXv zvdxNqq^rOv>m0p69}IQ?swu-Z;ro$cb1{QOD;kj5k|1xFmv#`{(AL1b*;NSirBqVw ze@bID!A+nkd4m4I;j`To$yQCGA-5j0_^O~fhP?`RmKbj3!LGxlTGuA) zDCdKcle2?*Nb;wS7ciT0Aah+|tX?o39=opK(ugB^UM>rrvIP1k-T%$mq*+o_G_ghE zjnrWIkLwCE1u9DgB@TrebY8tDC6yIg&L?-rc8rXA9xQ9VeA6O=F;8X1b&Y;11nisBMxnC z+>TR^FCx=+qbsefb+lwS~r3?|Is_r^Z( zg$uzz)2t??)MVzb-tFpenwaIBTi_v6_+uu=hfv-^kjpt-ac+Bsi;|k~B;9FdvPzd# z6TJD7ew;C&w_fPxFf@2$v`7ud%EW$0d#=OS9h;>ywVCK;c}K&KMSm#zFm6oyu#=;q zUAMK-w#`Gi_##~vdex3kOK6_Lry|JlW6kJqUjGT6ESz`kQj|h92^a04H)*b=fBZI} z58k9qP-ZQo2iSh>-){5k;&=Y%oIr=UL_k~sn#XvOk(^^bh9tePeT;*Y>Ii%JL9lRa zOzI3+EZ&o^m&w4O-Ryy%dHG4`&gm$4;a}s&SdWm7yEh2kUq)~A*qTmLb@Idu@f&!q zD^Mye(MHQ4O>LbUZ&5qhbJ^bDCbDhXErrZ`A{?cBCvaZAE3bFE#!{PPM@Zh)p6^{Es|u4I{Q|aw^&co zWfydI_C50PEf#jtB9>6Jvu`D6b-`$7-=iP5Xq2K4>c}2^XW!R@W-Bova>-^1G&}pg z9kwgA#{z1?!JYCIdinry-`pqsSrB=k{2|BAzI#8h1^y}3?sB7lU_N-DOrOs!(>=c& zym$897d+*Dk;{fV`xcsh;HmEHd!VVEKO)mOLCc`CZ}AiUU~QPUdNP`weGh(O%eOE~ zJQ5N#Wgdz4S308YI(w2{#1D^rrQ;3wL5nmjR6(EnzS`7B%L>rrk>(zvMMU^(9kvPi zbR&)VYaJFh26;#tbohf$LDGP~*6|VL)Gu78w%>i68=5OIgku%2s+k-2Hb)8#=`9QE z$;uBQK6#r1TM6I(-S2IbkVNMNS}&9MgErik>%+25pG9Yo&B1W&c@Q)I&A?VDd(^ZN z*_@*~${!+3QQ}9_N_ksiXgP(JKxkkX+#2=K>M1v+gdGqXkQw2i`Un~Y&vD^s!$9g01y+7qO{@>&}jHV=Q zaH&U-RG(zec{;jpK!w7xu*Eu4o1wE3rzL@tMy24KbP94wdMH67v1g}TDHQb!@<_V7 z_%sqPMk7$Pho#w3*%NP6k8Uv0%0UH@@_9Nz2nzgss!o2X9eW`qCU_J+T}P6j;w!rM z)nN@83H`zGGj7ddbF6zk(e8Sm@~vWuwL6!8B!A%txcTsF94jZP zZYB6gVxs2Cc@a3^TF?HApQIBqK{W$ieGkmNa?2e*rcHD*>Du1oy{MVm*ce4%U44th z9E=>Hxuc%0zQ3Sm6WdAa{a~zlyfz`9rR(Z@2esSKhz#;%(@J;pn0qhTlmgWRz-gdo*bBOzvn=Gn-=Sidqw#yYI~TrE-40?YOxpam z;*p!5PBZ$j_6YA7==6R{$X_(yd1(&Q?058$N}av~$eumEQ6XlHTJq1-DU8X;#%r`` zvu&=D2;bKj9mV&6;RO@D#^BqUfcwWV_@Ykjh{)|E^@f<`*i)25=S z_7v?ET5#LZx7(UYy--=P$8rtas6K?RYUW0@Glz`y*r+;pl-jy`{aI6YIVtGO7ruH2{@y1LmA+K=dyAKLenjm9-gZ{FXmJMT92nv@C$yPHN8 zQmpI?sJ#m6bT6vHMFLSnMB{&J#=2r!}(Ne>`#H%0BDkHm>_~jpT zEuJzS1G-)H9bMn+=xw`1FaPFqbG`^%UWFvPdr~{to#FO~fJnDr4nd@aPl-6(_Ze@! zkifs3Gg75j+~`eH^02<4&(q<5y()J-n~DnA7!e^$56f$+oqYlOXe8pU(mt}n$|={- zV{ePn-*SSE2B8B0ppp^g_tPvB9wA*GBvH1=OKR1rfg8(o0{0r@XOjMOZIlf=JVWN5 z#qqEDJGZ!tIP-XIh@0p&BkEN^Q$(+@0R_nXR^%;mmwx!#nr{RJO8muG@7WIK{W%A& zLSIAbFDZ$i!9e*HJ>qd6g&5=XjdOZwcqDqge$bZR(o6mpN&_FhU6(XcDJd8G$1B6f z!A0RI&<)`t_S=TJh@pX!a&dsZ0}Cd8FU~~x(}sBn!9Yh@;KczJ`kxw;L-^B%SqQ;E zM_DM*+dp98&2bjOpEk@w2nIR<3)A4?il@cIz>nE)o5F;lfs%4@n8Q(U@zyvOvEMe# zMGOs;F4~cCOYebw(f)qOB)iYOXR-ZikVkzZm8P>1Gk^7_+F|;h12uUU_Qvw5edU?q z@x%PhIC9NkUvv23K!xtCreE^7fS7Vk;>GpY+W@-t^zXv9z^QHbrd`o2x}LNjI<~_N zA;%5VT#8*Xnsjk_nTwN-z7w6egTDabkX@~11k znNu85&TV>WoKI;q5bY!A!*>ey5pktF= zdv@-=X7{z%Tzw6Fb>=Eu3G_-8ETyf|JD?!&2l7vl($NOmJu}GjNTV+RKkIU9=|$Uhw>rB|x(&oGm3Q!-b zvWwGi4Kt^tp?C~EsA7WBFZ7YZ;0?b_amU7+HC#Qc%KMX5qfP|@vzq6#h#`}h;$VR1 zX3T*Mk&EmzewPu`@0pW$FG6an!YF><3^Xko~mpebW9dlNIlccyng zNljNy6W+WRm$?-vF&BEQ^)9~M>-SW zh2^iKqkw*5LfY&?I(=o|f4H*A=+VKpDwC<*@OX7%gjxxF&p#JcL90;4($DR5O__p; z4f*jIbL-%Gwi{I|Xn4yTlw`Zxsj@ac2Mx}%7|;RrZ2z2&$H!H_@!K2ZK(QgIEbAiO z_#z1Cs^9%|p1Mt)-Q5d*BB@GcmQ6@MJgUs;a8xi#S=kwL!bI=LT8uKQ@B1ewnM=SI zrtgelWfhhGApr}!m?gO*r^Hu|hAz#O$dvBa577B^1-I_i_g=gcyMMMZU2CAXze({X zTBK<8IREQ^nY-`sk{y*ySl_xP~9iAqb!`X1(WN>2~QTlC38 z_M}|OME$%&EG^paDEehiJcNWzl2Qs>W!HZ>)e+gHE4J)9|9p)~&m~D23Pd|<&vx7R z4EmjKTqAU*6*UL$D)q}VcLVE5S)}R+@1D_v@Z~8gkhDE*ycffnAJ(_d3KQCrDNaKM z4Uog6YCLM zPu6;LtC8La&mE*AY+igfvE)s`OHT6m!LLZ}j&DT0uQw;1^r5~B*yWG`^JXQXHQf2a)o0v~(5l5OX_WUVAYrufjkr13Kv z5DoZXC= z9Arx%5cLB%h|fJ~Q(>FrVz|iVyO7KoF7J%XzHsZ(#&fQ{0@?J`1_#Ofw{B zCVQUc#E@x)q!+2s0e%fIWP;6aGO?FwWn#3lN3X|D*<=2)vdeYUIHN*laGO63p(ze- zDYNqsYW|)A=)Jkkr#bO=W;APCr?E!EKLJsRw581=#ZT*x=6!EGQuI_n`CQk;sV2#@ z$e)t(_(7bvA8I1(gFory5W5-8#;>tPzcnBccF9laW9f;o=CQc*A`N1LB$pwlC%FVj zp8~5+a6UmLedv0IQC8yX>E;HGTK6l1dQg@8na!vs2ZP8;UQhI&dpoX&*gm0nLR%~) zpyzl=cu-f3(*Z=_i7O9cM|e2E3(5&PXjLS;eF^};rK_%n$HQSib1RB%4Rf>V^*);v-`@cc2oXX=0hMJ1~)X|l%E0r7-fuu%f0EZmj>nQ zsYaE@jFXpa19NDvlLi|Y;VOJAdYm2DSS?MGR)!;eU|%-PcLX#uA2Vj~fUR8O0TK3S`@jl@20yO&Qx^3UCu5J89%-3JkPLx9Oi|@L~#8#e${_XeHYNF8@rq%(g~ZYzFN*nQP|ti>bUq zCH@X7q52}59N$A5{phpZkku^tAIKoya3HoE=;B)XyBm>)>a~9YP>5+Mlp+F65lW`h z%}C-5|EckmVe+jf<(?8u$_s47B}_rCIo)`(9!B67OLAno=td8maj|CVx(x~)`R1q$ z{`bl0gBZljGtf4cVT=<7EeCm!aYWVZN*DSD&6;(s}s`U|jz@N4Fj zrcFVnSqZ&|_OnDLXIEhdsRu1y+FI7&R@7Aoa(j2tpnL4g0vGMb@})Mw(Q{PaGPTns z@1tv;+eR_99}V$X^J&_&ev7^P_Y@{`CKBYbb3uGb#VvG5(6hbsd5$%o4tmxfXv>+V zgAANJdRi$o4H3>p=sk6*=jp~7Ob*|yvbB^sIKYDAi*|@roF0&W9Tu-NdV>yU+a)PK zQivg52@G1aEu|9>GBvohC32gj)7T70_{fbaV7D~}D%u*_&R5A*ao^+dd4;DTGN+#s z_VhWhiX02sM*u#kOmG#AHR2Nk-M$=OqdhutmQTWOxk)wI9-~)7;9~|QsvXhAnx2eJ zPrirVRO78Lve(;G%goAL7;FZ1almN*}yJa_C?Epls^&yZ>ru^iJ?@ zZ?oYSny5Ax%y3UvUKSj(V}yVK0Z-c9C5g+ogKK&?Q_U69(JeQtK#eK;>1g}QWpY$L z%(fjlJ70cnC?MdO8t31l4>b{X?L(L5?i$9~q;gP$={WX8QLRCsV zRZytxAZF8;a+-qwul$_K8w=Mkg9W4VXGhL^2t2Q%S>2k*W_Py8{R zbXt<}7dY^q2R&)~RlAp9@E%P-ZF-_QOrNjg&lyI4@zY5S3x6fmw=++?Cy&}}tVufO zkxLWsw--Z*1Ug_G0FruVOBs3`7wabfq~l4K^O(;%IoV127yCyN2AO>gB)(Y--4 zJU;jKg^%UwD+olbGGagZh<=i8cBbw(R%XU)T!T^so*zvLE8v$W3ilq>KJ1e7+b)Cw zm=;dxEGw{3O}}*=c0>2_xs!vP=!mxa*U?-%Ipi|)#H-KA^D7N{AC0|T!sdrM`B!L1 z=@xC?cKyv=b-E^i8vJXs^7WY&6YgB^0s++WzAtBj9EVho=|>a=~6AyCW9BhD#Y%Y3{2s8 zmC|I_r=_C@U0{(~TUOo%5N<$7KA%WG}cSU){mgQsMQ{ zbowu5{0r|=Qyg4)6nmpTP=v}TT}&VS)%%mio1$iY-73v|2fw~s+4KUd3M7nvKr47^ z1%vaCxsMaUK?xp{xBl?PAGMQf&JrRQ`}EJ4h^!57MaSH3PlYYDn83Hpr#Z@& zQy-qjx4pv&hCVt+?}_pMsP&NPpu9^~!U1*8y+}5Wzx`YrG^ldv6^!zo!cWh3vz6w0 zyz`@Od{82D`PB8m-+_g&yT1Msh8y>D0h;R^ zyMw{~z};h4Ft9B;M4N~EA-I9z+525nZ~?>3d;x=N4enpKiSA!`_I^SQu3vZ_Ip@+A z+`draTdQPtZ*m3oHa_`98iT7Br15%sdoXtM!cDW2f*ahtaJ}5TAg#g83kUe-1!)X! zUfAc(g81TvLw7j6^sB@4^0!{#exet+gUj*`Q;4al@9PSxY4Z2gyRR#7ff?P6CH8=V z;rkT)!E=4E{u99|!+NkN2;lB)2JGjp-+ja0EGtz3% zcz^to+8Z`=SK2izU+mGPY}*6(y#(J1@Z=^rfi+xfj6|>bx#a5izfmx2>(x8aqbx}p zhJT4)I^D^)sdBr8_)>dd&HiQw{w#yLZ$%6NcG#S>1Ks=@*BmF|eE@sL=ufKqnZSuMB5ks{60Dk7@?AN29=k?S}5YqLMm+OU9_W7Zt>|?(MekGJ3H+*_{ z!bu-Zo^0%4h4zHSZYkkkY9bu|I!AX*$=~d*M))?BrxW%C604!VlO4|ln=>i6p2aE; z=a-X%Z|cIAUCBPMPgToT8y=)7K&!u#RXTfH?r&!0?!LVTvh%|%fMq|-CU(Fv?aA1Z zoBH%@zhB4Y69ZpSX}8^-1K{xRS_Rg#y>ZNm%tL<kC@30^YqsrgZw04rf~+iI7;&cF^)7c;Q;5o0*d4O@ZvB%RT!)=;*{; zFD}@)varKXe83g$CX{SQJ6y5vIlEM~|5FZE>>AI#SJFBw{OE|AT=LOU$wZe8W5G~F zKru$)#f3y|iIz3Gfy8*HvG{?}K>Q!O3p=;~oSwM~M@4(mM{{;Xwa<;lvoE9ZgOkzt zKX=pM`tfn$+}^9`&tj0YSDx+ShwQUz&oh+09*wBdWc6;sNINA+`SrpSLBqg%e>jOz?8n_G;9G|Nlw0)<+ng7 z94~gEz?rsf`V7uNbqsPR`3{x3J$sTvk5kt9B>QKJTdX&^cnxZKa0^0qzie$>7_wii zTr$nqHAe3lg%-jZ*iRJH&YZZ@m4SOZLQN{SfNB6XE4ZJ`K+Q?ZpObAIEtb{pPbPwo!>%cwWSAVFMbqY z0DSTnuIT&CT^*h0-F_7x&j%OAU+n$Ou0Y!)6&zhQo)oTY57W#b-*z{_2kZyp*nUpw zqEJZzzqW}ge(`CFBvmB3yb$mV(C8|b z6)kjPF3sq|)M(APH-mh8I&LJ=OVh(2D^(}^VC!+;$I#D6^lZOvtLx$S9{ZF>yY1Ht z-R`#DcA?I7@Ee~yNRYqdg{g`lzm=Mk4w`AT)T^Hrnfn+dA3f^CBZnU=PvuIm#P6{h zFjncr?F8x_qu)rq}A( z23&H!Bj%+MdzAKB_qB#S5z^)yO*t=?R_vdE1WSzfo8W71LE5|{sc3ZJwHzVPE&Q?1 z_*^a*&XW?}JmL7-3Jbi|bk>!bnOe4i`lxakXpqv5jw=l>A7DkKKkm5pIz2i`ehH9H zi0ERj#0L-Mdw)KLlLHaIU&+->e!rqCPB|;)!!$Z%;RYX@QG-(fACys(I}A9qZ!$S? z#yrO5hwMMoald}1gJ%)8h2!6o3da|PtI6SJY?uo&poUS&~{Ks{LP5rJ#pPE1Bc@IqXGxTjdYJ`^+`wGGTr0hzR ztsI$&e&;e90-kgip6aEczl3{1dDb&7HU0nDdl&e)j_Q8=I;M(40uhBIB2coBw8$nX zyQ_y~LLB)KKZqZ~a$-Xoq}A?~wDD?pv%9k85J0@mt0+*YX@M@!rlquMX~DG6pLn&V zKloLYQcR&B-UbTj-xux+{@-(E=FYu$?%W-x`F}qD{y%>aY-{E_XU?2CcjnBQGc)Qg z)llv7($vq&`&^0HTz)uMV2eAo)&1__a_Ua$?_6#2H3OHf$}j2s2w!20y23m}Ke+f= z-BupT6PJMh!Bs}Z!Bb^7{G5@eul&F8m>?5stc3{|vbVApC@%Zc`nJza(JRq6H)NTs zBFT00;ykgxtwSh5Kk$@f)Ls#uMXTYFH|&;SRK7vo8Qw(^8x%c`#FE|P`@1bDXr zRylYAQc|XIS)k{lXq|EChD$?WMdIBiTxIcbF6LW|M}qzrRDs7CSq|}9k^>naCMZ6& z6%j@x?-3gwEsK=q#1RWo=B{X&XePu0t4xS|7vzq>#lQWr+^-7ukiIe}YVEkLcq}ed zX!VWp+F^_=R*+Mcq&AI%^D3Pzy{ip!AC+yv0f~Aa?K9sc1J(93=2<)*zBq4s;4Mw{rALk~a2ISrJ&!O3WBM zsOU^7sV&z?4k+^7hRLefR^quwvls~wP|1SN^vVQ7LJkS?eP4tpD~zszqKFMJwLwiS zUFe88_^4?UtM7yqZgB4oy`CQB(@I?NKv63RG7UwzZ%{UPAbDEsDdDTdUMTaBs0skk3P$yEi}sow=ZG3rVfg8R#H)Vy38ZQzL$;WG+$>#5Z`T_5k7En`<1t-eGf zE1a-CNNCQ8rH_6|9JQcZc3-PfB)jH+=02e^togF*k0`CX9GA1<&FguD zUaa46rTPtaowvTbTXcNA?p^tOK|&}g63${Yp&&Ya@C_yr-XRy>QY{8v!H7gH38C8E zMWxDEPJ&dgI)W=kC8P|0S5}MNJZymCwjWmcKPQFV**nIT~I(cw$h(+i+ISzO)WS2P;PaSP})MXqLwGwfBB0 z<*QYWAf?)Hxk}~&mu|S?O8S0w)$o38i`<^!AtRFUTuGSmyK7=LHw%PvUL7uB!w2af zk!bR!MTKxpUS?@qVeo}=_~~RT1Oi1pSeNeN*Oze=>41pX)IqMJ$ENu#CPWyRCWk3t z98UJP$)UOHFv~dmqZi294^B-r`5{#8lh|7=`4mLG=bz8Z9@~b;Z%)qE__Lo-+5r!f zY-E_RVM+LL(M+n=!7>cG_I89n;wk|ctBQ`$0VPM8QqZ@}rZ*wwC_X4kz^#*{VBSxa zgyUaH-S>|j!U_SP-oRal@$a}yyfH{rQSJJKRiSm;LGr*3D=~BlKJcUrQb+n;q;xmN z9$x{0I%%a5RXMr@LT4zZdDw0?i7Z_FurA7_F;R!U*tS~P+oVvG@U@eahPWIaef5xy zabaH>H%9`h&!tslN^p(_*OSg4;mI&qNr}%}@S)nqpAQWUci;`(cx$NHk-Se!iHHUj z3o@!3wgpBs@Z;$djV!VN@iSR4cpJ1oA9xd02gRL;nC%19@PghU)5;G5xXk+!?Lo+Y|^v9s+=vLt1^)$gCFTsaI0UH0}8)m2Ssh!Ac3qXq^O`> zQhGX61D~uqc0)=09guE(P)dwQ)%v)@{gPC;SH4(COfcH?j@JnDv%|610ouRz(=sLjUEf=ABysl;DiuH95d$Y8nBSMrY^pcmeG zU2G=zy+pQ*tb29Dxlx@StIgpCQEx$IW1(T@p86%sPwWuT^Y4_;v!nh{@RTx1|avpzD~zgHHe&}>y&Qe!xq06Fd5ImC?t`jE5QVVVk8^=5y#6ZikKAT zy*PZzxaXSupUc@Luyc2-lulD3KdwM?onX57G9_8mpp&tDJjj+uz^pMn3hpxz?ll2L z_wuF?Q6J#d8m6Tyn1Oxe>M_BePJ z3X-p&xbzW^gnv~shzO0=c*|?OTnQwWL08x9^yvj(PYt16@*;~zs8OctfZW~h3R3o> z)zHHrGV%_dB=pmtyZQIv$vx=9FYurSI0!J`s6B=epp2pU@9Er5k|)k9FX_Q zDeg73pp=pqZPa0!z^X%mW5L}}7CN{?s^Ps(a>wte1gU$l0*M=wO?h-t5$&24tGAwK zN!_9ZVg`c9{L8THJG2eI53BV@@GMHC^5AnCD^KI?Ofjy9Ra#X+!rr(`qHL$vptvEIT$qXAot=fy zTVxv$<1rjkA=NL-5zJ#@BGa&SQ@xJY&H9=Yb+2yi`ERMTihoHWe8p>o+Nd*#62og8 zRe5Ob9Az0L*9NhY zfwqWeAQ`l^TP=c(s+g8)1drG;UPNWrjQ)yjXJ7<=`m-{n)94MV$u$37$t0lpeOH=d ztr?7}8#7H2E%w+;)pvZU+Iqpt7%@4$CidO3Nugcucq|u1cFRpptUsUfdZn?bEiuM5 zycuaUu+tS97>EFj#7Elq7ZRx+?BPf!SBBnX&q~IjP%Qr8JIjN zBhGuSQDNZPL+Bjm9;-Sa`g0G6R>Mw+&0K1tgtZXWg2+tdtMMEJIHXf+)ICaP;{+nT z{XH8hCY`TI=@{$;O?j?t3J}3Z(!{Gyef#Gy2q1QaA8LhroYm&$48232p-U_HcYHHH z`@S#}1p!2R9q)s;TP)w+^@h*~7|ntW#PM_CC9m+3>qVScw1pOt;4n%>Rlv-1R>?1x zXJJY{>5cKKRnD0%+^So2o`J0IS7_ObrK#wY#wCp$fAjftT?QNEdNPteACok(bIF_--Kb5OLKUx$I#!^$qOi5~3iH3!S1xxTN$qaM0p2t)Z6YHcfQS!;@ z;NA6lcW*r`zrlELZ(ir;LoKTKQ>`5c#%Xyk{dP!5wANwu2xRz)?}V~>EfmdvPDsZ2 ze&PASQt&e&s<~X?5PEwk8SzG{HqFfwGys{2a}m<%Gkbyer8k8-A|2YDypbGCrF7?U zRIZn4xn1U6PNs6-ene=_&|*>idIV1V65eQIuOI_P@y5I_zUa9(E8gNcqmS>}S2!uo zB5N;}*jxyEW(4Rqahrp7&@fP@2G@af?f2m!=WDA*l&=XE5iy;>6HcsWw}@wYwH`$t z-_1Z%!k`VmCR>AKdEji=%U&5Ia!rS6Ev^>g_#8Qr!}njJii^AKISt-Cc8vv}2`qG6 z7l9nk#T-CPfG;C)k99!?jW?G0xJ!QTgTB;Z}SAeyqKTnnMer65hen=_Lc$rN<{ zks+%5{Rq8J27gYI#ibLx{oQw{P@VP<^8;e<_?na*-zjgqQ9i^{$cj9avEBQ{uO@)g z6K_#pK+=cYxxDeo(iXu6_2{4doI)yJB9<5fC>X>-Bk3f=)?XKV%g|sI{EIIlm9nQe zgXUZA2;?^d2A-kBVnK<`cWeMa0NCAXif7%mL#tDiW){h*hPg*|>5bR`ymn_3KW@1J6{DzQ?m32$o1?S}AYsyo2sX$*zMQb{_ZFKpyvZAvoo{zjFn!lNuT(LICwAOo#2)MbO0D#Jjo?rdy^3g7!yAvLk0 zNiSf_r7I3iUetw$7sr%C9bc0yTR#=?me%gP`c{kxK#NR;CeUFEOPpfRRS9m>({C5m zg`AEV|2I{d2pZ`P64KnJ!bGt?-z2&GleY=l+F|Ne?sJk)?LT!ZmyNhnbweWVRF$mV zscys-QxWf~ThVt&8AqJ0ZbdsqLhftJ?hE@~*G1bn$>UxSjhU`lidQlfY>FoLnamd$h1HsADK$lAK62$Pq7~P z?jAC=8{Z{`&w47qjE78(Hhb01$bU-8Doz>EUAcEl^$UHRr`APf^WSAbHHf~~ly(Hq znMOX=w2z!WMWut0QdaB5rp|}w?M9b+(l5pQ#AAT!S*euJQcL5h8Nz0gwwN%E+cQX2xN`8StjN+(CW?Ts(9n(m8vutkkT z*4v#;`l=CD9dH-PMfXbAZ%J{b_X^gq?%h(Conl|q&>`qUxRv{^eWG@{M8wkTxCJco zs!-20pH(aeeSY}A+vo90(Bl-POY@z+CrUipqo3$eQ5gE($b`3v99yN@WK{v%FkpO& z_BE>I1GF!SUHc@WboTlue>+jt$ZO=<`BSp%p;<8X4DTKM12P~3Tzp(smpr^hpy=-C zf{ncf>K!yNXz4{>@Oh=pQi-pmdqex^{x|rCLR-?|~idjxs_1N)01irV@_OnavbCGQb*7IK)!aga*CPnotU5#St1mR`sxkmY! zbSF5!OmCe~;&#Z^2c>kuPFnk*6KYkV*->rjcuLsHj%liHd9Px~A{}xul8P$Vq-N)e z56Lh1A*(2pzUB`E85N4b8*n#v@XRK-nU$l(`rfQf-rLy~q9~r0>{t!AP`C|z*G@!* zJ!OOP!q2h|@u@$QG8Wc+XdUVHwq7UE8?-RA+k~ zE%1)27}{V6rfX?{2V-M`0Y0F{O<~Kh0sf3LQU#R(9wa;j1H3ci8$KwivpZL*>w>qh zI@{Hqt6Y$+?r2tbCKa`+wWK0ewMy=2Rd=pWvF>72cc%6#+0~JK4$BAFnOXT^CU z^(t&quZzk?sNq8&vs8o9{G<_eikQ?^TjlV)SdEVi$RW;(B$Kh}4d*)Hf<5(5$<1-- zb&BAd-d{=UIR(ciOheDBcWurF!6WDXDu_x^r-#Mk4;;PYz2Q$J!@{VQppa_;bNlN25RJ%Yd3bPNgE;y6VB%{0%{xxEG;Y-HQ<7Te78?(mf@7 zbu6}{AB~GGl$k2CDY`*`MRrEg&{cz61n0Af}U%x_%kV?zTib3i%E07tx&`D|?IVFLDVe@?wPPxh9|%==OQn-i2)! zrKV_MHd7hXxN4_1?LF~hLc+RvG6SE&G#&j8ZU|S0a`a`S@NJLsMJgH9ExMsG^15DH zee&q>W~1gHiyrtSCuK83{mF)f2t8gixDRE*+aPCQ^sSmbyZEvb z7!x8G zoD{acTo;^LJI;qP1v=&Bx&SYiX`(>*hp$RDBp^7;~A5T2dO*0E--QjEupgYBj zjrvu#eSG3QIPDjzG+a^Q{ZB|}hEaR+MOl&#gWPzL<(NEB&!ekE_s^(TwZX$fk$za#o`41OG!?;E0uxC`|P5uH}WaD)Vz{!^wfq) zXxBQH^HoU|JMZy3MX!+8X+pC4aGR&DgHfpmtGL$Y>8fH0t;3PGuZ9?R@7_w* zj3rF$^+x%)ctbNd6xv1C_xWTpbzgOZ{18L6!}Y2dpkvN}Wq%-Rpj#<$1W(tXs)p5v z<3-UEJ>f(03+rfGC|0=Vn$JtRdJ%R+rF2|SFfsaL%%3gL;R3oK2h0XHo_FE6Rm3jD zx}i*WIdrQ5Nj4`Sa`#^fX-EklI>KiSz3+cA=yGa3gnle~FBG#PlRp=w(IBpXzUqHR z`bZ^%ZMqL8=i=Cs*a8kw{D44{dk8+Rc{*UhkQl)5j45_J#XVAOXQvjV@@qHckqwVTQu-!YDXg7$o6|7k6I*Z+}f-$~0b z)!}`Q7{#xDM)oDN-pEvy4eOQ8qeFYMxJsbG@ADx7_~s0%r$O@O3|_FLe~8Ui!jN18 zf0X1>$w%D+s(#1tq&S2{iko}>MBPrLGvv)Hmz|QVQ^T^sYt=vbgw${(b?+4 zO+0z8&hlfNN;;UYj^!H{Gt`>Ga)v2_{VZy#zW*pjNI@@?Jq8A|iM$+_0Gu*S1}JVK zt5q!^sV%DeAX9Zvx=*}Fs@@}|WvjT$qmLFhbT7ikuMkoV7ot;Z4e!3ogB+ZW@nm;pGaEj@eOpvXChhfCK zOz9NeT5>n+^Jmh+e`|2V;D#^)mwI6AY9-OUQ4~AsB|Xa>M4rt4m1un^2KntODR7fx zv6f#6q|~v>Wl6xhiekM|c*}Zt1Rfnl>ZQJvAT&`Atwe<`snWx$^}%YzW>@sV>L5A! z!DSp8Zx_#{6i6Lo)fuKIRWMs#fF0uO%=E4E`j93-dqaA$`9O|?*ds+JNI*0xp0wIy`5 zHAIT`A-8%e%yM~MxUBk`Q)<1j1L4I>(!cjF|BW$XKkf^0^}zRj$+u-{NBtmKbmD4M z5ldAZ7fKJmMyZCzG%84bC>rI`lKkJwIWb+;gubZ2z{uc_f;7QfH(s%!x-|$qh?MN0 zXjJEo>0~?2E4#jE=-G=@QZNkByt4nC6hkntShU}PsSnE!E17C$Ov!@ehh51;Lw>3xB9%<6F1H451Ner_Wr=Ng+0ILnt)7ZOO;jmSgLQ~f zG*&tozujMn>JN=agDNegKxfzelT6jKp(6|Ts)9mW97{d?s-YSXQ;i@wRW%&BzVYwn zS9Vc)Ko00Wx}$fir(U{A?eh@6Q~&mS)$HF}R9d8eKQB|w{tZ>Z9n5a`JM$t==1dAe|ZQkgDd{FdWYp!OyYKFo^F+?FTaTZ-0Ay!?l;ZOdXY*CchQ7pweCrD21oH%?9z#e-SB*63ewTnCQdseki_Ot4`3f~rayMJ=4x9zjSf=QeZqj=HV z52yl{Bn`6B5~$(EXo{e*xIW!S_u%;51)wfo(e{+lCR5DJxRu^I-wA9=oBYy15O_P{!lE%`XfkA?TwhTq?5gHmsW$yg?9ta?^^bU66n5{u_9tRc>}n!dvDl)Ew~@Tz8~-JftGLS;3Ef>P zfgajJLQjw&gB*hkv=I-9Dg}(+Mp89eUbKkENJ!&#ds=O6JFQ7!A7!rc(se})V&vh zutYFOl<_Z0ce|*aGFY}Jcv`7gsWmzH>WRUFLxgL|cNu#dJM9G3h%Y@=<6-SCL}^Zy(haaBSv z;)V)7?Vkh~W($wHp{)NA-{{{-{&~FSkvB*&dRdLUp*HqOS*g)i#8o}~Q>{8O^zco! zg41xnKk{E={jL&%eivn){x8uk7peavdi#r#b=})RinX^z^PVh)3U4JSpsCDb7YaCnHw+XqYU(plGB~yX3yxvF0vJ`E9x;TlKkuO`nsV7c5 z1mTAPE?fWm*IF?tJO*?cHA&~xtu{IV#N?Rb@A}HsGTV_K{}5Q7{?81zN*xPYrzCb$ z$)B8?j)Lb6Fl1Mrts~H$f{6Q=JcwqlkMl-3e2HA7@)?7kY9}OGZZ-R|^TWjf{0!3{ z@tznVhRkBLXD0EU*=6h7&lDZ2?yFz7K8`C?OBH{#fTt5a z{-G(9n8A*U^Wcu7z4SGrH z11%XYW-ULUk~P!^D+|237m@meA$0*lX!W+z@dA#F9In-NvEaRz3+}J}m{P6)dcdEC zCLZ@?5mY`R!73zs-TD9wg8ORKX@DjyAS@LXMeZ0t7c5Zlxwi_RX}Kg`6+cApv!m^f z@a=d~4e*Q|zI|?L%5UtVhotdE+Hs0uaggG&^`jPOsBMSnWXWag>jsieg4|SS)n>~@ zyl_@)_@g!6%<02>?9Fk$R|1C^spwPUnr#%l10~@IHi|B~746R(B^NrE+)MAN8wDp) z3+}5GO15^6-k8=-DrswG-Kk^}v#ABQmAJ-)a+yx$l4aAKT5LycmL3nr!I!ZUg*vr0 zq2`f`Ad$>O)}X*fLf>?;FLa>evi062Pv&VRG_aE~K{)7Tp9tN)OE`q&o2J9i)|H=$ z0Yn#52Tl$ZPK?RJIB^wUFnCghWQid|&)S`e7$p|1CFYvGfo>=0u{cRIJ6DAO#Qd?x zm_HQbvjJwriV02a!<%X9op`Mf-a;_?DsqwW`~}8%u3+Q$`HdO~Ey!L_XE@faSBNIR zt4tG6dtOwg&hBUohOb(KAR{jj5OwHBLqe<%4sQW;RJQV3d4ftqA&5H8w_LXV!Mvb$ zhXL`c$M?~Zyvx?Fc|z;z2Bui6p9D_Geb_2fK==&gW$PEE3_N)nQgZ|hwQlV-f**BG zGXg;V^2^K;6{1^TiovJ})<(J~aTJ*?Tq-X0!&ql!&k~@eFOV*YG z)}pwvW92$s&Vyb)B^sgU=qM6%>voLEg%+Yas=zNAc%#w9Vvl#}|3dbO#*3)j9cPW)d_6xI(2uhoPwZS7i4; zPo9gS?hhgM&jC}HI;2jy@_LJTjGxc#i=E`f$NbYcr+T2(XPQyRy7)kAN_=3TShSjf z*(`BtNIa-5G+Y~7UBLw`Vk`47xt3vBb!LflKJEXYlIe|WzR|GZ*pF5s@h?zW+tiT? z@ewZ>{vA|SpW2ZMzTwzUm<9`ZX`?e0^@+qe11}2~MMd)zY9pw$9jH)Q5)Pj4O!@(p zMF;5ya!I1Wa#{Jsj&dPoQ9nuifR}D#q%`zJQ%R!1ym%Ky1>GdL3ey8GYZud^_^2=B z1S+eYsi1x|Dp|6W3MyXbo>p?<<`}b(&|Mc^l3Sv<11}4mziH;7NW+6F7yTPlRyu!; zx<#so3@Xc=TO@d)PXP4rKg?X>pOQE5vTX7quW!*dPHuCK%(KP{7@!uAAYz z;_jqNY<6IZF|5gnUobupSu!#uHjF7zRZu+M8si%&XffLqMo`vDG(aE1N?D?Z)6h&+ zR3K=dd!mhD&}OP(bZ;7MTGv$kc|mtIjqWab8d%`GG>VL)1(LvC=tvVQApu=WgA&DX zt47m!AaID^J)N+k{-bFya2c+?rvo-rdv_Z2aDK0-d?XFESD`kfp?w=|ShJS!O`h@rZBawwLa1h9>4LO_({{Y!* zLkHYTI`4RO&6D6W*O8{mm#@NEgu(PZeh z$)-VdBpDi+3@gTD$ZXbYCvsV_8`i#5ten)HzJa!tw#c8&=q1`^Sumud^s=})R~*ch zhW*XM1=>fLu_F7o6tY`N+0Dbnp)G_QwIThG2J?>1q77Nf4{X7I19|N14ALM|w;_w0 z2Zn|QwhR>~v(OPBC#=Z)R4$hQ|3W(! zqrJF^T)ddEfD*=Zr16noh)U<>hA^UO;X>AQgaH3SO)wUgfj`31mYv&CY}xQS8%>}} zsor7BstHs^j8#fddB_=J;e(FccX&_;1GC}gHu;2TquUK$RP{m?iB^;ns4O|i#VV1Y zMJt_K#EU}KCi;Wqf&Y_oX}PSr_!GiqqOGCd(4tkNMHcM~nW$U($yDi)mfWQ)YDd;m z5}sVTv2qg8u?Oq8r4ygQD}*(seZQ8Xk$HE@n0J+5)>2ws;orym2E?-A`Rqsm?-`jM z)NYebxivF4*;lO1-ZWXOv`UlwS6}a@!}A;aV1E~n2}^a+SW8%Vui^4mtZ2Y=x0JKG z07_fhmZEfIJ%Q;B2Gi2im{djy{Y?hrNa9374sc72bQM5CjTxgxCGPn1ha$#h55igS zcH(90PZ^5@OT|#FJN-tpT&wOcH(`YpXHa^@Rl87HZr`KS#6^_aK^=;R8&NEC5yjM3 zaG=(bA41kB&9465P4eExjeU1iDJV-QPmi&6U=hnsnBQ|1RMLWEcs(U|xaJ+cRbE?B zm;^RM$xvE0c(l|CapE*isN}-Ml|1C%I|rrbsDz6sDXv0*On2d`G%DPE5ry|w@yTN2 zsXSTnx#1{3dJ*MC<+sh3n=RhCGomT%vXXpb#T#n4cM)|To=2l8M5O@c!S~WdmE9p? z__08{m|}?QrF+sbE4!9zHBOGzDzx{z>RP0C(suy+7IZ+Z36n8bSN3)OKuF11V(;CP`&c6)fAt^>kvu6li_wZr$b2s3r@n~ ziQs|^`RhQHmL_XX&_UvLd6#HbDV5hj;-;0$NCi(hNT`A)v2Ghmx?C zX9V=63`E%LrDi##{~4N=}?lu+Ms}@cR`*cuqX$j4PQv> zf;@HX!a+ebmkuQftV-x}Q=vH;2S#=ZsxM22k_1M!3+VgPp{xV<3+UgbL+LA+_^^Pk z``a`L@D|^~xPYdAFgX&|h?BZx=_^=rQtd2B;JnlLnk5N%PI6`cr{^TsERBS#ZVZqP zWL+dMu!VGB!DTLhf0Ll{i|tG6EjUd99dY@%2iONYazu3Ok#wrmu@hAReMvf$Brx)R z0eycebeJSicd-WshIua7CaI>W_P{Xdz{Ftz{ZcvuG!Bfqi~|G1B!Lx|(PdyW5AaSp zu$h{bb&>%4f>p%&`Y)z@v3NQgRL{BS>i~yWcDpgaIv|}O=?n~!1lG2QE=aXB2iSUZ zYt|5b1xrp{z}DM>le!Gi$KCDJTSKJUD^7A1hTiQ$0;!Yy02_MVvjz0V)Q%mbj$Lt* zD;s)lavh|O^_(QY*4v`Xs6D{e+giV9R_YpNV1T~ZMW>D(pf7gSjVd*(?nISMva?Pd zD@-yc2KuR4OHRGj&(pEfx5XyevSc82T`p+$yuun+J+v?v! zle{BU`U*x}x}cv8Jx8jfE*ZHn`R#OG*?MykRzDwaaASb2x2zjgQWr<6^uc7Egf;A} zF8yriW!!jmR~L5EbvsdIo6t=Hn@L?fH>%DvOh4O%XI#G6{>>zTB_}8wdJnomNe8-R z$EGgN``OT28x|vBs-@XK0|K{cJwE35(6gB_|1R;Ey9!8Z;N(sFJ$4QDsXr>!ew1 zY1W+>=yxA9+0tB z>~>OZwlr4@g4h2_)hu@Yt;*GLs%O8Soqt&;brF`P%W9*aoqyeKRGr6x{1*0*Y!(to zo#OIrKDI{%wD(+!<0sF4LML^}v-!B>G7jXo&`8*J`C#%}NCG1+ewVy3ALUn&YLw>L zd|Y&5VAy#i%n#EzuqNFesrv=_VUoa#?5$KQBhTieTNkjOaLI`(n~#oENdlhB=#ppi zabiqpR_f+Telv{&i*CG>ay| z+Icn~m+unIdUooV#e2tY>cZw@-DwTD0>`)M5TT-+XcagfMmj?J_AI4Z}1^x2TTk6EW?vH9qx zS?qoEoaQa|K8{GI>Pl+Ix_ckW(XClI8VOgNrZ~0a6n~!e7V)JoLhH#`$^6utip3TRMlfGu1 z&Bq*@kKK}L>MAbB=Hn@sF34?Rcaj@b8V45Ks8X{$7uC*fadsu-c<*@0MYVHm6OOpd z+&N(r%2={=xeA-mMO||4Herr!!d1yYs)r=UHsQQe7x3Qkic_Xme6#nG{Cp-6wuVbklY|kKr)cJ#h7D5 zZ}o_v`X8wbu%YKQ1oW5wE@g(vv7xu{P62&(I+TXD5vSf_LvPf@?U7?cZ{iNYzzb3t zU_)=j#n{iW^Dpbf0Bxs{PUz){$M(<)UhKjYnU8wGcU`S($omG96SFq z&k?+)hIHoG&|97q(9fsx%Fe&l(*pX_bSUXS=92=t@yltN#fDzDQx~xFZ}mPwH8t=q z$A(_!R|WLWR0i1jw|qiCUz`r5aiIM+0sY-{C`n+!skhkqxA0v-^;|ktQkTpR1@sYL zNs}uZdY=3YQyrB#_7k>!K{c03l?}a-rhxu(I+Q)7za^lrOo!4)IN>xGu%Wl;G;y+_ zchrSymJPjS8HAm>&72kSgc6z>Tb^Y<;j)W8kYzvNs*F}nbyjCNp3rmgI%L`Tx2D3* z(!zSP?EG8!9no7KNb9XE8+w@~0sU$^lsa~~E})P6`xJf6^4@XgJpwwI4rL4er2<+= zhmt)oa#BEFn+jz^Z{&3X`k{0vjRTp#5zud>Lunjn|C4}T`PDQDuuV8}xi~cW%rq!Y zt%K^sy#iWJhcd4cdL|u8y|r2wR69UvAZj~7+0vYFgEFsfP?GCv&4pLtQgnl|W;sCz znO8R`%eCslD|__XPEfYqCfuMr9lJrPV^?Qgcpac`tL+384mCF@O&b|ED9g3t!mEhU zbApP%J2xov>IP+AkGb&5{;akWR5+>Jpv~qPEcN&tv=UrTlzAO<;gvn5Z8s?M>ICKUFc~)}>+2yGUU^5l?F1D^ zl-;1Dgc&y|^ZINTUipY}+X>2xs0lYH`v=^htOKJiyz+){+X>2((S#e6%&Qxe zeQ*0*c;!$7if+rqX{=C^Xdj=9e9=luQ}l-bb<;$ zp&OLPEH@~RS$kc074w!Gl*a)lsF=6hpv>zY7hd^rX4?(QygEUJpU?%GWz%6|#D!O0 zZ>{cjg3?#ec7w86?gZtK`HUNsyI_|KuN(*8c7rmnF3>D5`ZG>)6{|QGsyTKkuHNR- zEIu3Ac7yVY(+x^Wm~n#gf^T)F3$Gm9-gbdzc@tpuRwt_L_;I0{6Sti?LD~Dby2F8i zEW2phPQ2!6C~mt@&51B{Cn!5AGcM4qxR1z*S3a7!y4^tnIgTxFyFvNea)OFwq#KmS zfo%@FX4&P;QpX=#mvPw;PnYVD%Outk&1od-S7k z6x~&;l*WpUa=k^cmkHSaGGJ4H?WcRWH*67*cO*lA@KO=`<^Z`coJM3Hv9gv9p~sHT zr$c~PO-1aj&iJ?*mv0k3mx|oo@O^sWb0rmp$D(FyB%`xd7)g6aq2*848YclfXO;Jz zg+>`y4%e#VV}1pfeAgO)pR&@uqgtLS`=#-{CBHV^DAehW>v=2su-}+1R|}Q#(Yb1| zHOKX!z=*ZLSZ%5`zO#mRHtF)@bDM3wH%63!Sg;}v6-s41b_C3X74z)58oe8jw(l=A zNbEmd(#;P^4RqFAUijRQR!z)mC91&^0UcU<=wYeh0n(TEw;Vz^-(_ z?#H7wfSv6C+gCdgkX-J7-Me#qtW{{x2XUq|bVse)Dp%+DqUR3i-J~S`tUrF+e9Px6 zu^;SELS7g?zIVD>YtVJl<2!JP{5Zde4ffg{if^mbX9|;kt6T*5v=w}yRxQpH8igXB zbd6RpVl9Jrf=H*v4>n3DblZH<=S$5|&(T4fB0LKZmVnm%1I|&yVjc<2rGmCafsYVk%rMKNX@EkNnAu~8_?5Y7n$d^tkiu-4 zKCx^H;#h-(*PDVUkKbALNv|`hpu;l-ntysyLHlTc>`sA9PZp{tsNoyZK!r+e8W_)t z89RwNoQAs#*7MGGm2|HVYM+gGLK86|@o9Q9E{~=A%j>h-?b1Fx><}(CW2=3Ue52s^fbK z^jUc+xXSFwhF@icuuhHOzHnk@d=KnWRtPKbAf864o@D9UF^w`KPT3Ka()i)I#xWNE zLMm(wZ$!+DZ-XTv#5SLb9;FvtxZCTUaI;+bOe*X^tr4kwA{D*2Rj4r0qbacQ9W&)) ztR{BQwD_F%SP=(~(IXhW_I&@u_~Al%d>`9*89NRyDYXiCQ6AK~t*HGc3srniq-J(Z zgE+ciwWIb!v1%33HESuT5{c%#9Z)V%J?HEIzfq&+h^uVg%eo20(HS^G~Yf`yNAbswG_xKTi)kW5QRn! zQ{fENwQ7e!C1%F=5$IeBs8u*7Y`B#aP_-)N=d&poJYGh1En6YaDjZh^%90hdx7uW1 z6BhU6e!$9hM(E>%&PCL8+)gQ>{W_=ZC|F6b&nh$r&5BQO(F)#EZWN}4AZP3#f3o49 zfRK*bA%*H(wMM!&nueL4Ba3-Y8U*pN)6L0n!0KS`S?Vdmd5=V zJESlN*B$lWHgtAXsLf~!9OD6X-JTQ(hDs(lS;NC)yN zYX>z7=w=dFCJi$)OG9*z9a5{;W@}S4{B+wvSUbYr1;(>uU|o`9_JY;4WtHv?1AgsZ*Ej*(93N_H5+NTXRQA zD0}SL#Q2Ckn-p@`o=uOMXYASZ>GasM`AJB7HZ^;LJsY{_tP7|E)UIKBHoL~`*~D3o zJ)0P_=JI~ss@105PeNI;XH%;mv}YrC!J5mvd^7fJ_E6iiNoJ$=Y*OMq_G})K?b#^o zS#x)gmY%i_d^?D<1$#EB;eE_*P*HB{eYL8;v)rJsu`QKuGKkb) zC0N$ai3in`t85XqCF1cPjZ_oroFNWTS-Md)YVX(WxIxsoDskV8;;8ZaYS^w6jL#=C zjt89!m4j8@&2Ilpu>SOD`$LQk^5OKQrwGRG{zincQsHECyARWzhWiD1A8y3qv55Un^wsly64bI9=O?NCqL%x*<_!yx8wYzH3xB zY`hjM*g+5NFOZFPR*tgYjn;;z;`jMj22`i_R%s$zOxCUD47|)c3nvfY`DW7NiDW&l zz=Ik>Ws*@$49?cpj3T#?3?y<9+=zh-URdYm!U@y#@h*3*(T9fdrnUD|A!R-CG7??D z%bg`@96#<`kxsbd@D8-{Ome2yR$LZDW7ld{=-1PuL`YkaJCZyS&5{6EmMy{IfoN%L zx|g{rB<|#1K^wOh$f{aM&TqC#SqcpCb)xwML1yYxVOP=h}kCtxI?1=ZNBl;To1yn|i8A;WpMU9Kh=q_SU z-V*q_a8sDA2$augenrgOzn>1JX!O;xfPOw5N<-nqvVi_19XbGL`##aJPx!Xdt;A;a z1G=zXPP(0(7d?=IYwoyl{RO}Q!V;}7HUEyzi!lsoxn%`Z?)TYUb8(k&{yow z7KbLM25~h$k0+p*HKskDAO}q3nlWETnxXr1SvKQ$gUVw-$z)wJ`GA3gKw5=KaJL}) z{GS6zFkLB{2j*sZkPqgo^ZzB(PLHSx3S1ECH)`}gQJ$@1maZdmudn6Lw{8LxCnzSg z(Fb0-Z;0DK(Grt$Q{@@~m!;{Y88C+QV(=3g$%9`&W%X(C>I^EewGt)?@uLtdin?Dn>xXGng<05=d44LzPy4gUXsstT)xMYMtui{@xBF^O!Io&tDgBx~x^= zi?z9GD}+DO0UsKx2D5ba-s)DNuEXC`pK7!MW@wLJs0)5BbfC}tX!zL<@CZ9(9<(Jp z?@nXq@Js_H?+*OY@&#L-VP{8M!EBkuRxXA;GD#*}*xOxeAf5!CV!_*5hf0{YSefMx zWg>Fp<9Hnyi`WY%|5Nn2_QV9k+T_WW-|X8yhviqJ597%Z9)HmCUSn8OWulUvJh|g! zu>u-R3}t;-lZbB;6o!8q9~h%0N&m|gU(_f>cdmmNigntKUwVxo{Il;X6;5VNR)0N_>+T>l4aktYxCD zh5i(eISFFa+JqE}h9Hg_RHCKlsx;(DhMJ=DS37k6WT*&w?37&Vz3~T13!+uPj;rhb zJ>3D_;vuHULyRuf?obLRDa4nri!631QWx4t7G_r31b-B?fOJmV1kIC8ta&Rm$9sk` zARCLd-ekGe?90x>m5HC?@Nkj-hDR~xQUsL+W7(EOB{a>eiA?`ZY#WY53zgv*2N5a@ zZdB|v#93ztDiDUUP&5bnUue-vXX%nqSgaPy1yt5L8w}vYDih)eR3;26&6Cw)U+<p)aK(^d3=BTA(nokAXdEyV>IG!>%FMM- zsg@(NIajAON0YVVVD+|npM0M+*&4m<1hjV(HDhBR`?>{BOG!LYb>(7fwmzN}&!w%( z<*@engBtpL7bMu6;o}+$vRAZ69FW@)We0~ghNy_(FNGqB&h;|u-(~m zvx#Ug5FJgb5Fq$BZksPRNnRrsh|13x`HC;4NuXD)1q;KOBqai5Z}m7r95^t;N|9PB zwE`tV-q97Kv5JXJvyjY9I4@G_qlwZlA;`H=^!s$ONI*;51`!R4X!)$6()!IWYR zp)~BzyiR;&9}4YyPSaDoA^inmk)rpPswIV%9a z7f=xWlFj+WEu}5s$e)}XCg13}G-jC8X9TIw2c&deCm662uZwzCTSnwExrs(6_MM>0 z#p~nC=5p<(GTCO8zMW;5Q4LbQ`YVN&{)4e_(CCtX{JmK9N(m?u%!R{#u`CPDp9)--(VrX9S_VkY{4b`B@3atJ;wTeGl8j$)S#;1|S$vfZPWsEe;zVf-6F- zmBqin<)Sf+0FI`N(I%W&TLYCzq^^~kTL#>kq00%qB+OAVNwp=b|3$SKy%hM+re<4x zb=qR=Uf0=CMpfX4t>1*YK&5S1&s2f73Ub4Izr=`qQRXMXM^CW6>6&ms@TG%`(%#b_ zS`oy))5)4(;n~=zt-^e<2-1zPoxlgeI2_ z=^T?!>v8E2lJO(cAtd5G=@63eNIHZB+?5U?`3|Q;NW9&N5H&K(Rn5FHGLvp8kX+W( z6G4%2%Qwa?qJwd!*4Tq_yW%&5tvr)RN_wfcW6ci6H^_lQuU?22mSQsBGxCE0iGWS4 zH1OA0u~4Pe1`U`C#!y6vB2Hyi{CNyXyv4ryaxo9+!I?mlm?RWpIT6up?m|R93EY@S zm>qcoLPl=L-25Xo%}{Q&*5WG?gme}XrNj1mb(+0vsAl9Dg3qr7Q8CPCp|lq#rsfqY zBd`33qN=q!{l=uiEZZoJ;t06{jU*C67|)S%sWqce6NxBn-!uvevYZIP)`bFOlG%Y% z@h~++LWlg>PCTam7o8})EaoY^0y{ za--o-(cMmcfVPc~7AvM2#Tec+$(O`LHLz%CU>sgMj$Ob?jgBL>4Q(_&WgZH6m7zYn z=-))eY3G7zh(Dqf=r>RqHK_1x5p7+;Xq^Dz13O%+?JG3+D_S&~68+nFG>?&0*&c}JD3Rl+X|<1z3Dlnyg{)hz zAl2G<9oG|K8@D-*HCz$L+-OkojLkW$@aUUG-tr#dtx>BaZ#@^Bf~|P(oX@ufEK4`N zhUntnH{!*0-pILlp5n9ItXB$ES{41S>@Y=Jx24>KH@#FlK|=YX6jZZT!FfnREm=`M zEuV25j1DQC-D{Ix2z2V!IH)u^eVlJRSUntXm2PqS#qm67+;LR87Gup@j|_6&zs$&h zDO&U=(Rbs;0^-?#xiPjv^45s9L9EKiFN zw2{|DA?xs27iY$s{%iwx@!>AGai4Y>P|<4*Chmj5RxQ!q+9{*IPyw7=<5e7OK>lZp zvN9i%MfMGby1*#Fmoz(G!ik0($VIRk^BsBXbu*V+(Kdwh+9i8l=7aG((ItE?W#Oms z{+yg{p78xTeH=Y8&xp64?y0IEsIoy0f~?UVh(QF4c}5mWB8vu7lpI+fS8uEbIT8Vx z-jm~*S_Z5C9&bxERC3Xfzb?5T-_q3|j?SAfhT2fxv*R`DJa4x>FH^DSEz2-x&5Kf4 zIPSy*(AN)1Ovr$Gh0|kjC_Vwkc7g{{&D5YWYV3Wh+Co&4J)R*dS!0$DJfC;<->oRl zHu1?)2O9zL0a`&%)EdV~?}5&C4lSg$0R5*pivLY@8VeJn&RGgyp`~+!Pd$uwu9p{8 z%27+A#((sKe=skoxBZLpDaoj}iTR>L19QD|jZELV=n?T5PCZI22LDTvm$7(KU8A*- zT!ka@$XALM3Z6+U^sjhb%=40!XI&c&DyuierKz|Iv=w!5g=Re>1yojy+JZj0E1wV4 zl@hmA$l6-z+%ck3syn%2P?<135`%ermjujrTRSEY0Z~cjBA~L|nHLgdCn|;@lUhVV z;Vz*+evWylH6(*EGfg}SeqYhM3KNzO6>OzGyCaEpDk2?ExKtQ%hl#2g}7EN@f zg07Wx=x=k-0hKjl3(b(OqGD?ksB}B@G<9%_gh6G=r9~v&xHRxHV zi~o}N0hQ&>TF1(gSYFTsm66W+LM=$*L8XC8-Hi%Sve5#S)y`BzFRPl(zd>cK^SDcW z!=1z3Bfe`ExSVl`iZMzB6MOJ+1J>PnI;SR66(+MH1ymLs8qQqWXs~iFx~LVgl1ioC znF>WIQ-pG|YBDbiM*Kn`H5KukynUc~gIqiZDwYpK(E*i=i*!l6+*67DL{vJS~Ylul(AY+Tu2F)K`nbWwBzQ zc)OUd)Rgg%jem+0qE#nov|lG^?0m!{Jo?cqYq)CQssLnr(x345yn zL&K*}6poQAt0i42I(AugMX`c=z{Xp(adsD0>)8JyAMeD^39rqE45~O@R4$GCrFo!E zOR_rnPLV~lFFdbAX;f;#8RL?evWW2&E~XyoV*1o_TxQcnyi35>YQNiBU8~Y$!$CTt z&Y4`Jc{#i_vv~lKRs(&+TiA2IWQ4`3hS1@X!Tup!iLfP?H_EL(+4h-Hx%|-ZK>y&t z;E+*nBDGwue;}XRyg5H?lv_>Zb7*r84~yYUalCom*3+-VW`FuB-~dooQa9bvMW{LU#??Js zZG*fbOF&o%GlGo=?YN$V09;BJyowO$%dSG&OqL&zOR9)xJF zS;2AS9xD?2R3VC|j7SD0>{&cXMV$hf3wbYENh;{jfb5x$NOicf-4U4^5;RYDL`pW7 zIs&tT;wdXI5@9wcZBcz)fRfNOS)!}IBEG>p|J^WW#}JS@*A$-t8OY1>?!SLCj8-gw z{04StMK}OHaSEKSqsTeyCy53pf>hQ@irET!bHz$+3ad&Ad?7`b zpk2WMW%V5pph3h$t*5OT#6bEI7UbQ5*FMr%fvYggfp@AC{!V^i}+NzuQ0IA`l z(%RwDCp*EE!BY8nxg_o!B~e-_@>j3OWvt{7V5$#Rty!s6{Z_qJslX!%yN4q5mZgzp zIt7p2i|i*_eTE#|NpW#N9hJk0`H|C5K||7_9Fm^ctp*&Sez{_)SQ;8sng!%}t5P9u z5OW>PJmTgx)w!cqJs`MbF>7UUQcxokEKpBA>ZwqR5R;gc!5`X(_rJ@)70ywE-ZF3rMw zJcK(VdH!e+sjqmZp&A_HV{J8+)Vr-xrxC0+HNInf{}>ej0;Qj{^kHgW9**7JbX zWlL^07=@pmmffc%hvp80aKv*IaZ_rv>4+x~sI(=O*BXO00HpK}rd1>R<-E0D&@`eW zEhwv$h#7H}9BO>4)$Im~*j{8P|UTXorid#P$Vs}REnP|&N^->5l zAvrZczM!H2=FW@ASLZ>@d|z$>*%1=3An&$HAi?eKD_SUv|0%3!N6_ zRPlq>iv1eht&)|O0e?H_cO@)bn}!>-+1%NQpl{K+Ggg&U(=%wUUM9YluE#4~QZyl6 zGKqj$kbUr5Pqbj9;-0lmbC{SUIT&O(su_IGdkp!psfU*pl$EDcI%8dcvrnH`m9$Bc zl9L0$Ezzn~5VtU=daY&#FAhOuMEVSuu8TK&u1aULJ0$X;bzMr(+;j(K zKUAGh2F+Vh&`uG3A$sp0xIY8LMNc8__P%!BP5CxA@Qq*NLb$@%7$Nn zTrq}F9%K~~h$RD|Iv&^KZ4+_30y)Br}$-HQXIBx7TzFA9|Ml-Ee3z_M}ZH(G$MF96Kz0Gr0!taFoe z!^lmOwMwfr$$wGF?hYj(JbniP(A5r5+=d6#LI;$-L=5112QWR;UMu-TH*3VfMkRsM zxIm3`Ac$pst-*Y*cIXOn3KPXlhkDf~0O(SO%K7{^aBCf^)^~#eJZcbCH3p|Q(t|xk zD4`MOYEV)4q^l1;{x^78=^Us@7n7xhe1gh^0~KZ_&Vl|NRF*qaq0sCO!I7(-&!Z44 zx@PlV;AN>ZFG{-l?-;S#U zW)9*(j9QhS zc1fXv*LfR-lSJwPu{!zCljCMn&~GACI4bAxZ=kZ)`OHC@E)z9k*!rCZUSDZZ8P)^K zSKssoVxzHBw{*%GR};Y9I*KSwvh>JEUpDSf2%~Uy>n^;8K)}^xU}RVOn6w@AuC^j3 zFJ$G5HbAUx5F>5DPEp?`ImYu}W3gZl<4z7HKS}z$oqd?}b{5D_7?<*h6=%N4Vf8?K z#4v^e2AC#^2$Blj3VS-aa)5T!8uB9K1*2J*ReLw>f~CK)k1t&m-S?oeI1mkiU42Zh z48Y@>yj>*!l(=T@_h;qu>5#aREF)J3`jRsy2op<_^Q5`1$uUMRbWr65qe{l0kq2tk zo$%^6%h=4@PWN4niM^a9qseTc;sLqv7edN?%5Z)|IEUD&C#15REERnsl;f-RlElQMwg9F6~y>-K#vnGp(3EQ6sP6g^2h7EOFa6y`reJ+4fvbI zK!13L)o;C<_TzV4PCr-m4y=<9l_;*BdZSL>G2<7HNkNM;A4d&Lws%uBQ~W{R?J)!A$rM#|3pd{8!;$*)T8!i{82?^BPpU|^H+ z_tW&|AJ+*ohCvZKWw;a3d&*Uvz;w}hZPxq0Is!G-1Bm9rko%6S-Dper@oPH4k6>*s zFMWSjPbaXT8Y)7Ty8N!9;)UpFxM+HR+X1p9alcF1qeRa(uB;>n|f^_}wGJMZyNjMf_mHb?!&7(yaoc{XfNl23@_*>qfp zV&)fu%IUMjBv)%}B)b@468ES)`FJD8F1=qRQkDEAzwJqqgi2v+XzO({m7XbWdS6t( z;^t4(v$2o&a-NV0Y8R>4qn=_uD)6siulR*=z$A}CVaPW%#K_#(2S=#a4>!3~tQdWf z|KgNTG@4Y9UG~oS3JZaEdxIRW}$ouzr(q`{fmWgOPvS{iydT7p@C4-(e=%Axm-F_=lk#5nmtv@Xukh4Z(tvkQZ!Brhd*sGg(vWvn zCGmw{-^OoZ)lGgzJP?7E*M6GK_ia)c{=K2(KM0Z;e^>5qc2dfx_q-=PEmSI=`KlmO z*A*U3ybA$9)fvh5Z&bu%<&}@%ZvsH1yvpA8bhCWe!0?s=fGQu!{)IlXe8^VtUK8Z2 z;^Ew%1i6~~kp1HMH!13>bU62OL9Q-MUz(f*y<4;K(&60q1-a4EYI^pr%_S8NvR@fw z>+<0#+WXf4pqP(j7xRidm%nRERBKj(Y?O{?-rOH8n~#=#FvzB|vCPK~M9cO^%Ps`j zR5q6RgCJA4na4IBe~%0*%BsOS?_)upXzf6>*1n-o(Ys=qZ$YMV5y_1Q?>|Cma+kro zd$Y#j7<9WISK|g@ojx0q>S)CJ;d&#(P8Q>RgI<#Vs1F4z+lV zP$J|b+Ho$N2my)ITes@+=mwGao=~Dbh2lNxR*hA169wi&IX(@W{=ME`hSE4<0clSh z(G+N;{`iM-ULlkgIwm&l{kbJ0=M8VuWaRd$_r_4#EJEDrxRiIrb`7KiJTvG$FP27! zpmN>^5>mY#J440kwJ|38;c%)vyOr}EeOm}CQ}f<^38~(7yET*!e)0QLCGUYqGT&W0 zP8AY^-c@_TWppN$_m(V~6mI?Rmb@ZvJ>9ui6Ybq}qEK$#yRpx&iaSkTpOjfbf76Ah z{}9SF_UpZ;K1*-KZeqKHz7wB+SpepmAw78 z>-wU({&B>mc%QN6PgUlcGnLx3chf!_iRmCX)O$k+q~1B8+t|JT2xaINdD;D%=d`VHDskoGjZ z6toE^%<4~fgbUojL0y+m6N2;rM~KZ?K!U`_Lb-K>lD7)gliod}nl1;dooGP$J`qaY zfv5(*;l23T8Yq%r$A{8(A3SvM;9+mWAr0%@G>Q9rH}Se!W$Nu?*T z*>Zie#FbDY zg$EqY-{u`DYM@Bl>-Cg$8m{@k=e;+7*tL~a9-Q%R|L@5`ZN z;$km2yJad)U~hhJ-unw9`L_IC@7C!!7^!*h)1hRgN^B8Oncf*)h7((C_RWTp*`g51 ze;7)p{TlE3vMw&(-1S}Tt`uAeV%?d8u^=`aJQza5DPR4E0 z;!LOafy8|8+G9z@roA_Y(#6%zI45*yHUvi8;p9Eo_V7+eQ^h{%4?~HK!USXb*FfymTouOnH{Ybmldt5_9bzr_=>vSkj*o1lS^Px0y^6d9#dFkanzNrZziW)I4 z^VI@+h|V*Ph4LEyGzI@R=v}xS=zltg@cK|b>jWKAXnKDfN|qNcd*?!FC+NZONpwUR zCnE8o-_X)5g!3>6Q1ju74%Rx6Y(8W6F-tCMzIWwZa@nauEARcXJ+t5YZF}Z`_pkO$ z@9=S5B?1SY0Dj(@K> zfcU;p8gHGBLo2@)P9&?364#&9rFk=UT*gJdB$R>My)PLxWTnfwwy;3s1~eL+MPU;kV`*RqsDS>AX^4GEMKMSL!OJ#bHnH zgW)vnEHU|`X#&Y()A4-|VV+dqpU;8Re zkV8?u`$H+r_>}j)P|`FH`rZ#hNsMZG*S=bl5=nLMmUvpV;!T9oj>{VQUlS`!ym)>* zRjAeP#FJ^Q>isyLN{N}*#^}!Y^Ij>QDBnx*-V)D{bKYl-be`-U^ST&uHsriJLdoQs z_ud{#5K1}VeJqp~IW_HlKa{gu9M1M0^((q2QW~s-UTY*t^YBZN3^80h;q|(Fp~wLu zV{;|A1>P9Skk3PIwiDfl;*TXN-IJ%b`3-9UUb`@Ta~}lS3_Jo{jSr0?$jxz~|ib-W19ZIwqSm2^%~2krJwgb)RKd6tgXh_3biFd+jDJu24cWa=ye~yz&p=841b}m2XUHKjjR;k|ovBW0s z0jeO#>3gB{dXWwY3pSqn-Y5}1I{eX4B9^Ch@2=m{D4L4?Z`$4iK8_-3A1*LC9LdBZ zm~0D>H)$ndk}W5JgRo@#z<^louB1h)U9r2eEppB|XE<`sIo^@OVZyuWtx zM)$#rG#b#ra<02F=$QC%0LMXQg$|*-a-F6|o%JPNwhK*+XjhggalMzS2VFFkkoLRL zBhV{EOPFV&=~E3B?JPNpk?F#a^-W$1PtWrv6!ZXXd$U14N_S{5*Y2oPsr?pDv`2x9 zG_c%TT+oe8d085`)f3H?CoLR6?T7Q(Wra!)X{`H%ajH%RPjl1Typ*o}@_aA4Oyl_V ze)z6PBuY;j&=?hN_w*>)IGt`l6Lhx$ZK5{~Xfy45ho@IO*HZy#OExg)E!wh}CH=`| z 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≪S~HV~+FN)kLZc4+M$&I9II4 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