func (c *archiveRun) main(a subcommands.Application, args []string) error {
out := os.Stdout
prefix := "\n"
if c.defaultFlags.Quiet {
out = nil
prefix = ""
}
start := time.Now()
arch := archiver.New(isolatedclient.New(c.isolatedFlags.ServerURL, c.isolatedFlags.Namespace), out)
common.CancelOnCtrlC(arch)
future := isolate.Archive(arch, &c.ArchiveOptions)
future.WaitForHashed()
var err error
if err = future.Error(); err != nil {
fmt.Printf("%s%s %s\n", prefix, filepath.Base(c.Isolate), err)
} else {
fmt.Printf("%s%s %s\n", prefix, future.Digest(), filepath.Base(c.Isolate))
}
if err2 := arch.Close(); err == nil {
err = err2
}
if !c.defaultFlags.Quiet {
duration := time.Since(start)
stats := arch.Stats()
fmt.Fprintf(os.Stderr, "Hits : %5d (%s)\n", stats.TotalHits(), stats.TotalBytesHits())
fmt.Fprintf(os.Stderr, "Misses : %5d (%s)\n", stats.TotalMisses(), stats.TotalBytesPushed())
fmt.Fprintf(os.Stderr, "Duration: %s\n", common.Round(duration, time.Millisecond))
}
return err
}
// Test that if the isolate file is not found, the error is properly propagated.
func TestArchiveFileNotFoundReturnsError(t *testing.T) {
t.Parallel()
a := archiver.New(isolatedclient.New("http://unused", "default-gzip"), nil)
opts := &ArchiveOptions{
Isolate: "/this-file-does-not-exist",
Isolated: "/this-file-doesnt-either",
}
future := Archive(a, opts)
future.WaitForHashed()
err := future.Error()
ut.AssertEqual(t, true, strings.HasPrefix(err.Error(), "open /this-file-does-not-exist: "))
closeErr := a.Close()
ut.AssertEqual(t, true, closeErr != nil)
ut.AssertEqual(t, true, strings.HasPrefix(closeErr.Error(), "open /this-file-does-not-exist: "))
}
func TestArchive(t *testing.T) {
// Create a .isolate file and archive it.
t.Parallel()
server := isolatedfake.New()
ts := httptest.NewServer(server)
defer ts.Close()
a := archiver.New(isolatedclient.New(ts.URL, "default-gzip"), nil)
// Setup temporary directory.
// /base/bar
// /base/ignored
// /foo/baz.isolate
// /link -> /base/bar
// Result:
// /baz.isolated
tmpDir, err := ioutil.TempDir("", "isolate")
ut.AssertEqual(t, nil, err)
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Fail()
}
}()
baseDir := filepath.Join(tmpDir, "base")
fooDir := filepath.Join(tmpDir, "foo")
ut.AssertEqual(t, nil, os.Mkdir(baseDir, 0700))
ut.AssertEqual(t, nil, os.Mkdir(fooDir, 0700))
ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(baseDir, "bar"), []byte("foo"), 0600))
ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(baseDir, "ignored"), []byte("ignored"), 0600))
isolate := `{
'variables': {
'files': [
'../base/',
'../link',
],
},
'conditions': [
['OS=="amiga"', {
'variables': {
'command': ['amiga', '<(EXTRA)'],
},
}],
['OS=="win"', {
'variables': {
'command': ['win'],
},
}],
],
}`
isolatePath := filepath.Join(fooDir, "baz.isolate")
ut.AssertEqual(t, nil, ioutil.WriteFile(isolatePath, []byte(isolate), 0600))
if !common.IsWindows() {
ut.AssertEqual(t, nil, os.Symlink(filepath.Join("base", "bar"), filepath.Join(tmpDir, "link")))
} else {
ut.AssertEqual(t, nil, ioutil.WriteFile(filepath.Join(tmpDir, "link"), []byte("no link on Windows"), 0600))
}
opts := &ArchiveOptions{
Isolate: isolatePath,
Isolated: filepath.Join(tmpDir, "baz.isolated"),
Blacklist: common.Strings{"ignored", "*.isolate"},
PathVariables: map[string]string{"VAR": "wonderful"},
ExtraVariables: map[string]string{"EXTRA": "really"},
ConfigVariables: map[string]string{"OS": "amiga"},
}
future := Archive(a, opts)
ut.AssertEqual(t, "baz.isolated", future.DisplayName())
future.WaitForHashed()
ut.AssertEqual(t, nil, future.Error())
ut.AssertEqual(t, nil, a.Close())
mode := 0600
if common.IsWindows() {
mode = 0666
}
// /base/
isolatedDirData := isolated.Isolated{
Algo: "sha-1",
Files: map[string]isolated.File{
filepath.Join("base", "bar"): {Digest: "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", Mode: newInt(mode), Size: newInt64(3)},
},
Version: isolated.IsolatedFormatVersion,
}
encoded, err := json.Marshal(isolatedDirData)
ut.AssertEqual(t, nil, err)
isolatedDirEncoded := string(encoded) + "\n"
isolatedDirHash := isolated.HashBytes([]byte(isolatedDirEncoded))
isolatedData := isolated.Isolated{
Algo: "sha-1",
Command: []string{"amiga", "really"},
Files: map[string]isolated.File{},
Includes: []isolated.HexDigest{isolatedDirHash},
RelativeCwd: "foo",
Version: isolated.IsolatedFormatVersion,
}
if !common.IsWindows() {
isolatedData.Files["link"] = isolated.File{Link: newString(filepath.Join("base", "bar"))}
} else {
isolatedData.Files["link"] = isolated.File{Digest: "12339b9756c2994f85c310d560bc8c142a6b79a1", Mode: newInt(0666), Size: newInt64(18)}
}
encoded, err = json.Marshal(isolatedData)
ut.AssertEqual(t, nil, err)
isolatedEncoded := string(encoded) + "\n"
isolatedHash := isolated.HashBytes([]byte(isolatedEncoded))
expected := map[string]string{
"0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33": "foo",
string(isolatedDirHash): isolatedDirEncoded,
string(isolatedHash): isolatedEncoded,
}
if common.IsWindows() {
expected["12339b9756c2994f85c310d560bc8c142a6b79a1"] = "no link on Windows"
}
actual := map[string]string{}
for k, v := range server.Contents() {
actual[string(k)] = string(v)
ut.AssertEqualf(t, expected[string(k)], actual[string(k)], "%s: %#v", k, actual[string(k)])
}
ut.AssertEqual(t, expected, actual)
ut.AssertEqual(t, isolatedHash, future.Digest())
stats := a.Stats()
ut.AssertEqual(t, 0, stats.TotalHits())
ut.AssertEqual(t, common.Size(0), stats.TotalBytesHits())
if !common.IsWindows() {
ut.AssertEqual(t, 3, stats.TotalMisses())
ut.AssertEqual(t, common.Size(3+len(isolatedDirEncoded)+len(isolatedEncoded)), stats.TotalBytesPushed())
} else {
ut.AssertEqual(t, 4, stats.TotalMisses())
ut.AssertEqual(t, common.Size(3+18+len(isolatedDirEncoded)+len(isolatedEncoded)), stats.TotalBytesPushed())
}
ut.AssertEqual(t, nil, server.Error())
digest, err := isolated.HashFile(filepath.Join(tmpDir, "baz.isolated"))
ut.AssertEqual(t, isolated.DigestItem{isolatedHash, false, int64(len(isolatedEncoded))}, digest)
ut.AssertEqual(t, nil, err)
}
func (c *batchArchiveRun) main(a subcommands.Application, args []string) error {
out := os.Stdout
prefix := "\n"
if c.defaultFlags.Quiet {
out = nil
prefix = ""
}
start := time.Now()
arch := archiver.New(isolatedclient.New(c.isolatedFlags.ServerURL, c.isolatedFlags.Namespace), out)
common.CancelOnCtrlC(arch)
type tmp struct {
name string
future archiver.Future
}
items := make(chan *tmp, len(args))
var wg sync.WaitGroup
for _, arg := range args {
wg.Add(1)
go func(genJsonPath string) {
defer wg.Done()
data := &struct {
Args []string
Dir string
Version int
}{}
if err := common.ReadJSONFile(genJsonPath, data); err != nil {
arch.Cancel(err)
return
}
if data.Version != isolate.IsolatedGenJSONVersion {
arch.Cancel(fmt.Errorf("invalid version %d in %s", data.Version, genJsonPath))
return
}
if !common.IsDirectory(data.Dir) {
arch.Cancel(fmt.Errorf("invalid dir %s in %s", data.Dir, genJsonPath))
return
}
opts, err := parseArchiveCMD(data.Args, data.Dir)
if err != nil {
arch.Cancel(fmt.Errorf("invalid archive command in %s: %s", genJsonPath, err))
return
}
name := filepath.Base(opts.Isolated)
// Strip the extension if there is one.
if dotIndex := strings.LastIndex(name, "."); dotIndex != -1 {
name = name[0:dotIndex]
}
items <- &tmp{name, isolate.Archive(arch, opts)}
}(arg)
}
go func() {
wg.Wait()
close(items)
}()
data := map[string]isolated.HexDigest{}
for item := range items {
item.future.WaitForHashed()
if item.future.Error() == nil {
data[item.name] = item.future.Digest()
fmt.Printf("%s%s %s\n", prefix, item.future.Digest(), item.name)
} else {
fmt.Fprintf(os.Stderr, "%s%s %s\n", prefix, item.name, item.future.Error())
}
}
err := arch.Close()
duration := time.Since(start)
// Only write the file once upload is confirmed.
if err == nil && c.dumpJSON != "" {
err = common.WriteJSONFile(c.dumpJSON, data)
}
if !c.defaultFlags.Quiet {
stats := arch.Stats()
fmt.Fprintf(os.Stderr, "Hits : %5d (%s)\n", stats.TotalHits(), stats.TotalBytesHits())
fmt.Fprintf(os.Stderr, "Misses : %5d (%s)\n", stats.TotalMisses(), stats.TotalBytesPushed())
fmt.Fprintf(os.Stderr, "Duration: %s\n", common.Round(duration, time.Millisecond))
}
return err
}