Do a bit more towards global security metadata

Still need to sort out the Time serialization issue; leave a comment
to this effect.

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

diff --git a/main.go b/main.go
index 8f87918853051b30aa456649e472d614963c2367..e93c46df1d0b16646e5af67d0f831325e4085582 100644 (file)
--- a/main.go
+++ b/main.go
@@ -12,17 +12,17 @@ var repos struct {
 }
 
 func OpenRepos() (err error) {
-       repos.xen, err = XenRepoOpen(config.GetXenPath(), XRXen)
+       repos.xen, err = XenRepoOpen(config.Tool.GetXenPath(), XRXen)
        if err != nil {
                return 
        }
 
-       repos.qemuu, err = XenRepoOpen(config.GetQemuuPath(), XRQemuu)
+       repos.qemuu, err = XenRepoOpen(config.Tool.GetQemuuPath(), XRQemuu)
        if err != nil {
                return
        }
 
-       repos.qemut, err = XenRepoOpen(config.GetQemutPath(), XRQemut)
+       repos.qemut, err = XenRepoOpen(config.Tool.GetQemutPath(), XRQemut)
        if err != nil {
                return
        }
@@ -44,7 +44,10 @@ func VersionsFromArgs(args []string) (vers []XenVersion) {
 
 type MainFunc func(int, []string) (int)
 
-var config ToolConfig
+var config struct {
+       Tool     ToolConfig
+       Security SecurityMeta
+}
 
 var xsa XSAMeta
 
@@ -117,7 +120,7 @@ func main() {
        }
        
        if loadConfig {
-               err := config.Load()
+               err := config.Tool.Load()
                if err != nil {
                        fmt.Printf("Error finding config: %v\n", err)
                        os.Exit(1)

diff --git a/meta.go b/meta.go
index 32573eedff48005750a614a7cd5c2966571c2da3..2de292053349e70ee406b09fd0b3f9a7ff5ae7a2 100644 (file)
--- a/meta.go
+++ b/meta.go
@@ -60,7 +60,7 @@ func (tc *ToolConfig) Load() (err error) {
 
 func (tc *ToolConfig) Save() (err error) {
        if tc.rootDir == "" {
-               return fmt.Errorf("Uninitialized root dir\n")
+               return fmt.Errorf("Uninitialized root dir")
        }
 
        b, err := json.MarshalIndent(*tc, "", "  ")
@@ -104,6 +104,8 @@ func (tc ToolConfig) GetQemutPath() (s string) {
        return
 }
 
+// FIXME: Need to figure out a good way to serialize time in a
+// human-readable way
 type VersionMeta struct {
        XenVersion
        ReleaseDate     time.Time
@@ -114,6 +116,47 @@ type SecurityMeta struct {
        Versions []VersionMeta
 }
 
+const GlobalMetaFilename = "global.meta"
+
+func (sm *SecurityMeta) Load() (err error) {
+       if config.Tool.GetXSAPath() == "" {
+               return fmt.Errorf("Tool config not loaded")
+       }
+
+       filename := config.Tool.GetXSAPath() + "/" + GlobalMetaFilename
+       
+       b, err := ioutil.ReadFile(filename)
+       if err != nil {
+               if os.IsNotExist(err) {
+                       // No problem if the file doesn't exist; just use the null config
+                       return nil
+               } else {
+                       return fmt.Errorf("Opening global metadata file %s: %v\n", filename, err)
+               }
+       }
+
+       err = json.Unmarshal(b, sm)
+       return
+}
+
+func (sm *SecurityMeta) Save() (err error) {
+       if config.Tool.GetXSAPath() == "" {
+               return fmt.Errorf("Tool config not loaded")
+       }
+
+       b, err := json.MarshalIndent(*sm, "", "  ")
+       if err != nil {
+               return fmt.Errorf("Marshalling config: %v", err)
+       }
+
+       filename := config.Tool.GetXSAPath() + "/" + GlobalMetaFilename
+       err = ioutil.WriteFile(filename, b, 0666)
+       if err != nil {
+               return fmt.Errorf("Writing config: %v", err)
+       }
+       return
+}
+
 type XSAMeta struct {
        XSA               int
        SupportedVersions []XenVersion

diff --git a/recipe.go b/recipe.go
index 609ac95c88f6d603c2c1eec9b083f59556880c24..8830c0d9830b80412a60b6b2d1b54a634199aa56 100644 (file)
--- a/recipe.go
+++ b/recipe.go
@@ -194,7 +194,7 @@ func (r *Recipe) MakePatches(prefix string, sync bool) (err error) {
                        xsabase += "-"+r.XenVersionFull.XenVersion().String()
                }
 
-               xsatgt := config.XSAPath+"/"+xsabase
+               xsatgt := config.Tool.GetXSAPath()+"/"+xsabase
                
                // rm -rf ../xsa.git/xsa206-unstable
                // Do a full remove of $base and $base.patch just to be sure
@@ -330,7 +330,7 @@ func (r *Recipe) Apply(prefix string) (err error) {
 
                for _, glob := range tr.Prereqs {
                        // git am
-                       _, err = xr.AmClean(config.GetXSAPath()+"/"+glob)
+                       _, err = xr.AmClean(config.Tool.GetXSAPath()+"/"+glob)
                        if err != nil {
                                return fmt.Errorf("Appling am %s: %v\n", glob, err)
                        }
@@ -345,7 +345,7 @@ func (r *Recipe) Apply(prefix string) (err error) {
 
                for _, glob := range tr.Patches {
                        // git am
-                       _, err = xr.AmClean(config.GetXSAPath()+"/"+glob)
+                       _, err = xr.AmClean(config.Tool.GetXSAPath()+"/"+glob)
                        if err != nil {
                                return fmt.Errorf("Appling am %s: %v\n", glob, err)
                        }

diff --git a/repo.go b/repo.go
index ba3ef05515af394792d7a31d15907da0b1bc829f..fd062a4c9d15efd50d251cf090d8dba9d6346f9d 100644 (file)
--- a/repo.go
+++ b/repo.go
@@ -28,7 +28,7 @@ func MainRepoInit(xsanum int, args []string) (ret int) {
        }
 
        fmt.Printf("Trying local config...\n")
-       if err := config.Load(); err != nil && !os.IsNotExist(err) {
+       if err := config.Tool.Load(); err != nil && !os.IsNotExist(err) {
                fmt.Printf("Error opening config file: %v\n", err)
                return 1
        }
@@ -42,10 +42,10 @@ func MainRepoInit(xsanum int, args []string) (ret int) {
                }
        }
 
-       setDef(&config.XSAPath, "xsa.git")
-       setDef(&config.XenPath, "xen.git")
-       setDef(&config.QemuuPath, "qemu-xen.git")
-       setDef(&config.QemutPath, "qemu-xen-traditional.git")
+       setDef(&config.Tool.XSAPath, "xsa.git")
+       setDef(&config.Tool.XenPath, "xen.git")
+       setDef(&config.Tool.QemuuPath, "qemu-xen.git")
+       setDef(&config.Tool.QemutPath, "qemu-xen-traditional.git")
 
        checkDir := func(target string) (clone bool, err error) {
                _, err = os.Stat(target)
@@ -92,24 +92,24 @@ func MainRepoInit(xsanum int, args []string) (ret int) {
        }
 
        var err error
-       if repos.xen, err = cloneXen(config.XenPath, "git://xenbits.xenproject.org/xen.git", XRXen); err != nil {
+       if repos.xen, err = cloneXen(config.Tool.XenPath, "git://xenbits.xenproject.org/xen.git", XRXen); err != nil {
                fmt.Printf("Trying to clone Xen: %v\n", err)
                return 1
        }
-       if repos.qemuu, err = cloneXen(config.QemuuPath, "git://xenbits.xenproject.org/qemu-xen.git", XRQemuu); err != nil {
+       if repos.qemuu, err = cloneXen(config.Tool.QemuuPath, "git://xenbits.xenproject.org/qemu-xen.git", XRQemuu); err != nil {
                fmt.Printf("Trying to clone Qemuu: %v\n", err)
                return 1
        }
-       if repos.qemut, err = cloneXen(config.QemutPath, "git://xenbits.xenproject.org/qemu-xen-traditional.git", XRQemut); err != nil {
+       if repos.qemut, err = cloneXen(config.Tool.QemutPath, "git://xenbits.xenproject.org/qemu-xen-traditional.git", XRQemut); err != nil {
                fmt.Printf("Trying to clone Qemut: %v\n", err)
                return 1
        }
-       if repos.xsa, err = cloneNormal(config.XSAPath, "xenbits.xen.org:/home/xensec/git/xsa.git"); err != nil {
+       if repos.xsa, err = cloneNormal(config.Tool.XSAPath, "xenbits.xen.org:/home/xensec/git/xsa.git"); err != nil {
                fmt.Printf("Trying to clone xsa.git: %v\n", err)
                return 1
        }
 
-       if err = config.Save(); err != nil {
+       if err = config.Tool.Save(); err != nil {
                fmt.Print("Trying to save configfile: %v\n", err)
                return 1
        }
@@ -118,10 +118,11 @@ func MainRepoInit(xsanum int, args []string) (ret int) {
 }
 
 func MainRepoInfo(xsanum int, args []string) (ret int) {
-       fmt.Printf("rootDir: %s\n", config.rootDir)
-       fmt.Printf("XSA repo: %s\n", config.GetXSAPath())
-       fmt.Printf("Xen repo: %s\n", config.GetXenPath())
-       fmt.Printf("Qemu Upstream repo: %s\n", config.GetQemuuPath())
-       fmt.Printf("Qemu Traditional repo: %s\n", config.GetQemutPath())
+       fmt.Printf("[Tool]\n")
+       fmt.Printf("rootDir: %s\n", config.Tool.rootDir)
+       fmt.Printf("XSA repo: %s\n", config.Tool.GetXSAPath())
+       fmt.Printf("Xen repo: %s\n", config.Tool.GetXenPath())
+       fmt.Printf("Qemu Upstream repo: %s\n", config.Tool.GetQemuuPath())
+       fmt.Printf("Qemu Traditional repo: %s\n", config.Tool.GetQemutPath())
        return 0
 }