global: Open repos on-demand as needed

Rather than opening all repos whenever opening the config, only open
the necessary repos as needed.

Access global repos via GetRepo() rather than directly accessing the
map.

Initialize the map, and the repos, as needed.

Add xsa.OpenRepos() to open the repos necessary to work with a
particular XSA.  Call this as a prep for most XSA-related functions.

G.repos.xsa was only ever accessed from systemtest; have it open
xsa.git itself instead.

Signed-off-by: George Dunlap <george.dunlap@citrix.com>
---

diff --git a/global.go b/global.go
index a4d3ec86fd8ff99abaaeedacc2218b560bfdb833..4f21f6d1cadf9fbd8d4f0fb227f8016d57e85388 100644 (file)
--- a/global.go
+++ b/global.go
@@ -6,9 +6,9 @@ import (
 )
 
 func MainGlobalUpdate(unused *XSAMeta, args []string) int {
-       err := OpenRepos()
+       xr, err := G.repos.GetRepo(TreeXen)
        if err != nil {
-               fmt.Printf("Error opening repos: %v\n", err)
+               fmt.Printf("Error opening xen repo: %v\n", err)
                return 1
        }
 
@@ -45,7 +45,7 @@ func MainGlobalUpdate(unused *XSAMeta, args []string) int {
        }
 
        fmt.Printf("Getting Xen releases from tree...\n")
-       versions, err := G.repos.XenRepos[TreeXen].GetVersions()
+       versions, err := xr.GetVersions()
        if err != nil {
                fmt.Printf("Error getting Xen releases: %v\n", err)
                return 1

diff --git a/main.go b/main.go
index ce90acc16d1aad1ef7327677570afb21ec494ebd..92885b5e496a61a88bec0f728ce3968bb5f6c045 100644 (file)
--- a/main.go
+++ b/main.go
@@ -8,22 +8,38 @@ import (
        "strings"
 )
 
-func OpenRepos() (err error) {
-       open := func(t Tree) (err error) {
-               G.repos.XenRepos[t], err = XenRepoOpen(G.config.Tool.GetPath(t), t)
-               return
-       }
-
-       err = ForEachCodeTree(open)
+type GlobalRepos struct {
+       codeRepos map[Tree]*XenRepo
+}
 
-       G.repos.xsa, err = GitOpen(G.config.Tool.GetPath(TreeXSA))
+func (repos *GlobalRepos) GetRepo(t Tree) (xr *XenRepo, err error) {
+       if repos.codeRepos == nil {
+               repos.codeRepos = make(map[Tree]*XenRepo)
+       }
+       xr = repos.codeRepos[t]
+       if xr == nil {
+               xr, err = XenRepoOpen(G.config.Tool.GetPath(t), t)
+               if err != nil {
+                       return
+               }
+               repos.codeRepos[t] = xr
+       }
+       return
+}
 
+// "No-check" version of above function, for when you "know" it will succeed
+func (repos *GlobalRepos) GetRepoNC(t Tree) (xr *XenRepo) {
+       xr, _ = repos.GetRepo(t)
        return
 }
 
 func ForEachXenRepo(f func(*XenRepo, Tree) error) error {
-       f2 := func(tree Tree) (err error) {
-               xr := G.repos.XenRepos[tree]
+       f2 := func(tree Tree) (error) {
+               xr, err := G.repos.GetRepo(tree)
+
+               if err != nil {
+                       return err
+               }
 
                return f(xr, tree)
        }
@@ -63,10 +79,7 @@ var G struct {
                Tool     ToolConfig
                Security SecurityMeta
        }
-       repos struct {
-               XenRepos map[Tree]*XenRepo
-               xsa      Repo
-       }
+       repos GlobalRepos
        test struct {
                topdir string
        }
@@ -76,8 +89,6 @@ var G struct {
 func globalReset() {
        G.config.Tool = ToolConfig{}
        G.config.Security = SecurityMeta{}
-       G.repos.xsa = Repo{}
-       G.repos.XenRepos = make(map[Tree]*XenRepo)
        // Don't reset 'test' data
 }
 
@@ -97,6 +108,7 @@ func XsaMain(args []string) int {
        loadConfig := true
        loadGlobal := false
        loadXSA := false
+       checkXSARepos := true
 
        tgt := args[1]
        cmd := args[2]
@@ -109,6 +121,7 @@ func XsaMain(args []string) int {
                case "init":
                        main = MainInit
                        loadGlobal = true
+                       checkXSARepos = false
                case "sync-patches":
                        main = MainSyncPatches
                case "backport":
@@ -125,6 +138,7 @@ func XsaMain(args []string) int {
                        main = MainResetBase
                case "set-patches":
                        main = MainSetPatches
+                       checkXSARepos = false
                default:
                        fmt.Printf("Unknown command: %s\n", cmd)
                        return 1
@@ -167,11 +181,6 @@ func XsaMain(args []string) int {
                        fmt.Printf("Error finding config: %v\n", err)
                        return 1
                }
-
-               if err := OpenRepos(); err != nil {
-                       fmt.Printf("Error opening repos: %v\n", err)
-                       return 1
-               }
        }
 
        if loadGlobal {
@@ -188,6 +197,13 @@ func XsaMain(args []string) int {
                                xsanum, err)
                        return 1
                }
+               if checkXSARepos {
+                       err = xsa.OpenRepos()
+                       if err != nil {
+                               fmt.Printf("Error opening repos: %v\n", err)
+                               return 1
+                       }
+               }
        }
 
        return main(&xsa, args)

diff --git a/meta.go b/meta.go
index 1d769ecfb4fefc8c96a0115d3f58594f9099c32b..d1d87f9bffd80719f734ac3321ec4b851b3fc495 100644 (file)
--- a/meta.go
+++ b/meta.go
@@ -245,6 +245,16 @@ type XSAMeta struct {
        dirty bool
 }
 
+func (m *XSAMeta) OpenRepos() (err error) {
+       for _, t := range m.Trees {
+               _, err = G.repos.GetRepo(t)
+               if err != nil {
+                       return
+               }
+       }
+       return
+}
+
 func (m *XSAMeta) GetRecipe(v XenVersion) *Recipe {
        return m.Recipes[v]
 }

diff --git a/recipe.go b/recipe.go
index 2c5b700354b1ce40804a9fa62e648be08ed5b154..1ba7873e0f48beecc2642bb4700153d693341b34 100644 (file)
--- a/recipe.go
+++ b/recipe.go
@@ -97,7 +97,7 @@ func (r *Recipe) MakePatches(prefix string, sync bool) (count int, err error) {
        }
 
        makePatches := func(tree Tree) (err error) {
-               xr := G.repos.XenRepos[tree]
+               xr := G.repos.GetRepoNC(tree)
 
                branchHash, err := xr.ParseRef(branch)
                if err != nil {
@@ -285,7 +285,7 @@ func (r *Recipe) HasPatchBranch(prefix string) (err error) {
                        return
                }
 
-               xr := G.repos.XenRepos[tree]
+               xr := G.repos.GetRepoNC(tree)
 
                if !xr.VerifyRef(branch) {
                        return ErrorMissingBranch(branch)
@@ -338,7 +338,7 @@ func (r *Recipe) ApplyPatches(prefix string) (err error) {
                        return
                }
 
-               xr := G.repos.XenRepos[tree]
+               xr := G.repos.GetRepoNC(tree)
 
                _, baseline, branch := r.branchName(prefix)
 
@@ -373,7 +373,7 @@ func (r *Recipe) ApplyBaselines(prefix string) (err error) {
                        return
                }
 
-               xr := G.repos.XenRepos[tree]
+               xr := G.repos.GetRepoNC(tree)
 
                stable, baseline, _ := r.branchName(prefix)
 
@@ -462,7 +462,7 @@ func (r *Recipe) Backport(prefix string, to XenVersion) (err error) {
        _, toBase, toBranch := BranchName(prefix, r.xsa, to)
 
        backport := func(tree Tree) (err error) {
-               xr := G.repos.XenRepos[tree]
+               xr := G.repos.GetRepoNC(tree)
 
                // git checkout -b xsa/NNN/$to xsa/NNN/$from
                if err = xr.MakeBranch(toBranch, fromBranch); err != nil {
@@ -485,7 +485,7 @@ func (r *Recipe) Backport(prefix string, to XenVersion) (err error) {
 func (r *Recipe) Build(prefix string) (err error) {
        _, _, branch := r.branchName(prefix)
 
-       xenrepo := G.repos.XenRepos[TreeXen]
+       xenrepo := G.repos.GetRepoNC(TreeXen)
 
        /* Always check out a temporary branch for xen */
        tmpBranch := "xsa/tmp"
@@ -510,7 +510,7 @@ func (r *Recipe) Build(prefix string) (err error) {
        gitURLXSARepoConfig := func(configSpec string, tree Tree) {
                if tr, prs := r.Recipes[tree]; prs && tr.HasPatches() {
                        config.AddRepoPathAndRevision(configSpec,
-                               "file://"+G.repos.XenRepos[tree].GetPath(),
+                               "file://"+G.repos.GetRepoNC(tree).GetPath(),
                                branch)
                } else {
                        config.AddRepoCachedURL(configSpec, tree.RepoName())

diff --git a/repo.go b/repo.go
index 5cb36d25a91969abc27971729168cab0db5ca524..084ca9b45a6f8a9e06df33da946fc98d31ca8f15 100644 (file)
--- a/repo.go
+++ b/repo.go
@@ -109,8 +109,6 @@ func MainRepoInit(unused *XSAMeta, args []string) (ret int) {
                        err = xr.ConfigEnableRerere()
                }
 
-               G.repos.XenRepos[t] = xr
-
                return
        }
 
@@ -128,9 +126,9 @@ func MainRepoInit(unused *XSAMeta, args []string) (ret int) {
                origin := defaultUrl[tree]
 
                if tree == TreeXSA {
-                       G.repos.xsa, err = cloneNormal(target, origin)
+                       _, err = cloneNormal(target, origin)
                } else {
-                       G.repos.XenRepos[tree], err = cloneXen(target, origin, tree)
+                       _, err = cloneXen(target, origin, tree)
                }
                return
        }
@@ -197,7 +195,13 @@ func MainRepoInfo(unused *XSAMeta, args []string) (ret int) {
 }
 
 func MainRepoX(unused *XSAMeta, args []string) (ret int) {
-       versions, err := G.repos.XenRepos[TreeXen].GetVersions()
+       var versions []XenVersionFull
+       
+       xr, err := G.repos.GetRepo(TreeXen)
+
+       if err == nil {
+               versions, err = xr.GetVersions()
+       }
 
        if err != nil {
                fmt.Printf("Error getting versions: %v\n", err)

diff --git a/systemtest.go b/systemtest.go
index 17df15c1808c9f5748a98b68f814440e9aa21414..86b563acfb6c6e8e9f8cd15bb607fae646de99e5 100644 (file)
--- a/systemtest.go
+++ b/systemtest.go
@@ -127,12 +127,6 @@ func InitRepo(st *SystemTest) bool {
                        G.config.Tool.rootDir)
                return false
        }
-       // Most repos are open after `repo init`, but xsa.git may not
-       // be if it wasn't cloned.
-       if err := OpenRepos(); err != nil {
-               st.Errorf("Opening repos: %v\n", err)
-               return false
-       }
 
        if TestFlags.MirrorDir != EmptyString &&
                G.config.Tool.Cache.MirrorDir != TestFlags.MirrorDir {
@@ -150,22 +144,19 @@ func InitRepo(st *SystemTest) bool {
                return false
        }
 
-       // Most repos are open after `repo init`, but xsa.git may not
-       // be if it wasn't cloned.
-       if err := OpenRepos(); err != nil {
-               st.Errorf("Opening repos: %v\n", err)
-               return false
-       }
-
        updateBranches := func(t Tree) (err error) {
                var r *Repo
                if t == TreeXSA {
-                       r = &G.repos.xsa
+                       r = &Repo{}
+                       *r, err = GitOpen(G.config.Tool.GetPath(TreeXSA))
+                       if err != nil {
+                               return err
+                       }
                } else {
-                       xr, prs := G.repos.XenRepos[t]
-                       if !prs {
-                               err = fmt.Errorf("Not present: %s\n", t)
-                               return
+                       xr, err := G.repos.GetRepo(t)
+                       if err != nil {
+                               err = fmt.Errorf("Couldn't open %s: %v\n", t, err)
+                               return err
                        }
                        r = &xr.Repo
                }
@@ -231,7 +222,10 @@ func InitRepo(st *SystemTest) bool {
                "4.8": "4.8.0",
                "4.7": "4.7.2",
        }
-       r := G.repos.XenRepos[TreeXen]
+       r, err := G.repos.GetRepo(TreeXen)
+       if err != nil {
+               st.Errorf("Error opening Xen repo: %v\n", err)
+       }
        versions, err := r.GetVersions()
        if err != nil {
                st.Errorf("Error getting Xen releases: %v\n", err)
@@ -449,7 +443,11 @@ func Story206Implement(st *SystemTest) (pass bool) {
 
        // git am $PATH/xsa206-master/*.patch
 
-       out, err := G.repos.XenRepos[TreeXen].Am("../testdata/xsa206-unstable/*.patch")
+       xr, err := G.repos.GetRepo(TreeXen)
+       if err != nil {
+               st.Errorf("Error opening xen tree: %v\n", err)
+       }
+       out, err := xr.Am("../testdata/xsa206-unstable/*.patch")
        if err != nil {
                st.Errorf("Error importing example patches: %v %s\n", err, string(out))
                return
@@ -536,7 +534,7 @@ func Story206Backport(st *SystemTest) bool {
                // - How many patches had been applied?  (0)
                
                // Fake things up:
-               xr := G.repos.XenRepos[TreeXen]
+               xr, _ := G.repos.GetRepo(TreeXen)
                // - git rebase --abort
                if _, err := xr.RebaseAbort(); err != nil {
                        return fmt.Errorf("Error aborting rebase: %v\n", err)
@@ -547,8 +545,7 @@ func Story206Backport(st *SystemTest) bool {
                if err = xr.MakeBranch(branch, baseline); err != nil {
                        return fmt.Errorf("Error fixing up rebase: %v\n", err)
                }
-               _, err = G.repos.XenRepos[TreeXen].AmClean("../testdata/xsa206-"+
-                       v.String()+"/*.patch")
+               _, err = xr.AmClean("../testdata/xsa206-"+v.String()+"/*.patch")
                if err != nil {
                        return fmt.Errorf("Error importing example patches: %v\n", err)
                }

diff --git a/xsa.go b/xsa.go
index 758978f0945d5fbf5fad6d0c3e5fcaba86d71927..8280817fb66e65683a6a01623f914d0ea0eb0169 100644 (file)
--- a/xsa.go
+++ b/xsa.go
@@ -111,6 +111,11 @@ func MainInit(xsa *XSAMeta, args []string) (ret int) {
                xsa.Trees = append(xsa.Trees, tree)
        }
 
+       if err := xsa.OpenRepos(); err != nil {
+               fmt.Printf("Cannot open repos: %v\n", err)
+               return 1
+       }
+
        xsa.Recipes = make(map[XenVersion]*Recipe)
 
        for v := range sm.Versions {
@@ -122,7 +127,7 @@ func MainInit(xsa *XSAMeta, args []string) (ret int) {
                for _, t := range xsa.Trees {
                        var err error
 
-                       xr := G.repos.XenRepos[t]
+                       xr := G.repos.GetRepoNC(t)
 
                        if err = xr.MakeStableBranch(v); err != nil {
                                fmt.Printf("Checking out stable branch for version %v: %v\n",
@@ -160,7 +165,7 @@ func MainInit(xsa *XSAMeta, args []string) (ret int) {
        // Check out "xsa/NNN/master" on all relevant trees
        _, _, branch := BranchName("xsa", xsa.XSA, XenVersion("master"))
        for _, t := range xsa.Trees {
-               _, err := G.repos.XenRepos[t].Checkout(branch)
+               _, err := G.repos.GetRepoNC(t).Checkout(branch)
                if err != nil {
                        fmt.Printf("Checkout out branch %s\n", branch)
                        return 1
@@ -235,7 +240,6 @@ func MainResetBase(xsa *XSAMeta, args []string) (ret int) {
        //  -- Re-set stableref to upstream
        //  -- Re-apply recipe
 
-       
        vers := VersionsFromArgs(xsa, args, false)
 
        for _, v := range vers {
@@ -250,7 +254,7 @@ func MainResetBase(xsa *XSAMeta, args []string) (ret int) {
                for _, t := range xsa.Trees {
                        var err error
                        
-                       xr := G.repos.XenRepos[t]
+                       xr := G.repos.GetRepoNC(t)
 
                        if err = xr.MakeStableBranch(v); err != nil {
                                fmt.Printf("Checking out stable branch for tree %v version %v: %v\n",
@@ -312,7 +316,7 @@ func MainSetPatches(xsa *XSAMeta, args []string) (ret int) {
        for _, t := range xsa.Trees {
                var err error
                
-               xr := G.repos.XenRepos[t]
+               xr := G.repos.GetRepoNC(t)
                
                if err = xr.MakeStableBranch(v); err != nil {
                        fmt.Printf("Checking out stable branch for tree %v version %v: %v\n",