func (s *fsTreeStore) Import(u *unit.SourceUnit, data graph.Output) (err error) {
if u == nil {
return rwvfs.MkdirAll(s.fs, ".")
}
unitFilename := s.unitFilename(u.Type, u.Name)
if err := rwvfs.MkdirAll(s.fs, path.Dir(unitFilename)); err != nil {
return err
}
f, err := s.fs.Create(unitFilename)
if err != nil {
return err
}
defer func() {
err2 := f.Close()
if err == nil {
err = err2
}
}()
if _, err := Codec.NewEncoder(f).Encode(u); err != nil {
return err
}
dir := strings.TrimSuffix(unitFilename, unitFileSuffix)
if err := rwvfs.MkdirAll(s.fs, dir); err != nil {
return err
}
cleanForImport(&data, "", u.Type, u.Name)
return s.openUnitStore(unit.ID2{Type: u.Type, Name: u.Name}).(UnitStoreImporter).Import(data)
}
func TestHTTP_BaseURL(t *testing.T) {
m := map[string]string{"b/c": "c"}
mapFS := rwvfs.Map(m)
prefix := "/foo/bar/baz"
h := http.Handler(http.StripPrefix(prefix, rwvfs.HTTPHandler(mapFS, nil)))
httpServer := httptest.NewServer(h)
defer httpServer.Close()
httpURL, err := url.Parse(httpServer.URL + prefix)
if err != nil {
t.Fatal(err)
}
fs := rwvfs.HTTP(httpURL, nil)
if err := rwvfs.MkdirAll(fs, "b"); err != nil {
t.Errorf("MkdirAll %q: %s", "b", err)
}
fis, err := fs.ReadDir("b")
if err != nil {
t.Fatal(err)
}
if len(fis) != 1 {
t.Errorf("got len(fis) == %d, want 1", len(fis))
}
if wantName := "c"; fis[0].Name() != wantName {
t.Errorf("got name == %q, want %q", fis[0].Name(), wantName)
}
}
func testMkdirAll(t *testing.T, fs rwvfs.FileSystem) {
label := fmt.Sprintf("%T", fs)
err := rwvfs.MkdirAll(fs, "/a/b/c")
if err != nil {
t.Fatalf("%s: MkdirAll: %s", label, err)
}
testIsDir(t, label, fs, "/a")
testIsDir(t, label, fs, "/a/b")
testIsDir(t, label, fs, "/a/b/c")
err = rwvfs.MkdirAll(fs, "/a/b/c")
if err != nil {
t.Fatalf("%s: MkdirAll again: %s", label, err)
}
}
func (s *fsMultiRepoStore) Import(repo, commitID string, unit *unit.SourceUnit, data graph.Output) error {
if unit != nil {
cleanForImport(&data, repo, unit.Type, unit.Name)
}
subpath := s.fs.Join(s.RepoToPath(repo)...)
if err := rwvfs.MkdirAll(s.fs, subpath); err != nil {
return err
}
return s.openRepoStore(repo).(RepoImporter).Import(commitID, unit, data)
}
func TestMap_MkdirAllWithRootNotExists(t *testing.T) {
m := map[string]string{}
fs := rwvfs.Sub(rwvfs.Map(m), "x")
paths := []string{"a/b", "/c/d"}
for _, path := range paths {
if err := rwvfs.MkdirAll(fs, path); err != nil {
t.Errorf("MkdirAll %q: %s", path, err)
}
}
}
func uploadFile(local vfs.FileSystem, remote rwvfs.FileSystem, path string, fi os.FileInfo, dryRun bool) error {
kb := float64(fi.Size()) / 1024
if GlobalOpt.Verbose || dryRun {
log.Printf("Uploading %s (%.1fkb)", path, kb)
}
if dryRun {
return nil
}
lf, err := local.Open(path)
if err != nil {
return err
}
if err := rwvfs.MkdirAll(remote, filepath.Dir(path)); err != nil {
return err
}
rf, err := remote.Create(path)
if err != nil {
return err
}
defer func() {
if err := rf.Close(); err != nil {
log.Println("Error closing after error:", err)
}
}()
if _, err := io.Copy(rf, lf); err != nil {
return err
}
if err := rf.Close(); err != nil {
return err
}
if GlobalOpt.Verbose {
log.Printf("Uploaded %s (%.1fkb)", path, kb)
}
return nil
}
func testGlob(t *testing.T, fs rwvfs.FileSystem) {
label := fmt.Sprintf("%T", fs)
files := []string{"x/y/0.txt", "x/y/1.txt", "x/2.txt"}
for _, file := range files {
err := rwvfs.MkdirAll(fs, filepath.Dir(file))
if err != nil {
t.Fatalf("%s: MkdirAll: %s", label, err)
}
w, err := fs.Create(file)
if err != nil {
t.Errorf("%s: Create(%q): %s", label, file, err)
return
}
w.Close()
}
globTests := []struct {
prefix string
pattern string
matches []string
}{
{"", "x/y/*.txt", []string{"x/y/0.txt", "x/y/1.txt"}},
{"x/y", "x/y/*.txt", []string{"x/y/0.txt", "x/y/1.txt"}},
{"", "x/*", []string{"x/y", "x/2.txt"}},
}
for _, test := range globTests {
matches, err := rwvfs.Glob(rwvfs.Walkable(fs), test.prefix, test.pattern)
if err != nil {
t.Errorf("%s: Glob(prefix=%q, pattern=%q): %s", label, test.prefix, test.pattern, err)
continue
}
sort.Strings(test.matches)
sort.Strings(matches)
if !reflect.DeepEqual(matches, test.matches) {
t.Errorf("%s: Glob(prefix=%q, pattern=%q): got %v, want %v", label, test.prefix, test.pattern, matches, test.matches)
}
}
}
func fetchFile(remote vfs.FileSystem, local rwvfs.FileSystem, path string, fi os.FileInfo, dryRun bool) error {
kb := float64(fi.Size()) / 1024
if GlobalOpt.Verbose || dryRun {
log.Printf("Fetching %s (%.1fkb)", path, kb)
}
if dryRun {
return nil
}
if err := rwvfs.MkdirAll(local, filepath.Dir(path)); err != nil {
return err
}
rf, err := remote.Open(path)
if err != nil {
return fmt.Errorf("remote file: %s", err)
}
defer rf.Close()
lf, err := local.Create(path)
if err != nil {
return fmt.Errorf("local file: %s", err)
}
defer lf.Close()
if _, err := io.Copy(lf, rf); err != nil {
return fmt.Errorf("copy from remote to local: %s", err)
}
if GlobalOpt.Verbose {
log.Printf("Fetched %s (%.1fkb)", path, kb)
}
if err := lf.Close(); err != nil {
return fmt.Errorf("local file: %s", err)
}
return nil
}
func (c *ConfigCmd) Execute(args []string) error {
if c.w == nil {
c.w = os.Stdout
}
if c.Quiet {
c.w = nopWriteCloser{}
}
cfg, err := getInitialConfig(c.Options, c.Args.Dir.String())
if err != nil {
return err
}
if len(cfg.PreConfigCommands) > 0 {
if err := runPreConfigCommands(c.Args.Dir.String(), cfg.PreConfigCommands, c.ToolchainExecOpt, c.Quiet); err != nil {
return fmt.Errorf("PreConfigCommands: %s", err)
}
}
if err := scanUnitsIntoConfig(cfg, c.Options, c.ToolchainExecOpt, c.Quiet); err != nil {
return fmt.Errorf("failed to scan for source units: %s", err)
}
localRepo, err := OpenRepo(c.Args.Dir.String())
if err != nil {
return fmt.Errorf("failed to open repo: %s", err)
}
buildStore, err := buildstore.LocalRepo(localRepo.RootDir)
if err != nil {
return err
}
commitFS := buildStore.Commit(localRepo.CommitID)
// Write source units to build cache.
if !c.NoCacheWrite {
if err := rwvfs.MkdirAll(commitFS, "."); err != nil {
return err
}
for _, u := range cfg.SourceUnits {
unitFile := plan.SourceUnitDataFilename(unit.SourceUnit{}, u)
if err := rwvfs.MkdirAll(commitFS, filepath.Dir(unitFile)); err != nil {
return err
}
f, err := commitFS.Create(unitFile)
if err != nil {
return err
}
defer f.Close()
if err := json.NewEncoder(f).Encode(u); err != nil {
return err
}
if err := f.Close(); err != nil {
log.Fatal(err)
}
}
}
if c.Output.Output == "json" {
PrintJSON(cfg, "")
} else {
fmt.Fprintf(c.w, "SCANNERS (%d)\n", len(cfg.Scanners))
for _, s := range cfg.Scanners {
fmt.Fprintf(c.w, " - %s\n", s)
}
fmt.Fprintln(c.w)
fmt.Fprintf(c.w, "SOURCE UNITS (%d)\n", len(cfg.SourceUnits))
for _, u := range cfg.SourceUnits {
fmt.Fprintf(c.w, " - %s: %s\n", u.Type, u.Name)
}
fmt.Fprintln(c.w)
fmt.Fprintf(c.w, "CONFIG PROPERTIES (%d)\n", len(cfg.Config))
for _, kv := range sortedMap(cfg.Config) {
fmt.Fprintf(c.w, " - %s: %s\n", kv[0], kv[1])
}
}
return nil
}
