return ks.BlockTrash(ctx, loc)
}
checkexists := func(volidx int) bool {
- _, err := vol[volidx].BlockRead(ctx, fooHash, io.Discard)
+ err := vol[volidx].BlockRead(ctx, fooHash, brdiscard)
if !os.IsNotExist(err) {
c.Check(err, IsNil)
}
for _, mnt := range ks.mounts {
err := mnt.BlockWrite(context.Background(), fooHash, []byte("foo"))
c.Assert(err, IsNil)
- _, err = mnt.BlockRead(context.Background(), fooHash, io.Discard)
+ err = mnt.BlockRead(context.Background(), fooHash, brdiscard)
c.Assert(err, IsNil)
}
c.Check(os.IsNotExist(err), Equals, true)
for _, mnt := range ks.mounts {
- _, err := mnt.BlockRead(context.Background(), fooHash, io.Discard)
+ err := mnt.BlockRead(context.Background(), fooHash, brdiscard)
c.Assert(err, IsNil)
}
}
c.Check(ks.mounts["zzzzz-nyw5e-222222222222222"].volume.(*stubVolume).stubLog.String(), HasLen, 0)
}
-func (s *keepstoreSuite) TestParseLocator(c *C) {
+func (s *keepstoreSuite) TestGetLocatorInfo(c *C) {
for _, trial := range []struct {
locator string
ok bool
ok: true, expect: locatorInfo{size: 1234, remote: true}},
{locator: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+12345+Zexample+Rzzzzz-abcdef",
ok: true, expect: locatorInfo{size: 12345, remote: true}},
+ {locator: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+123456+👶🦈+Rzzzzz-abcdef",
+ ok: true, expect: locatorInfo{size: 123456, remote: true}},
+ // invalid: bad hash char
+ {locator: "aaaaaaaaaaaaaazaaaaaaaaaaaaaaaaa+1234",
+ ok: false},
+ {locator: "aaaaaaaaaaaaaaFaaaaaaaaaaaaaaaaa+1234",
+ ok: false},
+ {locator: "aaaaaaaaaaaaaa⛵aaaaaaaaaaaaaaaaa+1234",
+ ok: false},
// invalid: hash length != 32
{locator: "",
ok: false},
// invalid: first hint is not size
{locator: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+Abcdef+1234",
ok: false},
+ // invalid: leading/trailing/double +
+ {locator: "+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+1234",
+ ok: false},
+ {locator: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+1234+",
+ ok: false},
+ {locator: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa++1234",
+ ok: false},
+ {locator: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+1234++Abcdef@abcdef",
+ ok: false},
} {
c.Logf("=== %s", trial.locator)
- li, err := parseLocator(trial.locator)
+ li, err := getLocatorInfo(trial.locator)
if !trial.ok {
c.Check(err, NotNil)
continue
// corresponding func (if non-nil). If the func returns an
// error, that error is returned to caller. Otherwise, the
// stub continues normally.
- blockRead func(ctx context.Context, hash string, writeTo io.Writer) (int, error)
+ blockRead func(ctx context.Context, hash string, writeTo io.WriterAt) error
blockWrite func(ctx context.Context, hash string, data []byte) error
deviceID func() string
blockTouch func(hash string) error
v.stubLog.Printf("%s %s %s", v.params.UUID[24:27], op, hash[:3])
}
-func (v *stubVolume) BlockRead(ctx context.Context, hash string, writeTo io.Writer) (int, error) {
+func (v *stubVolume) BlockRead(ctx context.Context, hash string, writeTo io.WriterAt) error {
v.log("read", hash)
if v.blockRead != nil {
- n, err := v.blockRead(ctx, hash, writeTo)
+ err := v.blockRead(ctx, hash, writeTo)
if err != nil {
- return n, err
+ return err
}
}
v.mtx.Lock()
ent, ok := v.data[hash]
v.mtx.Unlock()
if !ok || !ent.trash.IsZero() {
- return 0, os.ErrNotExist
+ return os.ErrNotExist
}
wrote := 0
for writesize := 1000; wrote < len(ent.data); writesize = writesize * 2 {
if len(data) > writesize {
data = data[:writesize]
}
- n, err := writeTo.Write(data)
+ n, err := writeTo.WriteAt(data, int64(wrote))
wrote += n
if err != nil {
- return wrote, err
+ return err
}
}
- return wrote, nil
+ return nil
}
func (v *stubVolume) BlockWrite(ctx context.Context, hash string, data []byte) error {