mirror of
https://github.com/pgsty/minio.git
synced 2026-09-17 07:48:27 +03:00
Feng Ruohang
102 lines
3.0 KiB
Go
102 lines
3.0 KiB
Go
// Copyright (c) 2026 Feng Ruohang
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"archive/tar"
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"sync"
|
|
"testing"
|
|
"testing/iotest"
|
|
|
|
"github.com/pierrec/lz4/v4"
|
|
)
|
|
|
|
func TestUntarLZ4(t *testing.T) {
|
|
for _, empty := range []bool{false, true} {
|
|
t.Run(fmt.Sprintf("empty=%t", empty), func(t *testing.T) {
|
|
want := map[string][]byte{}
|
|
if !empty {
|
|
want["small.txt"] = bytes.Repeat([]byte("small object\n"), 10)
|
|
want["large.txt"] = bytes.Repeat([]byte("large object\n"), 32768)
|
|
}
|
|
var compressed bytes.Buffer
|
|
compressor := lz4.NewWriter(&compressed)
|
|
archive := tar.NewWriter(compressor)
|
|
for name, data := range want {
|
|
if err := archive.WriteHeader(&tar.Header{Name: name, Mode: 0o600, Size: int64(len(data))}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := archive.Write(data); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := archive.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := compressor.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var mu sync.Mutex
|
|
got := map[string][]byte{}
|
|
err := untar(t.Context(), iotest.HalfReader(bytes.NewReader(compressed.Bytes())), func(r io.Reader, info os.FileInfo, name string) error {
|
|
// Exercise a short first read followed by streaming the remaining content.
|
|
var output bytes.Buffer
|
|
prefix := make([]byte, 7)
|
|
if _, err := io.ReadFull(r, prefix); err != nil {
|
|
return err
|
|
}
|
|
output.Write(prefix)
|
|
if _, err := io.Copy(&output, r); err != nil {
|
|
return err
|
|
}
|
|
if int64(output.Len()) != info.Size() {
|
|
return fmt.Errorf("size mismatch for %s", name)
|
|
}
|
|
mu.Lock()
|
|
got[name] = output.Bytes()
|
|
mu.Unlock()
|
|
return nil
|
|
}, untarOptions{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != len(want) {
|
|
t.Fatalf("objects=%d, want %d", len(got), len(want))
|
|
}
|
|
for name, data := range want {
|
|
if !bytes.Equal(got[name], data) {
|
|
t.Errorf("content mismatch for %s", name)
|
|
}
|
|
}
|
|
t.Run("corrupt-header", func(t *testing.T) {
|
|
damaged := bytes.Clone(compressed.Bytes())
|
|
damaged[6] ^= 0xff
|
|
err := untar(t.Context(), bytes.NewReader(damaged), func(io.Reader, os.FileInfo, string) error {
|
|
t.Error("corrupt header must be rejected before uploading objects")
|
|
return nil
|
|
}, untarOptions{})
|
|
if err == nil {
|
|
t.Fatal("corrupt LZ4 header accepted")
|
|
}
|
|
})
|
|
})
|
|
}
|
|
}
|