Merge "jiri: Remove support for old-style manifests."
diff --git a/.api b/.api
index d02b8f3..3983236 100644
--- a/.api
+++ b/.api
@@ -16,14 +16,12 @@
pkg jiri, method (*X) JiriManifestFile() string
pkg jiri, method (*X) ProfilesDBDir() string
pkg jiri, method (*X) ProfilesRootDir() string
-pkg jiri, method (*X) ResolveManifestPath(string) (string, error)
pkg jiri, method (*X) RootMetaDir() string
pkg jiri, method (*X) ScriptsDir() string
pkg jiri, method (*X) UpdateHistoryDir() string
pkg jiri, method (*X) UpdateHistoryLatestLink() string
pkg jiri, method (*X) UpdateHistorySecondLatestLink() string
pkg jiri, method (*X) UsageErrorf(string, ...interface{}) error
-pkg jiri, method (*X) UsingOldManifests() bool
pkg jiri, method (RelPath) Abs(*X) string
pkg jiri, method (RelPath) Join(...string) RelPath
pkg jiri, method (RelPath) Symbolic() string
diff --git a/cmd/jiri/cmd.go b/cmd/jiri/cmd.go
index a5d8ab5..5363083 100644
--- a/cmd/jiri/cmd.go
+++ b/cmd/jiri/cmd.go
@@ -41,7 +41,6 @@
cmdRebuild,
cmdSnapshot,
cmdUpdate,
- cmdUpgrade,
cmdWhich,
},
Topics: []cmdline.Topic{
diff --git a/cmd/jiri/doc.go b/cmd/jiri/doc.go
index 2b58edd..61a3e10 100644
--- a/cmd/jiri/doc.go
+++ b/cmd/jiri/doc.go
@@ -20,7 +20,6 @@
rebuild Rebuild all jiri tools
snapshot Manage project snapshots
update Update all jiri tools and projects
- upgrade Upgrade jiri to new-style manifests
which Show path to the jiri tool
help Display help for commands or topics
@@ -713,49 +712,6 @@
-v=false
Print verbose output.
-Jiri upgrade - Upgrade jiri to new-style manifests
-
-Upgrades jiri to use new-style manifests.
-
-The old (deprecated) behavior only allowed a single manifest repository, located
-in $JIRI_ROOT/.manifest. The initial manifest file is located as follows:
- 1) Use -manifest flag, if non-empty. If it's empty...
- 2) Use $JIRI_ROOT/.local_manifest file. If it doesn't exist...
- 3) Use $JIRI_ROOT/.manifest/v2/default.
-
-The new behavior allows multiple manifest repositories, by allowing imports to
-specify project attributes describing the remote repository. The -manifest flag
-is no longer allowed to be set; the initial manifest file is always located in
-$JIRI_ROOT/.jiri_manifest. The .local_manifest file is ignored.
-
-During the transition phase, both old and new behaviors are supported. The jiri
-tool uses the existence of the $JIRI_ROOT/.jiri_manifest file as the signal; if
-it exists we run the new behavior, otherwise we run the old behavior.
-
-The new behavior includes a "jiri import" command, which writes or updates the
-.jiri_manifest file. The new bootstrap procedure runs "jiri import", and it is
-intended as a regular command to add imports to your jiri environment.
-
-This upgrade command eases the transition by writing an initial .jiri_manifest
-file for you. If you have an existing .local_manifest file, its contents will
-be incorporated into the new .jiri_manifest file, and it will be renamed to
-.local_manifest.BACKUP. The -revert flag deletes the .jiri_manifest file, and
-restores the .local_manifest file.
-
-Usage:
- jiri upgrade [flags] <kind>
-
-<kind> specifies the kind of upgrade, one of "v23" or "fuchsia".
-
-The jiri upgrade flags are:
- -revert=false
- Revert the upgrade by deleting the $JIRI_ROOT/.jiri_manifest file.
-
- -color=true
- Use color to format output.
- -v=false
- Print verbose output.
-
Jiri which - Show path to the jiri tool
Which behaves similarly to the unix commandline tool. It is useful in
diff --git a/cmd/jiri/snapshot_test.go b/cmd/jiri/snapshot_test.go
index 151fb9b..78167a6 100644
--- a/cmd/jiri/snapshot_test.go
+++ b/cmd/jiri/snapshot_test.go
@@ -307,7 +307,7 @@
fake.EnableRemoteManifestPush()
defer fake.DisableRemoteManifestPush()
- manifestDir := filepath.Join(fake.X.Root, ".manifest")
+ manifestDir := filepath.Join(fake.X.Root, "manifest")
snapshotDir := filepath.Join(manifestDir, "snapshot")
label := "test"
diff --git a/cmd/jiri/upgrade.go b/cmd/jiri/upgrade.go
deleted file mode 100644
index 08eb99a..0000000
--- a/cmd/jiri/upgrade.go
+++ /dev/null
@@ -1,150 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
- "fmt"
- "os"
- "path/filepath"
-
- "v.io/jiri"
- "v.io/jiri/project"
- "v.io/jiri/runutil"
- "v.io/x/lib/cmdline"
-)
-
-// TODO(toddw): Remove the upgrade command after the transition to new-style
-// manifests is complete.
-
-var flagUpgradeRevert bool
-
-func init() {
- cmdUpgrade.Flags.BoolVar(&flagUpgradeRevert, "revert", false, `Revert the upgrade by deleting the $JIRI_ROOT/.jiri_manifest file.`)
-}
-
-var cmdUpgrade = &cmdline.Command{
- Runner: jiri.RunnerFunc(runUpgrade),
- Name: "upgrade",
- Short: "Upgrade jiri to new-style manifests",
- Long: `
-Upgrades jiri to use new-style manifests.
-
-The old (deprecated) behavior only allowed a single manifest repository, located
-in $JIRI_ROOT/.manifest. The initial manifest file is located as follows:
- 1) Use -manifest flag, if non-empty. If it's empty...
- 2) Use $JIRI_ROOT/.local_manifest file. If it doesn't exist...
- 3) Use $JIRI_ROOT/.manifest/v2/default.
-
-The new behavior allows multiple manifest repositories, by allowing imports to
-specify project attributes describing the remote repository. The -manifest flag
-is no longer allowed to be set; the initial manifest file is always located in
-$JIRI_ROOT/.jiri_manifest. The .local_manifest file is ignored.
-
-During the transition phase, both old and new behaviors are supported. The jiri
-tool uses the existence of the $JIRI_ROOT/.jiri_manifest file as the signal; if
-it exists we run the new behavior, otherwise we run the old behavior.
-
-The new behavior includes a "jiri import" command, which writes or updates the
-.jiri_manifest file. The new bootstrap procedure runs "jiri import", and it is
-intended as a regular command to add imports to your jiri environment.
-
-This upgrade command eases the transition by writing an initial .jiri_manifest
-file for you. If you have an existing .local_manifest file, its contents will
-be incorporated into the new .jiri_manifest file, and it will be renamed to
-.local_manifest.BACKUP. The -revert flag deletes the .jiri_manifest file, and
-restores the .local_manifest file.
-`,
- ArgsName: "<kind>",
- ArgsLong: `
-<kind> specifies the kind of upgrade, one of "v23" or "fuchsia".
-`,
-}
-
-func runUpgrade(jirix *jiri.X, args []string) error {
- localFile := filepath.Join(jirix.Root, ".local_manifest")
- backupFile := localFile + ".BACKUP"
- if flagUpgradeRevert {
- // Restore .local_manifest.BACKUP if it exists.
- switch _, err := jirix.NewSeq().Stat(backupFile); {
- case err != nil && !runutil.IsNotExist(err):
- return err
- case err == nil:
- if err := jirix.NewSeq().Rename(backupFile, localFile).Done(); err != nil {
- return fmt.Errorf("couldn't restore %v to %v: %v", backupFile, localFile, err)
- }
- }
- // Deleting the .jiri_manifest file reverts to the old behavior.
- return jirix.NewSeq().Remove(jirix.JiriManifestFile()).Done()
- }
- if len(args) != 1 {
- return jirix.UsageErrorf("must specify upgrade kind")
- }
- kind := args[0]
- var argRemote, argName, argManifest string
- switch kind {
- case "v23":
- argRemote = "https://vanadium.googlesource.com/manifest"
- argName, argManifest = "manifest", "public"
- case "fuchsia":
- argRemote = "https://fuchsia.googlesource.com/fnl-start"
- argName, argManifest = "fnl-start", "manifest/fuchsia"
- default:
- return jirix.UsageErrorf("unknown upgrade kind %q", kind)
- }
- // Initialize manifest from .local_manifest.
- hasLocalFile := true
- manifest, err := project.ManifestFromFile(jirix, localFile)
- if err != nil {
- if !runutil.IsNotExist(err) {
- return err
- }
- hasLocalFile = false
- manifest = &project.Manifest{}
- }
- oldImports := manifest.Imports
- manifest.Imports = nil
- for _, oldImport := range oldImports {
- if oldImport.Remote != "" {
- // This is a new-style remote import, carry it over directly.
- manifest.Imports = append(manifest.Imports, oldImport)
- continue
- }
- // This is an old-style import, convert it to the new style.
- oldName := oldImport.Name
- switch {
- case kind == "v23" && oldName == "default":
- oldName = "public"
- case kind == "fuchsia" && oldName == "default":
- oldName = "manifest/fuchsia"
- }
- manifest.Imports = append(manifest.Imports, project.Import{
- Manifest: oldName,
- Name: argName,
- Remote: argRemote,
- })
- }
- if len(manifest.Imports) == 0 {
- manifest.Imports = append(manifest.Imports, project.Import{
- Manifest: argManifest,
- Name: argName,
- Remote: argRemote,
- })
- }
- // Write output to .jiri_manifest file.
- outFile := jirix.JiriManifestFile()
- if _, err := os.Stat(outFile); err == nil {
- return fmt.Errorf("%v already exists", outFile)
- }
- if err := manifest.ToFile(jirix, outFile); err != nil {
- return err
- }
- // Backup .local_manifest file, if it exists.
- if hasLocalFile {
- if err := jirix.NewSeq().Rename(localFile, backupFile).Done(); err != nil {
- return fmt.Errorf("couldn't backup %v to %v: %v", localFile, backupFile, err)
- }
- }
- return nil
-}
diff --git a/cmd/jiri/upgrade_test.go b/cmd/jiri/upgrade_test.go
deleted file mode 100644
index 16f4f72..0000000
--- a/cmd/jiri/upgrade_test.go
+++ /dev/null
@@ -1,310 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
- "fmt"
- "io/ioutil"
- "os"
- "strings"
- "testing"
-
- "v.io/jiri"
- "v.io/x/lib/gosh"
-)
-
-type upgradeTestCase struct {
- Args []string
- Exist bool
- Local, Want string
- Stderr string
-}
-
-func TestUpgrade(t *testing.T) {
- tests := []upgradeTestCase{
- {
- Stderr: `must specify upgrade kind`,
- },
- {
- Args: []string{"foo"},
- Stderr: `unknown upgrade kind "foo"`,
- },
- // Test v23 upgrades.
- {
- Args: []string{"v23"},
- Exist: true,
- Stderr: `.jiri_manifest already exists`,
- },
- {
- Args: []string{"v23"},
- Want: `<manifest>
- <imports>
- <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"v23"},
- Local: `<manifest>
- <imports>
- <import name="default"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"v23"},
- Local: `<manifest>
- <imports>
- <import name="private"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"v23"},
- Local: `<manifest>
- <imports>
- <import name="private"/>
- <import name="infrastructure"/>
- <import name="default"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- <import manifest="infrastructure" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"v23"},
- Local: `<manifest>
- <imports>
- <import name="default"/>
- <import name="infrastructure"/>
- <import name="private"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- <import manifest="infrastructure" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- </imports>
-</manifest>
-`,
- },
- // Test fuchsia upgrades.
- {
- Args: []string{"fuchsia"},
- Exist: true,
- Stderr: `.jiri_manifest already exists`,
- },
- {
- Args: []string{"fuchsia"},
- Want: `<manifest>
- <imports>
- <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"fuchsia"},
- Local: `<manifest>
- <imports>
- <import name="default"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"fuchsia"},
- Local: `<manifest>
- <imports>
- <import name="private"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="private" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"fuchsia"},
- Local: `<manifest>
- <imports>
- <import name="private"/>
- <import name="infrastructure"/>
- <import name="default"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="private" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- <import manifest="infrastructure" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- </imports>
-</manifest>
-`,
- },
- {
- Args: []string{"fuchsia"},
- Local: `<manifest>
- <imports>
- <import name="default"/>
- <import name="infrastructure"/>
- <import name="private"/>
- </imports>
-</manifest>
-`,
- Want: `<manifest>
- <imports>
- <import manifest="manifest/fuchsia" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- <import manifest="infrastructure" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- <import manifest="private" name="fnl-start" remote="https://fuchsia.googlesource.com/fnl-start"/>
- </imports>
-</manifest>
-`,
- },
- }
- sh := gosh.NewShell(t)
- defer sh.Cleanup()
- jiriTool := gosh.BuildGoPkg(sh, sh.MakeTempDir(), "v.io/jiri/cmd/jiri")
- for _, test := range tests {
- if err := testUpgrade(t, jiriTool, test); err != nil {
- t.Errorf("%v: %v", test.Args, err)
- }
- }
-}
-
-func testUpgrade(t *testing.T, jiriTool string, test upgradeTestCase) error {
- sh := gosh.NewShell(t)
- sh.PropagateChildOutput = true
- defer sh.Cleanup()
- jiriRoot := sh.MakeTempDir()
- sh.Pushd(jiriRoot)
- // Set up an existing file or local_manifest, if they were specified
- if test.Exist {
- if err := ioutil.WriteFile(".jiri_manifest", []byte("<manifest/>"), 0644); err != nil {
- return err
- }
- }
- if test.Local != "" {
- if err := ioutil.WriteFile(".local_manifest", []byte(test.Local), 0644); err != nil {
- return err
- }
- }
- // Run upgrade and check the error.
- sh.Vars[jiri.RootEnv] = jiriRoot
- cmd := sh.Cmd(jiriTool, append([]string{"upgrade"}, test.Args...)...)
- if test.Stderr != "" {
- cmd.ExitErrorIsOk = true
- }
- _, stderr := cmd.StdoutStderr()
- if got, want := stderr, test.Stderr; !strings.Contains(got, want) || (got != "" && want == "") {
- return fmt.Errorf("stderr got %q, want substr %q", got, want)
- }
- // Make sure the right file is generated.
- if test.Want != "" {
- data, err := ioutil.ReadFile(".jiri_manifest")
- if err != nil {
- return err
- }
- if got, want := string(data), test.Want; got != want {
- return fmt.Errorf("GOT\n%s\nWANT\n%s", got, want)
- }
- }
- // Make sure the .local_manifest file is backed up.
- if test.Local != "" && test.Stderr == "" {
- data, err := ioutil.ReadFile(".local_manifest.BACKUP")
- if err != nil {
- return fmt.Errorf("local manifest backup got error: %v", err)
- }
- if got, want := string(data), test.Local; got != want {
- return fmt.Errorf("local manifest backup GOT\n%s\nWANT\n%s", got, want)
- }
- }
- return nil
-}
-
-func TestUpgradeRevert(t *testing.T) {
- sh := gosh.NewShell(t)
- defer sh.Cleanup()
- jiriRoot := sh.MakeTempDir()
- sh.Pushd(jiriRoot)
- jiriTool := gosh.BuildGoPkg(sh, sh.MakeTempDir(), "v.io/jiri/cmd/jiri")
- localData := `<manifest/>`
- jiriData := `<manifest>
- <imports>
- <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
- </imports>
-</manifest>
-`
- // Set up an existing local_manifest.
- if err := ioutil.WriteFile(".local_manifest", []byte(localData), 0644); err != nil {
- t.Errorf("couldn't write local manifest: %v", err)
- }
- // Run a regular upgrade first, and make sure files are as expected.
- sh.Vars[jiri.RootEnv] = jiriRoot
- sh.Cmd(jiriTool, "upgrade", "v23").Run()
- gotJiri, err := ioutil.ReadFile(".jiri_manifest")
- if err != nil {
- t.Errorf("couldn't read jiri manifest: %v", err)
- }
- if got, want := string(gotJiri), jiriData; got != want {
- t.Errorf("jiri manifest GOT\n%s\nWANT\n%s", got, want)
- }
- gotBackup, err := ioutil.ReadFile(".local_manifest.BACKUP")
- if err != nil {
- t.Errorf("couldn't read local manifest backup: %v", err)
- }
- if got, want := string(gotBackup), localData; got != want {
- t.Errorf("local manifest backup GOT\n%s\nWANT\n%s", got, want)
- }
- // Now run a revert, and make sure files are as expected.
- sh.Cmd(jiriTool, "upgrade", "-revert").Run()
- if _, err := os.Stat(".jiri_manifest"); !os.IsNotExist(err) {
- t.Errorf(".jiri_manifest still exists after revert: %v", err)
- }
- if _, err := os.Stat(".local_manifest.BACKUP"); !os.IsNotExist(err) {
- t.Errorf(".local_manifest.BACKUP still exists after revert: %v", err)
- }
- gotLocal, err := ioutil.ReadFile(".local_manifest")
- if err != nil {
- t.Errorf("couldn't read local manifest: %v", err)
- }
- if got, want := string(gotLocal), localData; got != want {
- t.Errorf("local manifest GOT\n%s\nWANT\n%s", got, want)
- }
-}
diff --git a/jiritest/.api b/jiritest/.api
index 5ba67b4..48b6fe4 100644
--- a/jiritest/.api
+++ b/jiritest/.api
@@ -5,10 +5,10 @@
pkg jiritest, method (FakeJiriRoot) CreateRemoteProject(string) error
pkg jiritest, method (FakeJiriRoot) DisableRemoteManifestPush() error
pkg jiritest, method (FakeJiriRoot) EnableRemoteManifestPush() error
-pkg jiritest, method (FakeJiriRoot) ReadLocalManifest() (*project.Manifest, error)
+pkg jiritest, method (FakeJiriRoot) ReadJiriManifest() (*project.Manifest, error)
pkg jiritest, method (FakeJiriRoot) ReadRemoteManifest() (*project.Manifest, error)
pkg jiritest, method (FakeJiriRoot) UpdateUniverse(bool) error
-pkg jiritest, method (FakeJiriRoot) WriteLocalManifest(*project.Manifest) error
+pkg jiritest, method (FakeJiriRoot) WriteJiriManifest(*project.Manifest) error
pkg jiritest, method (FakeJiriRoot) WriteRemoteManifest(*project.Manifest) error
pkg jiritest, type FakeJiriRoot struct
pkg jiritest, type FakeJiriRoot struct, Projects map[string]string
diff --git a/jiritest/fake.go b/jiritest/fake.go
index 155fc74..f0aa2e5 100644
--- a/jiritest/fake.go
+++ b/jiritest/fake.go
@@ -24,11 +24,10 @@
}
const (
- defaultDataDir = "data"
- defaultManifest = "default"
- manifestProject = ".manifest"
- manifestVersion = "v2"
- toolsProject = "tools"
+ defaultDataDir = "data"
+ manifestFileName = "public"
+ manifestProjectName = "manifest"
+ manifestProjectPath = "manifest"
)
// NewFakeJiriRoot returns a new FakeJiriRoot and a cleanup closure. The
@@ -48,40 +47,34 @@
t.Fatalf("TempDir() failed: %v", err)
}
fake.remote = remoteDir
- if err := fake.CreateRemoteProject(manifestProject); err != nil {
+ if err := fake.CreateRemoteProject(manifestProjectPath); err != nil {
t.Fatal(err)
}
- if err := fake.CreateRemoteProject(toolsProject); err != nil {
- t.Fatal(err)
- }
-
// Create a fake manifest.
- manifestDir := filepath.Join(remoteDir, manifestProject, manifestVersion)
+ manifestDir := filepath.Join(remoteDir, manifestProjectPath)
if err := s.MkdirAll(manifestDir, os.FileMode(0700)).Done(); err != nil {
t.Fatal(err)
}
if err := fake.WriteRemoteManifest(&project.Manifest{}); err != nil {
t.Fatal(err)
}
- if err := gitutil.New(jirix.NewSeq()).CloneRecursive(fake.Projects[manifestProject], filepath.Join(jirix.Root, manifestProject)); err != nil {
- t.Fatal(err)
- }
-
- // Add the "tools" project and a fake "jiri" tool to the
- // manifests. This is necessary to make sure that the commonly
- // invoked DataDirPath() function, which uses the "jiri" tool
- // configuration for its default, works.
+ // Add the "manifest" project to the manifest.
if err := fake.AddProject(project.Project{
- Name: toolsProject,
- Path: toolsProject,
- Remote: fake.Projects[toolsProject],
+ Name: manifestProjectName,
+ Path: manifestProjectPath,
+ Remote: fake.Projects[manifestProjectName],
}); err != nil {
t.Fatal(err)
}
- if err := fake.AddTool(project.Tool{
- Name: "jiri",
- Data: defaultDataDir,
- Project: toolsProject,
+ // Create a .jiri_manifest file which imports the manifest created above.
+ if err := fake.WriteJiriManifest(&project.Manifest{
+ Imports: []project.Import{
+ project.Import{
+ Manifest: manifestFileName,
+ Name: manifestProjectName,
+ Remote: filepath.Join(fake.remote, manifestProjectPath),
+ },
+ },
}); err != nil {
t.Fatal(err)
}
@@ -140,7 +133,7 @@
// DisableRemoteManifestPush disables pushes to the remote manifest
// repository.
func (fake FakeJiriRoot) DisableRemoteManifestPush() error {
- dir := gitutil.RootDirOpt(filepath.Join(fake.remote, manifestProject))
+ dir := gitutil.RootDirOpt(filepath.Join(fake.remote, manifestProjectPath))
if err := gitutil.New(fake.X.NewSeq(), dir).CheckoutBranch("master"); err != nil {
return err
}
@@ -150,7 +143,7 @@
// EnableRemoteManifestPush enables pushes to the remote manifest
// repository.
func (fake FakeJiriRoot) EnableRemoteManifestPush() error {
- dir := gitutil.RootDirOpt(filepath.Join(fake.remote, manifestProject))
+ dir := gitutil.RootDirOpt(filepath.Join(fake.remote, manifestProjectPath))
if !gitutil.New(fake.X.NewSeq(), dir).BranchExists("non-master") {
if err := gitutil.New(fake.X.NewSeq(), dir).CreateBranch("non-master"); err != nil {
return err
@@ -178,23 +171,9 @@
return nil
}
-func getManifest(jirix *jiri.X) string {
- manifest := jirix.Manifest()
- if manifest != "" {
- return manifest
- }
- return defaultManifest
-}
-
-// ReadLocalManifest read a manifest from the local manifest project.
-func (fake FakeJiriRoot) ReadLocalManifest() (*project.Manifest, error) {
- path := filepath.Join(fake.X.Root, manifestProject, manifestVersion, getManifest(fake.X))
- return project.ManifestFromFile(fake.X, path)
-}
-
// ReadRemoteManifest read a manifest from the remote manifest project.
func (fake FakeJiriRoot) ReadRemoteManifest() (*project.Manifest, error) {
- path := filepath.Join(fake.remote, manifestProject, manifestVersion, getManifest(fake.X))
+ path := filepath.Join(fake.remote, manifestProjectPath, manifestFileName)
return project.ManifestFromFile(fake.X, path)
}
@@ -212,30 +191,33 @@
return nil
}
-// WriteLocalManifest writes the given manifest to the local
-// manifest project.
-func (fake FakeJiriRoot) WriteLocalManifest(manifest *project.Manifest) error {
- dir := filepath.Join(fake.X.Root, manifestProject)
- path := filepath.Join(dir, manifestVersion, getManifest(fake.X))
- return fake.writeManifest(manifest, dir, path)
+// ReadJiriManifest reads the .jiri_manifest manifest.
+func (fake FakeJiriRoot) ReadJiriManifest() (*project.Manifest, error) {
+ return project.ManifestFromFile(fake.X, fake.X.JiriManifestFile())
+}
+
+// WriteJiriManifest writes the given manifest to the .jiri_manifest file.
+func (fake FakeJiriRoot) WriteJiriManifest(manifest *project.Manifest) error {
+ return manifest.ToFile(fake.X, fake.X.JiriManifestFile())
}
// WriteRemoteManifest writes the given manifest to the remote
// manifest project.
func (fake FakeJiriRoot) WriteRemoteManifest(manifest *project.Manifest) error {
- dir := filepath.Join(fake.remote, manifestProject)
- path := filepath.Join(dir, manifestVersion, getManifest(fake.X))
+ dir := filepath.Join(fake.remote, manifestProjectPath)
+ path := filepath.Join(dir, manifestFileName)
return fake.writeManifest(manifest, dir, path)
}
func (fake FakeJiriRoot) writeManifest(manifest *project.Manifest, dir, path string) error {
+ git := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(dir))
if err := manifest.ToFile(fake.X, path); err != nil {
return err
}
- if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(dir)).Add(path); err != nil {
+ if err := git.Add(path); err != nil {
return err
}
- if err := gitutil.New(fake.X.NewSeq(), gitutil.RootDirOpt(dir)).Commit(); err != nil {
+ if err := git.Commit(); err != nil {
return err
}
return nil
diff --git a/project/project.go b/project/project.go
index 18c8cd1..5bc5c0a 100644
--- a/project/project.go
+++ b/project/project.go
@@ -220,13 +220,6 @@
Manifest string `xml:"manifest,attr,omitempty"`
// Name is the name of the remote manifest project, used to determine the
// project key.
- //
- // If Remote and Manifest are empty, it is the old-style name of the manifest
- // to import, similar to localimport. This is deprecated behavior, and will be
- // removed.
- //
- // TODO(toddw): Remove the old behavior when the transition to new-style
- // manifests is complete.
Name string `xml:"name,attr,omitempty"`
// Protocol is the version control protocol used by the remote manifest
// project. If not set, "git" is used as the default.
@@ -243,47 +236,28 @@
}
func (i *Import) fillDefaults() error {
- if i.Remote != "" {
- if i.Protocol == "" {
- i.Protocol = "git"
- }
- if i.RemoteBranch == "" {
- i.RemoteBranch = "master"
- }
+ if i.Protocol == "" {
+ i.Protocol = "git"
+ }
+ if i.RemoteBranch == "" {
+ i.RemoteBranch = "master"
}
return i.validate()
}
func (i *Import) unfillDefaults() error {
- if i.Remote != "" {
- if i.Protocol == "git" {
- i.Protocol = ""
- }
- if i.RemoteBranch == "master" {
- i.RemoteBranch = ""
- }
+ if i.Protocol == "git" {
+ i.Protocol = ""
+ }
+ if i.RemoteBranch == "master" {
+ i.RemoteBranch = ""
}
return i.validate()
}
func (i *Import) validate() error {
- // After our transition is done, the "import" element will always denote
- // remote imports, and the "remote" and "manifest" attributes will be
- // required. During the transition we allow old-style local imports, which
- // only set the "name" attribute.
- //
- // This is a bit tricky, since the "name" attribute is allowed in both old and
- // new styles, but have different semantics. We distinguish between old and
- // new styles based on the existence of the "remote" attribute.
- oldStyle := *i
- oldStyle.Name = ""
- switch {
- case i.Name != "" && oldStyle == Import{}:
- // Only "name" is set, this is the old-style.
- case i.Remote != "" && i.Manifest != "":
- // At least "remote" and "manifest" are set, this is the new-style.
- default:
- return fmt.Errorf("bad import: neither old style (only name is set) or new style (at least remote and manifest are set): %+v", *i)
+ if i.Manifest == "" || i.Remote == "" {
+ return fmt.Errorf("bad import: both manifest and remote must be specified")
}
return nil
}
@@ -396,13 +370,6 @@
XMLName struct{} `xml:"project"`
}
-var (
- startUpperProjectBytes = []byte("<Project")
- startLowerProjectBytes = []byte("<project")
- endUpperProjectBytes = []byte("</Project>")
- endLowerProjectBytes = []byte("</project>")
-)
-
// ProjectFromFile returns a project parsed from the contents of filename,
// with defaults filled in and all paths absolute.
func ProjectFromFile(jirix *jiri.X, filename string) (*Project, error) {
@@ -411,16 +378,6 @@
return nil, err
}
- // Previous versions of the jiri tool had a bug where the project start and
- // end elements were in upper-case, since the XMLName field was missing. That
- // bug is now fixed, but the xml.Unmarshal call is case-sensitive, and will
- // fail if it sees the upper-case version. This hack rewrites the elements to
- // the lower-case version.
- //
- // TODO(toddw): Remove when the transition to new manifests is complete.
- data = bytes.Replace(data, startUpperProjectBytes, startLowerProjectBytes, -1)
- data = bytes.Replace(data, endUpperProjectBytes, endLowerProjectBytes, -1)
-
p := new(Project)
if err := xml.Unmarshal(data, p); err != nil {
return nil, err
@@ -684,17 +641,11 @@
}
// Add all tools from the current manifest to the snapshot manifest.
- var tools Tools
- if jirix.UsingOldManifests() {
- // TODO(nlacasse): Remove this logic when the transition to new manifests is done.
- _, tools, err = LoadManifest(jirix)
- } else {
- // We can't just call LoadManifest here, since that determines the
- // local projects using FastScan, but if we're calling CreateSnapshot
- // during "jiri update" and we added some new projects, they won't be
- // found anymore.
- _, tools, err = loadManifestFile(jirix, jirix.JiriManifestFile(), localProjects)
- }
+ // We can't just call LoadManifest here, since that determines the
+ // local projects using FastScan, but if we're calling CreateSnapshot
+ // during "jiri update" and we added some new projects, they won't be
+ // found anymore.
+ _, tools, err := loadManifestFile(jirix, jirix.JiriManifestFile(), localProjects)
if err != nil {
return err
}
@@ -921,10 +872,6 @@
// resolving remote and local imports. Returns the projects and tools specified
// by the manifest.
//
-// If the user is still using old-style manifests, it uses the old
-// ResolveManifestPath logic to determine the initial manifest file, since the
-// .jiri_manifest doesn't exist.
-//
// WARNING: LoadManifest cannot be run multiple times in parallel! It invokes
// git operations which require a lock on the filesystem. If you see errors
// about ".git/index.lock exists", you are likely calling LoadManifest in
@@ -932,18 +879,8 @@
func LoadManifest(jirix *jiri.X) (Projects, Tools, error) {
jirix.TimerPush("load manifest")
defer jirix.TimerPop()
- var (
- file string
- localProjects Projects
- err error
- )
- // TODO(toddw): Remove old manifest logic when the transition is complete.
- if jirix.UsingOldManifests() {
- file, err = jirix.ResolveManifestPath(jirix.Manifest())
- } else {
- file = jirix.JiriManifestFile()
- localProjects, err = LocalProjects(jirix, FastScan)
- }
+ file := jirix.JiriManifestFile()
+ localProjects, err := LocalProjects(jirix, FastScan)
if err != nil {
return nil, nil, err
}
@@ -983,10 +920,6 @@
func loadUpdatedManifest(jirix *jiri.X, localProjects Projects) (Projects, Tools, string, error) {
jirix.TimerPush("load updated manifest")
defer jirix.TimerPop()
- if jirix.UsingOldManifests() {
- projects, tools, err := loadUpdatedManifestDeprecated(jirix)
- return projects, tools, "", err
- }
ld := newManifestLoader(localProjects, true)
if err := ld.Load(jirix, "", jirix.JiriManifestFile(), ""); err != nil {
return nil, nil, ld.TmpDir, err
@@ -994,30 +927,6 @@
return ld.Projects, ld.Tools, ld.TmpDir, nil
}
-// TODO(toddw): Remove this logic when the transition to new manifests is done.
-func loadUpdatedManifestDeprecated(jirix *jiri.X) (Projects, Tools, error) {
- manifestPath := filepath.Join(jirix.Root, ".manifest")
- manifestRemote, err := getManifestRemote(jirix, manifestPath)
- if err != nil {
- return nil, nil, err
- }
- project := Project{
- Path: manifestPath,
- Remote: manifestRemote,
- }
- if err := project.fillDefaults(); err != nil {
- return nil, nil, err
- }
- if err := syncProjectMaster(jirix, project); err != nil {
- return nil, nil, err
- }
- file, err := jirix.ResolveManifestPath(jirix.Manifest())
- if err != nil {
- return nil, nil, err
- }
- return loadManifestFile(jirix, file, nil)
-}
-
// UpdateUniverse updates all local projects and tools to match the remote
// counterparts identified in the manifest. Optionally, the 'gc' flag can be
// used to indicate that local projects that no longer exist remotely should be
@@ -1638,10 +1547,6 @@
}
// Process remote imports.
for _, remote := range m.Imports {
- if remote.Remote == "" {
- // Old-style named imports handled in loop below.
- continue
- }
nextRoot := filepath.Join(root, remote.Root)
key := remote.ProjectKey()
p, ok := ld.localProjects[key]
@@ -1668,9 +1573,9 @@
}
ld.localProjects[key] = p
}
- // Reset the project to its specified branch and load the next file.
- // Note that we call load() recursively, so multiple files may be
- // loaded by resetAndLoad.
+ // Reset the project to its specified branch and load the next file. Note
+ // that we call load() recursively, so multiple files may be loaded by
+ // resetAndLoad.
p.Revision = "HEAD"
p.RemoteBranch = remote.RemoteBranch
nextFile := filepath.Join(p.Path, remote.Manifest)
@@ -1678,22 +1583,6 @@
return err
}
}
- // Process old-style named imports.
- //
- // TODO(toddw): Remove this logic when the manifest transition is done.
- for _, named := range m.Imports {
- if named.Remote != "" {
- // New-style remote imports handled in loop above.
- continue
- }
- nextFile, err := jirix.ResolveManifestPath(named.Name)
- if err != nil {
- return err
- }
- if err := ld.Load(jirix, root, nextFile, ""); err != nil {
- return err
- }
- }
// Process local imports.
for _, local := range m.LocalImports {
// TODO(toddw): Add our invariant check that the file is in the same
diff --git a/project/project_test.go b/project/project_test.go
index fb12f3e..d8b44f1 100644
--- a/project/project_test.go
+++ b/project/project_test.go
@@ -19,43 +19,28 @@
"v.io/jiri/gitutil"
"v.io/jiri/jiritest"
"v.io/jiri/project"
- "v.io/jiri/runutil"
)
-func addRemote(t *testing.T, jirix *jiri.X, localProject, name, remoteProject string) {
- cwd, err := os.Getwd()
- if err != nil {
+func checkReadme(t *testing.T, jirix *jiri.X, p project.Project, message string) {
+ if _, err := jirix.NewSeq().Stat(p.Path); err != nil {
t.Fatalf("%v", err)
}
- defer jirix.NewSeq().Chdir(cwd)
- if err := jirix.NewSeq().Chdir(localProject).Done(); err != nil {
- t.Fatalf("%v", err)
- }
- if err := gitutil.New(jirix.NewSeq()).AddRemote(name, remoteProject); err != nil {
- t.Fatalf("%v", err)
- }
-}
-
-func checkReadme(t *testing.T, jirix *jiri.X, project, message string) {
- if _, err := jirix.NewSeq().Stat(project); err != nil {
- t.Fatalf("%v", err)
- }
- readmeFile := filepath.Join(project, "README")
+ readmeFile := filepath.Join(p.Path, "README")
data, err := ioutil.ReadFile(readmeFile)
if err != nil {
t.Fatalf("ReadFile(%v) failed: %v", readmeFile, err)
}
if got, want := data, []byte(message); bytes.Compare(got, want) != 0 {
- t.Fatalf("unexpected content %v:\ngot\n%s\nwant\n%s\n", project, got, want)
+ t.Fatalf("unexpected content in project %v:\ngot\n%s\nwant\n%s\n", p.Name, got, want)
}
}
// Checks that /.jiri/ is ignored in a local project checkout
-func checkGitIgnore(t *testing.T, jirix *jiri.X, project string) {
- if _, err := jirix.NewSeq().Stat(project); err != nil {
+func checkMetadataIsIgnored(t *testing.T, jirix *jiri.X, p project.Project) {
+ if _, err := jirix.NewSeq().Stat(p.Path); err != nil {
t.Fatalf("%v", err)
}
- gitInfoExcludeFile := filepath.Join(project, ".git", "info", "exclude")
+ gitInfoExcludeFile := filepath.Join(p.Path, ".git", "info", "exclude")
data, err := ioutil.ReadFile(gitInfoExcludeFile)
if err != nil {
t.Fatalf("ReadFile(%v) failed: %v", gitInfoExcludeFile, err)
@@ -66,30 +51,6 @@
}
}
-func createLocalManifestCopy(t *testing.T, jirix *jiri.X, dir, manifestDir string) {
- // Load the remote manifest.
- m, err := project.ManifestFromFile(jirix, filepath.Join(manifestDir, "v2", "default"))
- if err != nil {
- t.Fatal(err)
- }
- // Store the manifest locally.
- if err := m.ToFile(jirix, filepath.Join(dir, ".local_manifest")); err != nil {
- t.Fatal(err)
- }
-}
-
-func createLocalManifestStub(t *testing.T, jirix *jiri.X, dir string) {
- // Create a manifest stub.
- manifest := project.Manifest{}
- imp := project.Import{}
- imp.Name = "default"
- manifest.Imports = append(manifest.Imports, imp)
- // Store the manifest locally.
- if err := manifest.ToFile(jirix, filepath.Join(dir, ".local_manifest")); err != nil {
- t.Fatal(err)
- }
-}
-
func commitFile(t *testing.T, jirix *jiri.X, dir, file, msg string) {
cwd, err := os.Getwd()
if err != nil {
@@ -104,126 +65,8 @@
}
}
-func createRemoteManifest(t *testing.T, jirix *jiri.X, dir string, remotes []string) {
- manifestDir, perm := filepath.Join(dir, "v2"), os.FileMode(0755)
- if err := jirix.NewSeq().MkdirAll(manifestDir, perm).Done(); err != nil {
- t.Fatalf("%v", err)
- }
- manifest := project.Manifest{}
- for i, remote := range remotes {
- project := project.Project{
- Name: remote,
- Path: localProjectName(i),
- Protocol: "git",
- Remote: remote,
- }
- manifest.Projects = append(manifest.Projects, project)
- }
- commitManifest(t, jirix, &manifest, dir)
-}
-
-func commitManifest(t *testing.T, jirix *jiri.X, manifest *project.Manifest, manifestDir string) {
- manifestFile := filepath.Join(manifestDir, "v2", "default")
- if err := manifest.ToFile(jirix, manifestFile); err != nil {
- t.Fatal(err)
- }
- commitFile(t, jirix, manifestDir, manifestFile, "creating manifest")
-}
-
-func createProject(t *testing.T, jirix *jiri.X, manifestDir, name, remote, path string) {
- m, err := project.ManifestFromFile(jirix, filepath.Join(manifestDir, "v2", "default"))
- if err != nil {
- t.Fatal(err)
- }
- m.Projects = append(m.Projects, project.Project{Name: name, Remote: remote, Path: path})
- commitManifest(t, jirix, m, manifestDir)
-}
-
-func deleteProject(t *testing.T, jirix *jiri.X, manifestDir, remote string) {
- m, err := project.ManifestFromFile(jirix, filepath.Join(manifestDir, "v2", "default"))
- if err != nil {
- t.Fatal(err)
- }
- deleteKey := project.MakeProjectKey(remote, remote)
- var projects []project.Project
- for _, p := range m.Projects {
- if p.Key() != deleteKey {
- projects = append(projects, p)
- }
- }
- m.Projects = projects
- commitManifest(t, jirix, m, manifestDir)
-}
-
-// Identify the current revision for a given project.
-func currentRevision(t *testing.T, jirix *jiri.X, name string) string {
- cwd, err := os.Getwd()
- if err != nil {
- t.Fatalf("%v", err)
- }
- defer jirix.NewSeq().Chdir(cwd)
- if err := jirix.NewSeq().Chdir(name).Done(); err != nil {
- t.Fatalf("%v", err)
- }
- revision, err := gitutil.New(jirix.NewSeq()).CurrentRevision()
- if err != nil {
- t.Fatalf("%v", err)
- }
- return revision
-}
-
-// Fix the revision in the manifest file.
-func setRevisionForProject(t *testing.T, jirix *jiri.X, manifestDir, name, revision string) {
- m, err := project.ManifestFromFile(jirix, filepath.Join(manifestDir, "v2", "default"))
- if err != nil {
- t.Fatal(err)
- }
- updated := false
- for i, p := range m.Projects {
- if p.Name == name {
- p.Revision = revision
- m.Projects[i] = p
- updated = true
- break
- }
- }
- if !updated {
- t.Fatalf("failed to fix revision for project %v", name)
- }
- commitManifest(t, jirix, m, manifestDir)
-}
-
-func holdProjectBack(t *testing.T, jirix *jiri.X, manifestDir, name string) {
- revision := currentRevision(t, jirix, name)
- setRevisionForProject(t, jirix, manifestDir, name, revision)
-}
-
-func localProjectName(i int) string {
- return "test-local-project-" + fmt.Sprintf("%d", i)
-}
-
-func moveProject(t *testing.T, jirix *jiri.X, manifestDir, name, dst string) {
- m, err := project.ManifestFromFile(jirix, filepath.Join(manifestDir, "v2", "default"))
- if err != nil {
- t.Fatal(err)
- }
- updated := false
- for i, p := range m.Projects {
- if p.Name == name {
- p.Path = dst
- m.Projects[i] = p
- updated = true
- break
- }
- }
- if !updated {
- t.Fatalf("failed to set path for project %v", name)
- }
- commitManifest(t, jirix, m, manifestDir)
-}
-
-func remoteProjectName(i int) string {
- return "test-remote-project-" + fmt.Sprintf("%d", i)
+func projectName(i int) string {
+ return fmt.Sprintf("project-%d", i)
}
func setupNewProject(t *testing.T, jirix *jiri.X, dir, name string, ignore bool) string {
@@ -258,14 +101,6 @@
return projectDir
}
-func writeEmptyMetadata(t *testing.T, jirix *jiri.X, projectDir string) {
- metadataFile := filepath.Join(projectDir, jiri.ProjectMetaDir, jiri.ProjectMetaFile)
- p := project.Project{}
- if err := p.ToFile(jirix, metadataFile); err != nil {
- t.Fatal(err)
- }
-}
-
func writeReadme(t *testing.T, jirix *jiri.X, projectDir, message string) {
path, perm := filepath.Join(projectDir, "README"), os.FileMode(0644)
if err := ioutil.WriteFile(path, []byte(message), perm); err != nil {
@@ -274,34 +109,6 @@
commitFile(t, jirix, projectDir, path, "creating README")
}
-func createAndCheckoutBranch(t *testing.T, jirix *jiri.X, projectDir, branch string) {
- cwd, err := os.Getwd()
- if err != nil {
- t.Fatalf("%v", err)
- }
- defer jirix.NewSeq().Chdir(cwd)
- if err := jirix.NewSeq().Chdir(projectDir).Done(); err != nil {
- t.Fatalf("%v", err)
- }
- if err := gitutil.New(jirix.NewSeq()).CreateAndCheckoutBranch(branch); err != nil {
- t.Fatalf("%v", err)
- }
-}
-
-func resetToOriginMaster(t *testing.T, jirix *jiri.X, projectDir string) {
- cwd, err := os.Getwd()
- if err != nil {
- t.Fatalf("%v", err)
- }
- defer jirix.NewSeq().Chdir(cwd)
- if err := jirix.NewSeq().Chdir(projectDir).Done(); err != nil {
- t.Fatalf("%v", err)
- }
- if err := gitutil.New(jirix.NewSeq()).Reset("origin/master"); err != nil {
- t.Fatalf("%v", err)
- }
-}
-
func checkProjectsMatchPaths(t *testing.T, gotProjects project.Projects, wantProjectPaths []string) {
gotProjectPaths := []string{}
for _, p := range gotProjects {
@@ -323,7 +130,7 @@
// Create some projects.
numProjects, projectPaths := 3, []string{}
for i := 0; i < numProjects; i++ {
- name := localProjectName(i)
+ name := projectName(i)
path := setupNewProject(t, jirix, jirix.Root, name, true)
p := project.Project{
Path: path,
@@ -341,7 +148,7 @@
Projects: []project.Project{
{
Name: projectPaths[0],
- Path: localProjectName(0),
+ Path: projectName(0),
Protocol: "git",
Remote: projectPaths[0],
},
@@ -381,196 +188,300 @@
checkProjectsMatchPaths(t, foundProjects, projectPaths[1:])
}
-// TestUpdateUniverse is a comprehensive test of the "jiri update"
-// logic that handles projects.
-//
-// TODO(jsimsa): Add tests for the logic that updates tools.
-func TestUpdateUniverse(t *testing.T) {
- // Setup an instance of jiri universe, creating the remote repositories for
- // the manifest and projects under the ".remote" directory, which is ignored
- // from the consideration of LocalProjects().
- jirix, cleanup := jiritest.NewX(t)
- defer cleanup()
+// setupUniverse creates a fake jiri root with 3 remote projects. Each project
+// has a README with text "initial readme".
+func setupUniverse(t *testing.T) ([]project.Project, *jiritest.FakeJiriRoot, func()) {
+ fake, cleanup := jiritest.NewFakeJiriRoot(t)
+ success := false
+ defer func() {
+ if !success {
+ cleanup()
+ }
+ }()
- localDir := jirix.Root
- remoteDir := filepath.Join(jirix.Root, ".remote")
-
- localManifest := setupNewProject(t, jirix, localDir, ".manifest", false)
- writeEmptyMetadata(t, jirix, localManifest)
- remoteManifest := setupNewProject(t, jirix, remoteDir, "test-remote-manifest", false)
- addRemote(t, jirix, localManifest, "origin", remoteManifest)
- numProjects, remoteProjects := 6, []string{}
+ // Create some projects and add them to the remote manifest.
+ numProjects := 3
+ localProjects := []project.Project{}
for i := 0; i < numProjects; i++ {
- remoteProject := setupNewProject(t, jirix, remoteDir, remoteProjectName(i), true)
- remoteProjects = append(remoteProjects, remoteProject)
- }
- createRemoteManifest(t, jirix, remoteManifest, remoteProjects)
-
- // Check that calling UpdateUniverse() creates local copies of
- // the remote repositories, advancing projects to HEAD or to
- // the fixed revision set in the manifest.
- for _, remoteProject := range remoteProjects {
- writeReadme(t, jirix, remoteProject, "revision 1")
- }
- holdProjectBack(t, jirix, remoteManifest, remoteProjects[0])
- for _, remoteProject := range remoteProjects {
- writeReadme(t, jirix, remoteProject, "revision 2")
- }
- if err := project.UpdateUniverse(jirix, false); err != nil {
- t.Fatalf("%v", err)
- }
- checkCreateFn := func(i int, revision string) {
- localProject := filepath.Join(localDir, localProjectName(i))
- checkGitIgnore(t, jirix, localProject)
- if i == 0 {
- checkReadme(t, jirix, localProject, "revision 1")
- } else {
- checkReadme(t, jirix, localProject, revision)
+ name := projectName(i)
+ path := fmt.Sprintf("path-%d", i)
+ if err := fake.CreateRemoteProject(name); err != nil {
+ t.Fatal(err)
+ }
+ p := project.Project{
+ Name: name,
+ Path: filepath.Join(fake.X.Root, path),
+ Remote: fake.Projects[name],
+ }
+ localProjects = append(localProjects, p)
+ if err := fake.AddProject(p); err != nil {
+ t.Fatal(err)
}
}
- for i, _ := range remoteProjects {
- checkCreateFn(i, "revision 2")
+
+ // Create initial commit in each repo.
+ for _, remoteProjectDir := range fake.Projects {
+ writeReadme(t, fake.X, remoteProjectDir, "initial readme")
}
- // Commit more work to the remote repositories and check that
- // calling UpdateUniverse() advances project to HEAD or to the
- // fixed revision set in the manifest.
- holdProjectBack(t, jirix, remoteManifest, remoteProjects[1])
- for _, remoteProject := range remoteProjects {
- writeReadme(t, jirix, remoteProject, "revision 3")
+ success = true
+ return localProjects, fake, cleanup
+}
+
+// TestUpdateUniverseSimple tests that UpdateUniverse will pull remote projects
+// locally, and that jiri metadata is ignored in the repos.
+func TestUpdateUniverseSimple(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+
+ // Check that calling UpdateUniverse() creates local copies of the remote
+ // repositories, and that jiri metadata is ignored by git.
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
- if err := project.UpdateUniverse(jirix, false); err != nil {
- t.Fatalf("%v", err)
+ for _, p := range localProjects {
+ if err := s.AssertDirExists(p.Path).Done(); err != nil {
+ t.Fatalf("expected project to exist at path %q but none found", p.Path)
+ }
+ checkReadme(t, fake.X, p, "initial readme")
+ checkMetadataIsIgnored(t, fake.X, p)
}
- checkUpdateFn := func(i int, revision string) {
+}
+
+// TestUpdateUniverseWithRevision checks that UpdateUniverse will pull remote
+// projects at the specified revision.
+func TestUpdateUniverseWithRevision(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+
+ // Set project 1's revision in the manifest to the current revision.
+ git := gitutil.New(s, gitutil.RootDirOpt(fake.Projects[localProjects[1].Name]))
+ rev, err := git.CurrentRevision()
+ if err != nil {
+ t.Fatal(err)
+ }
+ m, err := fake.ReadRemoteManifest()
+ if err != nil {
+ t.Fatal(err)
+ }
+ projects := []project.Project{}
+ for _, p := range m.Projects {
+ if p.Name == localProjects[1].Name {
+ p.Revision = rev
+ }
+ projects = append(projects, p)
+ }
+ m.Projects = projects
+ if err := fake.WriteRemoteManifest(m); err != nil {
+ t.Fatal(err)
+ }
+ // Update README in all projects.
+ for _, remoteProjectDir := range fake.Projects {
+ writeReadme(t, fake.X, remoteProjectDir, "new revision")
+ }
+ // Check that calling UpdateUniverse() updates all projects except for
+ // project 1.
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
+ }
+ for i, p := range localProjects {
if i == 1 {
- checkReadme(t, jirix, filepath.Join(localDir, localProjectName(i)), "revision 2")
+ checkReadme(t, fake.X, p, "initial readme")
} else {
- checkCreateFn(i, revision)
+ checkReadme(t, fake.X, p, "new revision")
}
}
- for i, _ := range remoteProjects {
- checkUpdateFn(i, "revision 3")
+}
+
+// TestUpdateUniverseWithUncommitted checks that uncommitted files are not droped
+// by UpdateUniverse(). This ensures that the "git reset --hard" mechanism used
+// for pointing the master branch to a fixed revision does not lose work in
+// progress.
+func TestUpdateUniverseWithUncommitted(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
- // Create an uncommitted file and make sure UpdateUniverse()
- // does not drop it. This ensures that the "git reset --hard"
- // mechanism used for pointing the master branch to a fixed
- // revision does not lose work in progress.
- file, perm, want := filepath.Join(remoteProjects[1], "uncommitted_file"), os.FileMode(0644), []byte("uncommitted work")
+ // Create an uncommitted file in project 1.
+ file, perm, want := filepath.Join(localProjects[1].Path, "uncommitted_file"), os.FileMode(0644), []byte("uncommitted work")
if err := ioutil.WriteFile(file, want, perm); err != nil {
t.Fatalf("WriteFile(%v, %v) failed: %v", file, err, perm)
}
- if err := project.UpdateUniverse(jirix, false); err != nil {
- t.Fatalf("%v", err)
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
got, err := ioutil.ReadFile(file)
if err != nil {
t.Fatalf("%v", err)
}
if bytes.Compare(got, want) != 0 {
- t.Fatalf("unexpected content %v:\ngot\n%s\nwant\n%s\n", remoteProjects[1], got, want)
+ t.Fatalf("unexpected content %v:\ngot\n%s\nwant\n%s\n", localProjects[1], got, want)
+ }
+}
+
+// TestUpdateUniverseMovedProject checks that UpdateUniverse can move a
+// project.
+func TestUpdateUniverseMovedProject(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
- // Update the local path at which a remote project is to be
- // located and check that UpdateUniverse() moves the local
- // copy of the project.
- destination := filepath.Join("test", localProjectName(2))
- moveProject(t, jirix, remoteManifest, remoteProjects[2], destination)
- if err := project.UpdateUniverse(jirix, false); err != nil {
- t.Fatalf("%v", err)
+ // Update the local path at which project 1 is located.
+ m, err := fake.ReadRemoteManifest()
+ if err != nil {
+ t.Fatal(err)
}
- checkMoveFn := func(i int, revision string) {
- if i == 2 {
- checkReadme(t, jirix, filepath.Join(localDir, destination), revision)
- } else {
- checkUpdateFn(i, revision)
+ oldProjectPath := localProjects[1].Path
+ localProjects[1].Path = filepath.Join(fake.X.Root, "new-project-path")
+ projects := []project.Project{}
+ for _, p := range m.Projects {
+ if p.Name == localProjects[1].Name {
+ p.Path = localProjects[1].Path
}
+ projects = append(projects, p)
}
- for i, _ := range remoteProjects {
- checkMoveFn(i, "revision 3")
+ m.Projects = projects
+ if err := fake.WriteRemoteManifest(m); err != nil {
+ t.Fatal(err)
+ }
+ // Check that UpdateUniverse() moves the local copy of the project 1.
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.AssertDirExists(oldProjectPath).Done(); err == nil {
+ t.Fatalf("expected project %q at path %q not to exist but it did", localProjects[1].Name, oldProjectPath)
+ }
+ if err := s.AssertDirExists(localProjects[2].Path).Done(); err != nil {
+ t.Fatalf("expected project %q at path %q to exist but it did not", localProjects[1].Name, localProjects[1].Path)
+ }
+ checkReadme(t, fake.X, localProjects[1], "initial readme")
+}
+
+// TestUpdateUniverseDeletedProject checks that UpdateUniverse will delete a
+// project iff gc=true.
+func TestUpdateUniverseDeletedProject(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
- // Delete a remote project and check that UpdateUniverse()
- // deletes the local copy of the project.
- deleteProject(t, jirix, remoteManifest, remoteProjects[3])
- if err := project.UpdateUniverse(jirix, true); err != nil {
- t.Fatalf("%v", err)
+ // Delete project 1.
+ m, err := fake.ReadRemoteManifest()
+ if err != nil {
+ t.Fatal(err)
}
- checkDeleteFn := func(i int, revision string) {
- if i == 3 {
- localProject := filepath.Join(localDir, localProjectName(i))
- if _, err := jirix.NewSeq().Stat(localProject); err == nil {
- t.Fatalf("project %v has not been deleted", localProject)
- } else {
- if !runutil.IsNotExist(err) {
- t.Fatalf("%v", err)
- }
- }
- } else {
- checkMoveFn(i, revision)
+ projects := []project.Project{}
+ for _, p := range m.Projects {
+ if p.Name == localProjects[1].Name {
+ continue
}
+ projects = append(projects, p)
}
- for i, _ := range remoteProjects {
- checkDeleteFn(i, "revision 3")
+ m.Projects = projects
+ if err := fake.WriteRemoteManifest(m); err != nil {
+ t.Fatal(err)
+ }
+ // Check that UpdateUniverse() with gc=false does not delete the local copy
+ // of the project.
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.AssertDirExists(localProjects[1].Path).Done(); err != nil {
+ t.Fatalf("expected project %q at path %q to exist but it did not", localProjects[1].Name, localProjects[1].Path)
+ }
+ checkReadme(t, fake.X, localProjects[1], "initial readme")
+ // Check that UpdateUniverse() with gc=true does delete the local copy of
+ // the project.
+ if err := fake.UpdateUniverse(true); err != nil {
+ t.Fatal(err)
+ }
+ if err := s.AssertDirExists(localProjects[1].Path).Done(); err == nil {
+ t.Fatalf("expected project %q at path %q not to exist but it did", localProjects[1].Name, localProjects[3].Path)
+ }
+}
+
+// TestUpdateUniverseNewProjectSamePath checks that UpdateUniverse can handle a
+// new project with the same path as a deleted project, but a different path.
+func TestUpdateUniverseNewProjectSamePath(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
- // Delete a project and create a new one with a different name but the same
- // path. Check that UpdateUniverse() does not fail.
- deleteProject(t, jirix, remoteManifest, remoteProjects[4])
- createProject(t, jirix, remoteManifest, "new.project", remoteProjects[4], localProjectName(4))
- if err := project.UpdateUniverse(jirix, true); err != nil {
- t.Fatalf("%v", err)
+ // Delete a project 1 and create a new one with a different name but the
+ // same path.
+ m, err := fake.ReadRemoteManifest()
+ if err != nil {
+ t.Fatal(err)
}
-
- // Commit to a non-master branch of a remote project and check that
- // UpdateUniverse() can update the local project to point to a revision on
- // that branch.
- writeReadme(t, jirix, remoteProjects[5], "master commit")
- createAndCheckoutBranch(t, jirix, remoteProjects[5], "non_master")
- writeReadme(t, jirix, remoteProjects[5], "non master commit")
- remoteBranchRevision := currentRevision(t, jirix, remoteProjects[5])
- setRevisionForProject(t, jirix, remoteManifest, remoteProjects[5], remoteBranchRevision)
- if err := project.UpdateUniverse(jirix, true); err != nil {
- t.Fatalf("%v", err)
- }
- localProject := filepath.Join(localDir, localProjectName(5))
- localBranchRevision := currentRevision(t, jirix, localProject)
- if localBranchRevision != remoteBranchRevision {
- t.Fatalf("project 5 is at revision %v, expected %v\n", localBranchRevision, remoteBranchRevision)
- }
- // Reset back to origin/master so the next update without a "revision" works.
- resetToOriginMaster(t, jirix, localProject)
-
- // Create a local manifest that imports the remote manifest
- // and check that UpdateUniverse() has no effect.
- createLocalManifestStub(t, jirix, localDir)
- if err := project.UpdateUniverse(jirix, true); err != nil {
- t.Fatalf("%v", err)
- }
-
- checkRebaseFn := func(i int, revision string) {
- if i == 5 {
- checkReadme(t, jirix, localProject, "non master commit")
- } else {
- checkDeleteFn(i, revision)
+ newProjectName := "new-project-name"
+ projects := []project.Project{}
+ for _, p := range m.Projects {
+ if p.Path == localProjects[1].Path {
+ p.Name = newProjectName
}
+ projects = append(projects, p)
}
- for i, _ := range remoteProjects {
- checkRebaseFn(i, "revision 3")
+ localProjects[1].Name = newProjectName
+ m.Projects = projects
+ if err := fake.WriteRemoteManifest(m); err != nil {
+ t.Fatal(err)
+ }
+ // Check that UpdateUniverse() does not fail.
+ if err := fake.UpdateUniverse(true); err != nil {
+ t.Fatal(err)
+ }
+}
+
+// TestUpdateUniverseRemoteBranch checks that UpdateUniverse can pull from a
+// non-master remote branch.
+func TestUpdateUniverseRemoteBranch(t *testing.T) {
+ localProjects, fake, cleanup := setupUniverse(t)
+ defer cleanup()
+ s := fake.X.NewSeq()
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
}
- // Create a local manifest that matches the remote manifest,
- // then revert the remote manifest to its initial version and
- // check that UpdateUniverse() has no effect.
- createLocalManifestCopy(t, jirix, localDir, remoteManifest)
- createRemoteManifest(t, jirix, remoteManifest, remoteProjects)
- if err := project.UpdateUniverse(jirix, true); err != nil {
- t.Fatalf("%v", err)
+ // Commit to master branch of a project 1.
+ writeReadme(t, fake.X, fake.Projects[localProjects[1].Name], "master commit")
+ // Create and checkout a new branch of project 1 and make a new commit.
+ git := gitutil.New(s, gitutil.RootDirOpt(fake.Projects[localProjects[1].Name]))
+ if err := git.CreateAndCheckoutBranch("non-master"); err != nil {
+ t.Fatal(err)
}
- for i, _ := range remoteProjects {
- checkRebaseFn(i, "revision 3")
+ writeReadme(t, fake.X, fake.Projects[localProjects[1].Name], "non-master commit")
+ // Point the manifest to the new non-master branch.
+ m, err := fake.ReadRemoteManifest()
+ if err != nil {
+ t.Fatal(err)
}
+ projects := []project.Project{}
+ for _, p := range m.Projects {
+ if p.Name == localProjects[1].Name {
+ p.RemoteBranch = "non-master"
+ }
+ projects = append(projects, p)
+ }
+ m.Projects = projects
+ if err := fake.WriteRemoteManifest(m); err != nil {
+ t.Fatal(err)
+ }
+ // Check that UpdateUniverse pulls the commit from the non-master branch.
+ if err := fake.UpdateUniverse(false); err != nil {
+ t.Fatal(err)
+ }
+ checkReadme(t, fake.X, localProjects[1], "non-master commit")
}
func TestFileImportCycle(t *testing.T) {
@@ -928,9 +839,6 @@
Remote: "remote2",
RemoteBranch: "branch2",
},
- {
- Name: "oldimport",
- },
},
LocalImports: []project.LocalImport{
{File: "fileimport"},
@@ -968,7 +876,6 @@
<imports>
<import manifest="manifest1" name="remoteimport1" remote="remote1"/>
<import manifest="manifest2" name="remoteimport2" remote="remote2" remotebranch="branch2"/>
- <import name="oldimport"/>
<localimport file="fileimport"/>
</imports>
<projects>
@@ -1057,63 +964,3 @@
}
}
}
-
-func TestProjectFromFileBackwardsCompatible(t *testing.T) {
- jirix, cleanup := jiritest.NewX(t)
- defer cleanup()
-
- tests := []struct {
- XML string
- Project project.Project
- }{
- // Make sure <Project> opening tag is accepted.
- {
- `<Project name="project" path="path" remote="remote"/>`,
- project.Project{
- Name: "project",
- Path: filepath.Join(jirix.Root, "path"),
- Protocol: "git",
- Remote: "remote",
- RemoteBranch: "master",
- Revision: "HEAD",
- },
- },
- // Make sure <Project> opening and closing tags are accepted.
- {
- `<Project name="project" path="path" remote="remote"></Project>`,
- project.Project{
- Name: "project",
- Path: filepath.Join(jirix.Root, "path"),
- Protocol: "git",
- Remote: "remote",
- RemoteBranch: "master",
- Revision: "HEAD",
- },
- },
- // Make sure "this_attribute_should_be_ignored" is silently ignored.
- {
- `<Project this_attribute_should_be_ignored="junk" name="project" path="path" remote="remote" remotebranch="branch" revision="rev"></Project>`,
- project.Project{
- Name: "project",
- Path: filepath.Join(jirix.Root, "path"),
- Protocol: "git",
- Remote: "remote",
- RemoteBranch: "branch",
- Revision: "rev",
- },
- },
- }
- for index, test := range tests {
- filename := filepath.Join(jirix.Root, fmt.Sprintf("test-%d", index))
- if err := jirix.NewSeq().WriteFile(filename, []byte(test.XML), 0644).Done(); err != nil {
- t.Errorf("%+v WriteFile failed: %v", test.Project, err)
- }
- project, err := project.ProjectFromFile(jirix, filename)
- if err != nil {
- t.Errorf("%+v FromFile failed: %v", test.Project, err)
- }
- if got, want := project, &test.Project; !reflect.DeepEqual(got, want) {
- t.Errorf("%+v FromFile got %#v, want %#v", test.Project, got, want)
- }
- }
-}
diff --git a/x.go b/x.go
index 2dda4b1..726cdd8 100644
--- a/x.go
+++ b/x.go
@@ -143,14 +143,6 @@
return filepath.Join(x.Root, JiriManifestFile)
}
-// UsingOldManifests returns true iff the JIRI_ROOT/.jiri_manifest file does not
-// exist. This is the one signal used to decide whether to use the old manifest
-// logic (checking .local_manifest and the -manifest flag), or the new logic.
-func (x *X) UsingOldManifests() bool {
- _, err := os.Stat(x.JiriManifestFile())
- return os.IsNotExist(err)
-}
-
// BinDir returns the path to the bin directory.
func (x *X) BinDir() string {
return filepath.Join(x.RootMetaDir(), "bin")
@@ -188,43 +180,6 @@
return filepath.Join(x.UpdateHistoryDir(), "second-latest")
}
-// ResolveManifestPath resolves the given manifest name to an absolute path in
-// the local filesystem.
-//
-// TODO(toddw): Remove this once the transition to new manifests is done. In
-// the new world, we always start with the JiriManifestFile.
-func (x *X) ResolveManifestPath(name string) (string, error) {
- if x.UsingOldManifests() {
- return x.resolveManifestPathDeprecated(name)
- }
- if name != "" {
- return "", fmt.Errorf("-manifest flag isn't supported with .jiri_manifest")
- }
- return x.JiriManifestFile(), nil
-}
-
-// Deprecated logic, only run if JIRI_ROOT/.jiri_manifest doesn't exist.
-//
-// TODO(toddw): Remove this logic when the transition to .jiri_manifest is done.
-func (x *X) resolveManifestPathDeprecated(name string) (string, error) {
- manifestDir := filepath.Join(x.Root, ".manifest", "v2")
- if name != "" {
- if filepath.IsAbs(name) {
- return name, nil
- }
- return filepath.Join(manifestDir, name), nil
- }
- path := filepath.Join(x.Root, ".local_manifest")
- switch _, err := os.Stat(path); {
- case err == nil:
- return path, nil
- case os.IsNotExist(err):
- return filepath.Join(manifestDir, "default"), nil
- default:
- return "", fmt.Errorf("Stat(%v) failed: %v", path, err)
- }
-}
-
// RunnerFunc is an adapter that turns regular functions into cmdline.Runner.
// This is similar to cmdline.RunnerFunc, but the first function argument is
// jiri.X, rather than cmdline.Env.
