func TestReceive(t *testing.T) {
sto := new(test.Fetcher)
data := []byte("some blob")
br := blob.SHA1FromBytes(data)
hub := blobserver.GetHub(sto)
ch := make(chan blob.Ref, 1)
hub.RegisterListener(ch)
sb, err := blobserver.Receive(sto, br, bytes.NewReader(data))
if err != nil {
t.Fatal(err)
}
if sb.Size != int64(len(data)) {
t.Errorf("received blob size = %d; want %d", sb.Size, len(data))
}
if sb.Ref != br {
t.Errorf("received blob = %v; want %v", sb.Ref, br)
}
select {
case got := <-ch:
if got != br {
t.Errorf("blobhub notified about %v; want %v", got, br)
}
case <-time.After(5 * time.Second):
t.Error("timeout waiting on blobhub")
}
}
func (s *storage) ReceiveBlob(plainBR blob.Ref, source io.Reader) (sb blob.SizedRef, err error) {
iv := s.randIV()
stream := cipher.NewCTR(s.block, iv)
hash := plainBR.Hash()
var buf bytes.Buffer
// TODO: compress before encrypting?
buf.Write(iv) // TODO: write more structured header w/ version & IV length? or does that weaken it?
sw := cipher.StreamWriter{S: stream, W: &buf}
plainSize, err := io.Copy(io.MultiWriter(sw, hash), source)
if err != nil {
return sb, err
}
if !plainBR.HashMatches(hash) {
return sb, blobserver.ErrCorruptBlob
}
encBR := blob.SHA1FromBytes(buf.Bytes())
_, err = blobserver.Receive(s.blobs, encBR, bytes.NewReader(buf.Bytes()))
if err != nil {
log.Printf("encrypt: error writing encrypted blob %v (plaintext %v): %v", encBR, plainBR, err)
return sb, errors.New("encrypt: error writing encrypted blob")
}
meta := encodeMetaValue(uint32(plainSize), iv, encBR, buf.Len())
metaBlob := s.makeSingleMetaBlob(plainBR, meta)
_, err = blobserver.ReceiveNoHash(s.meta, blob.SHA1FromBytes(metaBlob), bytes.NewReader(metaBlob))
if err != nil {
log.Printf("encrypt: error writing encrypted meta for plaintext %v (encrypted blob %v): %v", plainBR, encBR, err)
return sb, errors.New("encrypt: error writing encrypted meta")
}
err = s.index.Set(plainBR.String(), meta)
if err != nil {
return sb, fmt.Errorf("encrypt: error updating index for encrypted %v (plaintext %v): %v", encBR, plainBR, err)
}
return blob.SizedRef{plainBR, uint32(plainSize)}, nil
}
func TestReceiveCorrupt(t *testing.T) {
sto := new(test.Fetcher)
data := []byte("some blob")
br := blob.SHA1FromBytes(data)
data[0] = 'X' // corrupt it
_, err := blobserver.Receive(sto, br, bytes.NewReader(data))
if err != blobserver.ErrCorruptBlob {
t.Errorf("Receive = %v; want ErrCorruptBlob", err)
}
if len(sto.BlobrefStrings()) > 0 {
t.Errorf("nothing should be stored. Got %q", sto.BlobrefStrings())
}
}
func writeToCache(cache blobserver.Storage, thumbBytes []byte, name string) (br blob.Ref, err error) {
tr := bytes.NewReader(thumbBytes)
if len(thumbBytes) < constants.MaxBlobSize {
br = blob.SHA1FromBytes(thumbBytes)
_, err = blobserver.Receive(cache, br, tr)
} else {
// TODO: don't use rolling checksums when writing this. Tell
// the filewriter to use 16 MB chunks instead.
br, err = schema.WriteFileFromReader(cache, name, tr)
}
if err != nil {
return br, errors.New("failed to cache " + name + ": " + err.Error())
}
if imageDebug {
log.Printf("Image Cache: saved as %v\n", br)
}
return br, nil
}
// trunc is a hint about which blob to truncate after. It may be zero.
// If the returned error is of type 'needsTruncatedAfterError', then
// the zip should be attempted to be written again, but truncating the
// data after the listed blob.
func (pk *packer) writeAZip(trunc blob.Ref) (err error) {
defer func() {
if e := recover(); e != nil {
if v, ok := e.(error); ok && err == nil {
err = v
} else {
panic(e)
}
}
}()
mf := Manifest{
WholeRef: pk.wholeRef,
WholeSize: pk.wholeSize,
WholePartIndex: len(pk.zips),
}
var zbuf bytes.Buffer
cw := &countWriter{w: &zbuf}
zw := zip.NewWriter(cw)
var approxSize = zipFixedOverhead // can't use zbuf.Len because zw buffers
var dataRefsWritten []blob.Ref
var dataBytesWritten int64
var schemaBlobSeen = map[blob.Ref]bool{}
var schemaBlobs []blob.Ref // to add after the main file
baseFileName := pk.fr.FileName()
if strings.Contains(baseFileName, "/") || strings.Contains(baseFileName, "\\") {
return fmt.Errorf("File schema blob %v filename had a slash in it: %q", pk.fr.SchemaBlobRef(), baseFileName)
}
fh := &zip.FileHeader{
Name: baseFileName,
Method: zip.Store, // uncompressed
}
fh.SetModTime(pk.fr.ModTime())
fh.SetMode(0644)
fw, err := zw.CreateHeader(fh)
check(err)
check(zw.Flush())
dataStart := cw.n
approxSize += zipPerEntryOverhead // for the first FileHeader w/ the data
zipMax := pk.s.maxZipBlobSize()
chunks := pk.chunksRemain
chunkWholeHash := blob.NewHash()
for len(chunks) > 0 {
dr := chunks[0] // the next chunk to maybe write
if trunc.Valid() && trunc == dr {
if approxSize == 0 {
return errors.New("first blob is too large to pack, once you add the zip overhead")
}
break
}
schemaBlobsSave := schemaBlobs
for _, parent := range pk.schemaParent[dr] {
if !schemaBlobSeen[parent] {
schemaBlobSeen[parent] = true
schemaBlobs = append(schemaBlobs, parent)
approxSize += int(pk.schemaBlob[parent].Size()) + zipPerEntryOverhead
}
}
thisSize := pk.dataSize[dr]
approxSize += int(thisSize)
if approxSize+mf.approxSerializedSize() > zipMax {
if fn := testHookStopBeforeOverflowing; fn != nil {
fn()
}
schemaBlobs = schemaBlobsSave // restore it
break
}
// Copy the data to the zip.
rc, size, err := pk.s.Fetch(dr)
check(err)
if size != thisSize {
rc.Close()
return errors.New("unexpected size")
}
if n, err := io.Copy(io.MultiWriter(fw, chunkWholeHash), rc); err != nil || n != int64(size) {
rc.Close()
return fmt.Errorf("copy to zip = %v, %v; want %v bytes", n, err, size)
}
rc.Close()
dataRefsWritten = append(dataRefsWritten, dr)
dataBytesWritten += int64(size)
chunks = chunks[1:]
}
mf.DataBlobsOrigin = blob.RefFromHash(chunkWholeHash)
// zipBlobs is where a schema or data blob is relative to the beginning
// of the zip file.
var zipBlobs []BlobAndPos
var dataOffset int64
for _, br := range dataRefsWritten {
size := pk.dataSize[br]
mf.DataBlobs = append(mf.DataBlobs, BlobAndPos{blob.SizedRef{Ref: br, Size: size}, dataOffset})
zipBlobs = append(zipBlobs, BlobAndPos{blob.SizedRef{Ref: br, Size: size}, dataStart + dataOffset})
dataOffset += int64(size)
}
for _, br := range schemaBlobs {
fw, err := zw.CreateHeader(&zip.FileHeader{
Name: "camlistore/" + br.String() + ".json",
Method: zip.Store, // uncompressed
})
check(err)
check(zw.Flush())
b := pk.schemaBlob[br]
zipBlobs = append(zipBlobs, BlobAndPos{blob.SizedRef{Ref: br, Size: b.Size()}, cw.n})
rc := b.Open()
n, err := io.Copy(fw, rc)
rc.Close()
check(err)
if n != int64(b.Size()) {
return fmt.Errorf("failed to write all of schema blob %v: %d bytes, not wanted %d", br, n, b.Size())
}
}
// Manifest file
fw, err = zw.Create(zipManifestPath)
check(err)
enc, err := json.MarshalIndent(mf, "", " ")
check(err)
_, err = fw.Write(enc)
check(err)
err = zw.Close()
check(err)
if zbuf.Len() > zipMax {
// We guessed wrong. Back up. Find out how many blobs we went over.
overage := zbuf.Len() - zipMax
for i := len(dataRefsWritten) - 1; i >= 0; i-- {
dr := dataRefsWritten[i]
if overage <= 0 {
return needsTruncatedAfterError{dr}
}
overage -= int(pk.dataSize[dr])
}
return errors.New("file is unpackable; first blob is too big to fit")
}
zipRef := blob.SHA1FromBytes(zbuf.Bytes())
zipSB, err := blobserver.ReceiveNoHash(pk.s.large, zipRef, bytes.NewReader(zbuf.Bytes()))
if err != nil {
return err
}
bm := pk.s.meta.BeginBatch()
bm.Set(fmt.Sprintf("%s%s:%d", wholeMetaPrefix, pk.wholeRef, len(pk.zips)),
fmt.Sprintf("%s %d %d %d",
zipRef,
dataStart,
pk.wholeBytesWritten,
dataBytesWritten))
pk.wholeBytesWritten += dataBytesWritten
pk.zips = append(pk.zips, writtenZip{
SizedRef: zipSB,
dataRefs: dataRefsWritten,
})
for _, zb := range zipBlobs {
bm.Set(blobMetaPrefix+zb.Ref.String(), fmt.Sprintf("%d %v %d", zb.Size, zipRef, zb.Offset))
}
if err := pk.s.meta.CommitBatch(bm); err != nil {
return err
}
// Delete from small
if !pk.s.skipDelete {
toDelete := make([]blob.Ref, 0, len(dataRefsWritten)+len(schemaBlobs))
toDelete = append(toDelete, dataRefsWritten...)
toDelete = append(toDelete, schemaBlobs...)
if err := pk.s.small.RemoveBlobs(toDelete); err != nil {
// Can't really do anything about it and doesn't really matter, so
// just log for now.
pk.s.Logf("Error removing blobs from %s: %v", pk.s.small, err)
}
}
// On success, consume the chunks we wrote from pk.chunksRemain.
pk.chunksRemain = pk.chunksRemain[len(dataRefsWritten):]
return nil
}