@cryptotaxi247 / kubo / commits / c40fe2af1

feat(blockstore) write cache

vendors hashicorp/golang-lru dependency. (Mozilla Public License, version 2.0) License: MIT Signed-off-by: Brian Tiger Chow <brian@perfmode.com>

Brian Tiger Chow committed Nov 30, 2014 at 21:25 UTC c40fe2af17b8856587f0e7d9a8d2fe42ddcc277a
8 files changed +729
Godeps/Godeps.json
+4
@@ -89,6 +89,10 @@
89 "ImportPath": "github.com/inconshreveable/go-update",
90 "Rev": "221d034a558b4c21b0624b2a450c076913854a57"
91 },
92 + {
93 + "ImportPath": "github.com/hashicorp/golang-lru",
94 + "Rev": "253b2dc1ca8bae42c3b5b6e53dd2eab1a7551116"
95 + },
96 {
97 "ImportPath": "github.com/jbenet/go-base58",
98 "Rev": "568a28d73fd97651d3442392036a658b6976eed5"
Godeps/_workspace/src/github.com/hashicorp/golang-lru/.gitignore new
+23
@@ -0,0 +1,23 @@
1 +# Compiled Object files, Static and Dynamic libs (Shared Objects)
2 +*.o
3 +*.a
4 +*.so
5 +
6 +# Folders
7 +_obj
8 +_test
9 +
10 +# Architecture specific extensions/prefixes
11 +*.[568vq]
12 +[568vq].out
13 +
14 +*.cgo1.go
15 +*.cgo2.c
16 +_cgo_defun.c
17 +_cgo_gotypes.go
18 +_cgo_export.*
19 +
20 +_testmain.go
21 +
22 +*.exe
23 +*.test
Godeps/_workspace/src/github.com/hashicorp/golang-lru/LICENSE new
+362
@@ -0,0 +1,362 @@
1 +Mozilla Public License, version 2.0
2 +
3 +1. Definitions
4 +
5 +1.1. "Contributor"
6 +
7 + means each individual or legal entity that creates, contributes to the
8 + creation of, or owns Covered Software.
9 +
10 +1.2. "Contributor Version"
11 +
12 + means the combination of the Contributions of others (if any) used by a
13 + Contributor and that particular Contributor's Contribution.
14 +
15 +1.3. "Contribution"
16 +
17 + means Covered Software of a particular Contributor.
18 +
19 +1.4. "Covered Software"
20 +
21 + means Source Code Form to which the initial Contributor has attached the
22 + notice in Exhibit A, the Executable Form of such Source Code Form, and
23 + Modifications of such Source Code Form, in each case including portions
24 + thereof.
25 +
26 +1.5. "Incompatible With Secondary Licenses"
27 + means
28 +
29 + a. that the initial Contributor has attached the notice described in
30 + Exhibit B to the Covered Software; or
31 +
32 + b. that the Covered Software was made available under the terms of
33 + version 1.1 or earlier of the License, but not also under the terms of
34 + a Secondary License.
35 +
36 +1.6. "Executable Form"
37 +
38 + means any form of the work other than Source Code Form.
39 +
40 +1.7. "Larger Work"
41 +
42 + means a work that combines Covered Software with other material, in a
43 + separate file or files, that is not Covered Software.
44 +
45 +1.8. "License"
46 +
47 + means this document.
48 +
49 +1.9. "Licensable"
50 +
51 + means having the right to grant, to the maximum extent possible, whether
52 + at the time of the initial grant or subsequently, any and all of the
53 + rights conveyed by this License.
54 +
55 +1.10. "Modifications"
56 +
57 + means any of the following:
58 +
59 + a. any file in Source Code Form that results from an addition to,
60 + deletion from, or modification of the contents of Covered Software; or
61 +
62 + b. any new file in Source Code Form that contains any Covered Software.
63 +
64 +1.11. "Patent Claims" of a Contributor
65 +
66 + means any patent claim(s), including without limitation, method,
67 + process, and apparatus claims, in any patent Licensable by such
68 + Contributor that would be infringed, but for the grant of the License,
69 + by the making, using, selling, offering for sale, having made, import,
70 + or transfer of either its Contributions or its Contributor Version.
71 +
72 +1.12. "Secondary License"
73 +
74 + means either the GNU General Public License, Version 2.0, the GNU Lesser
75 + General Public License, Version 2.1, the GNU Affero General Public
76 + License, Version 3.0, or any later versions of those licenses.
77 +
78 +1.13. "Source Code Form"
79 +
80 + means the form of the work preferred for making modifications.
81 +
82 +1.14. "You" (or "Your")
83 +
84 + means an individual or a legal entity exercising rights under this
85 + License. For legal entities, "You" includes any entity that controls, is
86 + controlled by, or is under common control with You. For purposes of this
87 + definition, "control" means (a) the power, direct or indirect, to cause
88 + the direction or management of such entity, whether by contract or
89 + otherwise, or (b) ownership of more than fifty percent (50%) of the
90 + outstanding shares or beneficial ownership of such entity.
91 +
92 +
93 +2. License Grants and Conditions
94 +
95 +2.1. Grants
96 +
97 + Each Contributor hereby grants You a world-wide, royalty-free,
98 + non-exclusive license:
99 +
100 + a. under intellectual property rights (other than patent or trademark)
101 + Licensable by such Contributor to use, reproduce, make available,
102 + modify, display, perform, distribute, and otherwise exploit its
103 + Contributions, either on an unmodified basis, with Modifications, or
104 + as part of a Larger Work; and
105 +
106 + b. under Patent Claims of such Contributor to make, use, sell, offer for
107 + sale, have made, import, and otherwise transfer either its
108 + Contributions or its Contributor Version.
109 +
110 +2.2. Effective Date
111 +
112 + The licenses granted in Section 2.1 with respect to any Contribution
113 + become effective for each Contribution on the date the Contributor first
114 + distributes such Contribution.
115 +
116 +2.3. Limitations on Grant Scope
117 +
118 + The licenses granted in this Section 2 are the only rights granted under
119 + this License. No additional rights or licenses will be implied from the
120 + distribution or licensing of Covered Software under this License.
121 + Notwithstanding Section 2.1(b) above, no patent license is granted by a
122 + Contributor:
123 +
124 + a. for any code that a Contributor has removed from Covered Software; or
125 +
126 + b. for infringements caused by: (i) Your and any other third party's
127 + modifications of Covered Software, or (ii) the combination of its
128 + Contributions with other software (except as part of its Contributor
129 + Version); or
130 +
131 + c. under Patent Claims infringed by Covered Software in the absence of
132 + its Contributions.
133 +
134 + This License does not grant any rights in the trademarks, service marks,
135 + or logos of any Contributor (except as may be necessary to comply with
136 + the notice requirements in Section 3.4).
137 +
138 +2.4. Subsequent Licenses
139 +
140 + No Contributor makes additional grants as a result of Your choice to
141 + distribute the Covered Software under a subsequent version of this
142 + License (see Section 10.2) or under the terms of a Secondary License (if
143 + permitted under the terms of Section 3.3).
144 +
145 +2.5. Representation
146 +
147 + Each Contributor represents that the Contributor believes its
148 + Contributions are its original creation(s) or it has sufficient rights to
149 + grant the rights to its Contributions conveyed by this License.
150 +
151 +2.6. Fair Use
152 +
153 + This License is not intended to limit any rights You have under
154 + applicable copyright doctrines of fair use, fair dealing, or other
155 + equivalents.
156 +
157 +2.7. Conditions
158 +
159 + Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
160 + Section 2.1.
161 +
162 +
163 +3. Responsibilities
164 +
165 +3.1. Distribution of Source Form
166 +
167 + All distribution of Covered Software in Source Code Form, including any
168 + Modifications that You create or to which You contribute, must be under
169 + the terms of this License. You must inform recipients that the Source
170 + Code Form of the Covered Software is governed by the terms of this
171 + License, and how they can obtain a copy of this License. You may not
172 + attempt to alter or restrict the recipients' rights in the Source Code
173 + Form.
174 +
175 +3.2. Distribution of Executable Form
176 +
177 + If You distribute Covered Software in Executable Form then:
178 +
179 + a. such Covered Software must also be made available in Source Code Form,
180 + as described in Section 3.1, and You must inform recipients of the
181 + Executable Form how they can obtain a copy of such Source Code Form by
182 + reasonable means in a timely manner, at a charge no more than the cost
183 + of distribution to the recipient; and
184 +
185 + b. You may distribute such Executable Form under the terms of this
186 + License, or sublicense it under different terms, provided that the
187 + license for the Executable Form does not attempt to limit or alter the
188 + recipients' rights in the Source Code Form under this License.
189 +
190 +3.3. Distribution of a Larger Work
191 +
192 + You may create and distribute a Larger Work under terms of Your choice,
193 + provided that You also comply with the requirements of this License for
194 + the Covered Software. If the Larger Work is a combination of Covered
195 + Software with a work governed by one or more Secondary Licenses, and the
196 + Covered Software is not Incompatible With Secondary Licenses, this
197 + License permits You to additionally distribute such Covered Software
198 + under the terms of such Secondary License(s), so that the recipient of
199 + the Larger Work may, at their option, further distribute the Covered
200 + Software under the terms of either this License or such Secondary
201 + License(s).
202 +
203 +3.4. Notices
204 +
205 + You may not remove or alter the substance of any license notices
206 + (including copyright notices, patent notices, disclaimers of warranty, or
207 + limitations of liability) contained within the Source Code Form of the
208 + Covered Software, except that You may alter any license notices to the
209 + extent required to remedy known factual inaccuracies.
210 +
211 +3.5. Application of Additional Terms
212 +
213 + You may choose to offer, and to charge a fee for, warranty, support,
214 + indemnity or liability obligations to one or more recipients of Covered
215 + Software. However, You may do so only on Your own behalf, and not on
216 + behalf of any Contributor. You must make it absolutely clear that any
217 + such warranty, support, indemnity, or liability obligation is offered by
218 + You alone, and You hereby agree to indemnify every Contributor for any
219 + liability incurred by such Contributor as a result of warranty, support,
220 + indemnity or liability terms You offer. You may include additional
221 + disclaimers of warranty and limitations of liability specific to any
222 + jurisdiction.
223 +
224 +4. Inability to Comply Due to Statute or Regulation
225 +
226 + If it is impossible for You to comply with any of the terms of this License
227 + with respect to some or all of the Covered Software due to statute,
228 + judicial order, or regulation then You must: (a) comply with the terms of
229 + this License to the maximum extent possible; and (b) describe the
230 + limitations and the code they affect. Such description must be placed in a
231 + text file included with all distributions of the Covered Software under
232 + this License. Except to the extent prohibited by statute or regulation,
233 + such description must be sufficiently detailed for a recipient of ordinary
234 + skill to be able to understand it.
235 +
236 +5. Termination
237 +
238 +5.1. The rights granted under this License will terminate automatically if You
239 + fail to comply with any of its terms. However, if You become compliant,
240 + then the rights granted under this License from a particular Contributor
241 + are reinstated (a) provisionally, unless and until such Contributor
242 + explicitly and finally terminates Your grants, and (b) on an ongoing
243 + basis, if such Contributor fails to notify You of the non-compliance by
244 + some reasonable means prior to 60 days after You have come back into
245 + compliance. Moreover, Your grants from a particular Contributor are
246 + reinstated on an ongoing basis if such Contributor notifies You of the
247 + non-compliance by some reasonable means, this is the first time You have
248 + received notice of non-compliance with this License from such
249 + Contributor, and You become compliant prior to 30 days after Your receipt
250 + of the notice.
251 +
252 +5.2. If You initiate litigation against any entity by asserting a patent
253 + infringement claim (excluding declaratory judgment actions,
254 + counter-claims, and cross-claims) alleging that a Contributor Version
255 + directly or indirectly infringes any patent, then the rights granted to
256 + You by any and all Contributors for the Covered Software under Section
257 + 2.1 of this License shall terminate.
258 +
259 +5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
260 + license agreements (excluding distributors and resellers) which have been
261 + validly granted by You or Your distributors under this License prior to
262 + termination shall survive termination.
263 +
264 +6. Disclaimer of Warranty
265 +
266 + Covered Software is provided under this License on an "as is" basis,
267 + without warranty of any kind, either expressed, implied, or statutory,
268 + including, without limitation, warranties that the Covered Software is free
269 + of defects, merchantable, fit for a particular purpose or non-infringing.
270 + The entire risk as to the quality and performance of the Covered Software
271 + is with You. Should any Covered Software prove defective in any respect,
272 + You (not any Contributor) assume the cost of any necessary servicing,
273 + repair, or correction. This disclaimer of warranty constitutes an essential
274 + part of this License. No use of any Covered Software is authorized under
275 + this License except under this disclaimer.
276 +
277 +7. Limitation of Liability
278 +
279 + Under no circumstances and under no legal theory, whether tort (including
280 + negligence), contract, or otherwise, shall any Contributor, or anyone who
281 + distributes Covered Software as permitted above, be liable to You for any
282 + direct, indirect, special, incidental, or consequential damages of any
283 + character including, without limitation, damages for lost profits, loss of
284 + goodwill, work stoppage, computer failure or malfunction, or any and all
285 + other commercial damages or losses, even if such party shall have been
286 + informed of the possibility of such damages. This limitation of liability
287 + shall not apply to liability for death or personal injury resulting from
288 + such party's negligence to the extent applicable law prohibits such
289 + limitation. Some jurisdictions do not allow the exclusion or limitation of
290 + incidental or consequential damages, so this exclusion and limitation may
291 + not apply to You.
292 +
293 +8. Litigation
294 +
295 + Any litigation relating to this License may be brought only in the courts
296 + of a jurisdiction where the defendant maintains its principal place of
297 + business and such litigation shall be governed by laws of that
298 + jurisdiction, without reference to its conflict-of-law provisions. Nothing
299 + in this Section shall prevent a party's ability to bring cross-claims or
300 + counter-claims.
301 +
302 +9. Miscellaneous
303 +
304 + This License represents the complete agreement concerning the subject
305 + matter hereof. If any provision of this License is held to be
306 + unenforceable, such provision shall be reformed only to the extent
307 + necessary to make it enforceable. Any law or regulation which provides that
308 + the language of a contract shall be construed against the drafter shall not
309 + be used to construe this License against a Contributor.
310 +
311 +
312 +10. Versions of the License
313 +
314 +10.1. New Versions
315 +
316 + Mozilla Foundation is the license steward. Except as provided in Section
317 + 10.3, no one other than the license steward has the right to modify or
318 + publish new versions of this License. Each version will be given a
319 + distinguishing version number.
320 +
321 +10.2. Effect of New Versions
322 +
323 + You may distribute the Covered Software under the terms of the version
324 + of the License under which You originally received the Covered Software,
325 + or under the terms of any subsequent version published by the license
326 + steward.
327 +
328 +10.3. Modified Versions
329 +
330 + If you create software not governed by this License, and you want to
331 + create a new license for such software, you may create and use a
332 + modified version of this License if you rename the license and remove
333 + any references to the name of the license steward (except to note that
334 + such modified license differs from this License).
335 +
336 +10.4. Distributing Source Code Form that is Incompatible With Secondary
337 + Licenses If You choose to distribute Source Code Form that is
338 + Incompatible With Secondary Licenses under the terms of this version of
339 + the License, the notice described in Exhibit B of this License must be
340 + attached.
341 +
342 +Exhibit A - Source Code Form License Notice
343 +
344 + This Source Code Form is subject to the
345 + terms of the Mozilla Public License, v.
346 + 2.0. If a copy of the MPL was not
347 + distributed with this file, You can
348 + obtain one at
349 + http://mozilla.org/MPL/2.0/.
350 +
351 +If it is not possible or desirable to put the notice in a particular file,
352 +then You may include the notice in a location (such as a LICENSE file in a
353 +relevant directory) where a recipient would be likely to look for such a
354 +notice.
355 +
356 +You may add additional accurate notices of copyright ownership.
357 +
358 +Exhibit B - "Incompatible With Secondary Licenses" Notice
359 +
360 + This Source Code Form is "Incompatible
361 + With Secondary Licenses", as defined by
362 + the Mozilla Public License, v. 2.0.
Godeps/_workspace/src/github.com/hashicorp/golang-lru/README.md new
+25
@@ -0,0 +1,25 @@
1 +golang-lru
2 +==========
3 +
4 +This provides the `lru` package which implements a fixed-size
5 +thread safe LRU cache. It is based on the cache in Groupcache.
6 +
7 +Documentation
8 +=============
9 +
10 +Full docs are available on [Godoc](http://godoc.org/github.com/hashicorp/golang-lru)
11 +
12 +Example
13 +=======
14 +
15 +Using the LRU is very simple:
16 +
17 +```go
18 +l, _ := New(128)
19 +for i := 0; i < 256; i++ {
20 + l.Add(i, nil)
21 +}
22 +if l.Len() != 128 {
23 + panic("bad len: %v", l.Len())
24 +}
25 +```
Godeps/_workspace/src/github.com/hashicorp/golang-lru/lru.go new
+134
@@ -0,0 +1,134 @@
1 +// This package provides a simple LRU cache. It is based on the
2 +// LRU implementation in groupcache:
3 +// https://github.com/golang/groupcache/tree/master/lru
4 +package lru
5 +
6 +import (
7 + "container/list"
8 + "errors"
9 + "sync"
10 +)
11 +
12 +// Cache is a thread-safe fixed size LRU cache.
13 +type Cache struct {
14 + size int
15 + evictList *list.List
16 + items map[interface{}]*list.Element
17 + lock sync.Mutex
18 +}
19 +
20 +// entry is used to hold a value in the evictList
21 +type entry struct {
22 + key interface{}
23 + value interface{}
24 +}
25 +
26 +// New creates an LRU of the given size
27 +func New(size int) (*Cache, error) {
28 + if size <= 0 {
29 + return nil, errors.New("Must provide a positive size")
30 + }
31 + c := &Cache{
32 + size: size,
33 + evictList: list.New(),
34 + items: make(map[interface{}]*list.Element, size),
35 + }
36 + return c, nil
37 +}
38 +
39 +// Purge is used to completely clear the cache
40 +func (c *Cache) Purge() {
41 + c.lock.Lock()
42 + defer c.lock.Unlock()
43 + c.evictList = list.New()
44 + c.items = make(map[interface{}]*list.Element, c.size)
45 +}
46 +
47 +// Add adds a value to the cache.
48 +func (c *Cache) Add(key, value interface{}) {
49 + c.lock.Lock()
50 + defer c.lock.Unlock()
51 +
52 + // Check for existing item
53 + if ent, ok := c.items[key]; ok {
54 + c.evictList.MoveToFront(ent)
55 + ent.Value.(*entry).value = value
56 + return
57 + }
58 +
59 + // Add new item
60 + ent := &entry{key, value}
61 + entry := c.evictList.PushFront(ent)
62 + c.items[key] = entry
63 +
64 + // Verify size not exceeded
65 + if c.evictList.Len() > c.size {
66 + c.removeOldest()
67 + }
68 +}
69 +
70 +// Get looks up a key's value from the cache.
71 +func (c *Cache) Get(key interface{}) (value interface{}, ok bool) {
72 + c.lock.Lock()
73 + defer c.lock.Unlock()
74 +
75 + if ent, ok := c.items[key]; ok {
76 + c.evictList.MoveToFront(ent)
77 + return ent.Value.(*entry).value, true
78 + }
79 + return
80 +}
81 +
82 +// Remove removes the provided key from the cache.
83 +func (c *Cache) Remove(key interface{}) {
84 + c.lock.Lock()
85 + defer c.lock.Unlock()
86 +
87 + if ent, ok := c.items[key]; ok {
88 + c.removeElement(ent)
89 + }
90 +}
91 +
92 +// RemoveOldest removes the oldest item from the cache.
93 +func (c *Cache) RemoveOldest() {
94 + c.lock.Lock()
95 + defer c.lock.Unlock()
96 + c.removeOldest()
97 +}
98 +
99 +// Keys returns a slice of the keys in the cache.
100 +func (c *Cache) Keys() []interface{} {
101 + c.lock.Lock()
102 + defer c.lock.Unlock()
103 +
104 + keys := make([]interface{}, len(c.items))
105 + i := 0
106 + for k := range c.items {
107 + keys[i] = k
108 + i++
109 + }
110 +
111 + return keys
112 +}
113 +
114 +// removeOldest removes the oldest item from the cache.
115 +func (c *Cache) removeOldest() {
116 + ent := c.evictList.Back()
117 + if ent != nil {
118 + c.removeElement(ent)
119 + }
120 +}
121 +
122 +// removeElement is used to remove a given list element from the cache
123 +func (c *Cache) removeElement(e *list.Element) {
124 + c.evictList.Remove(e)
125 + kv := e.Value.(*entry)
126 + delete(c.items, kv.key)
127 +}
128 +
129 +// Len returns the number of items in the cache.
130 +func (c *Cache) Len() int {
131 + c.lock.Lock()
132 + defer c.lock.Unlock()
133 + return c.evictList.Len()
134 +}
Godeps/_workspace/src/github.com/hashicorp/golang-lru/lru_test.go new
+48
@@ -0,0 +1,48 @@
1 +package lru
2 +
3 +import "testing"
4 +
5 +func TestLRU(t *testing.T) {
6 + l, err := New(128)
7 + if err != nil {
8 + t.Fatalf("err: %v", err)
9 + }
10 + for i := 0; i < 256; i++ {
11 + l.Add(i, i)
12 + }
13 + if l.Len() != 128 {
14 + t.Fatalf("bad len: %v", l.Len())
15 + }
16 + for _, k := range l.Keys() {
17 + if v, ok := l.Get(k); !ok || v != k {
18 + t.Fatalf("bad key: %v", k)
19 + }
20 + }
21 + for i := 0; i < 128; i++ {
22 + _, ok := l.Get(i)
23 + if ok {
24 + t.Fatalf("should be evicted")
25 + }
26 + }
27 + for i := 128; i < 256; i++ {
28 + _, ok := l.Get(i)
29 + if !ok {
30 + t.Fatalf("should not be evicted")
31 + }
32 + }
33 + for i := 128; i < 192; i++ {
34 + l.Remove(i)
35 + _, ok := l.Get(i)
36 + if ok {
37 + t.Fatalf("should be deleted")
38 + }
39 + }
40 +
41 + l.Purge()
42 + if l.Len() != 0 {
43 + t.Fatalf("bad len: %v", l.Len())
44 + }
45 + if _, ok := l.Get(200); ok {
46 + t.Fatalf("should contain nothing")
47 + }
48 +}
blocks/blockstore/write_cache.go new
+45
@@ -0,0 +1,45 @@
1 +package blockstore
2 +
3 +import (
4 + "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/hashicorp/golang-lru"
5 + "github.com/jbenet/go-ipfs/blocks"
6 + u "github.com/jbenet/go-ipfs/util"
7 +)
8 +
9 +// WriteCached returns a blockstore that caches up to |size| unique writes (bs.Put).
10 +func WriteCached(bs Blockstore, size int) (Blockstore, error) {
11 + c, err := lru.New(size)
12 + if err != nil {
13 + return nil, err
14 + }
15 + return &writecache{blockstore: bs, cache: c}, nil
16 +}
17 +
18 +type writecache struct {
19 + cache *lru.Cache // pointer b/c Cache contains a Mutex as value (complicates copying)
20 + blockstore Blockstore
21 +}
22 +
23 +func (w *writecache) DeleteBlock(k u.Key) error {
24 + w.cache.Remove(k)
25 + return w.blockstore.DeleteBlock(k)
26 +}
27 +
28 +func (w *writecache) Has(k u.Key) (bool, error) {
29 + if _, ok := w.cache.Get(k); ok {
30 + return true, nil
31 + }
32 + return w.blockstore.Has(k)
33 +}
34 +
35 +func (w *writecache) Get(k u.Key) (*blocks.Block, error) {
36 + return w.blockstore.Get(k)
37 +}
38 +
39 +func (w *writecache) Put(b *blocks.Block) error {
40 + if _, ok := w.cache.Get(b.Key()); ok {
41 + return nil
42 + }
43 + w.cache.Add(b.Key(), struct{}{})
44 + return w.blockstore.Put(b)
45 +}
blocks/blockstore/write_cache_test.go new
+88
@@ -0,0 +1,88 @@
1 +package blockstore
2 +
3 +import (
4 + ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
5 + syncds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
6 + "github.com/jbenet/go-ipfs/blocks"
7 + "testing"
8 +)
9 +
10 +func TestReturnsErrorWhenSizeNegative(t *testing.T) {
11 + bs := NewBlockstore(syncds.MutexWrap(ds.NewMapDatastore()))
12 + _, err := WriteCached(bs, -1)
13 + if err != nil {
14 + return
15 + }
16 + t.Fail()
17 +}
18 +
19 +func TestRemoveCacheEntryOnDelete(t *testing.T) {
20 + b := blocks.NewBlock([]byte("foo"))
21 + cd := &callbackDatastore{f: func() {}, ds: ds.NewMapDatastore()}
22 + bs := NewBlockstore(syncds.MutexWrap(cd))
23 + cachedbs, err := WriteCached(bs, 1)
24 + if err != nil {
25 + t.Fatal(err)
26 + }
27 + cachedbs.Put(b)
28 +
29 + writeHitTheDatastore := false
30 + cd.SetFunc(func() {
31 + writeHitTheDatastore = true
32 + })
33 +
34 + cachedbs.DeleteBlock(b.Key())
35 + cachedbs.Put(b)
36 + if !writeHitTheDatastore {
37 + t.Fail()
38 + }
39 +}
40 +
41 +func TestElideDuplicateWrite(t *testing.T) {
42 + cd := &callbackDatastore{f: func() {}, ds: ds.NewMapDatastore()}
43 + bs := NewBlockstore(syncds.MutexWrap(cd))
44 + cachedbs, err := WriteCached(bs, 1)
45 + if err != nil {
46 + t.Fatal(err)
47 + }
48 +
49 + b1 := blocks.NewBlock([]byte("foo"))
50 +
51 + cachedbs.Put(b1)
52 + cd.SetFunc(func() {
53 + t.Fatal("write hit the datastore")
54 + })
55 + cachedbs.Put(b1)
56 +}
57 +
58 +type callbackDatastore struct {
59 + f func()
60 + ds ds.Datastore
61 +}
62 +
63 +func (c *callbackDatastore) SetFunc(f func()) { c.f = f }
64 +
65 +func (c *callbackDatastore) Put(key ds.Key, value interface{}) (err error) {
66 + c.f()
67 + return c.ds.Put(key, value)
68 +}
69 +
70 +func (c *callbackDatastore) Get(key ds.Key) (value interface{}, err error) {
71 + c.f()
72 + return c.ds.Get(key)
73 +}
74 +
75 +func (c *callbackDatastore) Has(key ds.Key) (exists bool, err error) {
76 + c.f()
77 + return c.ds.Has(key)
78 +}
79 +
80 +func (c *callbackDatastore) Delete(key ds.Key) (err error) {
81 + c.f()
82 + return c.ds.Delete(key)
83 +}
84 +
85 +func (c *callbackDatastore) KeyList() ([]ds.Key, error) {
86 + c.f()
87 + return c.ds.KeyList()
88 +}