func TestKeyNewPrivateNum(t *testing.T) { k := cas.NewKeyPrivateNum(31337) buf := k.Bytes() k2 := cas.NewKey(buf) if g, e := k2, cas.Invalid; g != e { t.Errorf("expected NewKey to give Invalid: %v", g) } k3 := cas.NewKeyPrivate(buf) if g, e := k3, k; g != e { t.Errorf("expected NewKeyPrivate to give original key: %v", g) } priv, ok := k3.Private() if !ok { t.Fatalf("expected Private to work: %v %v", priv, ok) } if g, e := priv, uint64(31337); g != e { t.Errorf("expected Private to match original: %v", g) } if g, e := k.IsSpecial(), true; g != e { t.Errorf("not Special: %v != %v", g, e) } if g, e := k.IsPrivate(), true; g != e { t.Errorf("not Private: %v != %v", g, e) } if g, e := k.IsReserved(), false; g != e { t.Errorf("bad Reserved: %v != %v", g, e) } }
// Clone is like Get but clones the chunk if it's not already private. // Chunks that are already private are returned as-is. // // A cloned chunk will have a buffer of size bytes. This is intended // to use for re-inflating zero-trimmed chunks. // // Modifying the returned chunk *will* cause the locally stored data // to change. This is the intended usage of a stash. func (s *Stash) Clone(key cas.Key, typ string, level uint8, size uint32) (cas.Key, *chunks.Chunk, error) { priv, ok := key.Private() if ok { chunk, ok := s.local[priv] if !ok { return key, nil, cas.NotFound{ Type: typ, Level: level, Key: key, } } return key, chunk, nil } chunk, err := s.chunks.Get(key, typ, level) if err != nil { return key, nil, err } // clone the byte slice tmp := make([]byte, size) copy(tmp, chunk.Buf) chunk.Buf = tmp priv = s.ids.Get() privkey := cas.NewKeyPrivateNum(priv) s.local[priv] = chunk return privkey, chunk, nil }