Refactor arguments to make "repo" target

Rather than "repoinit" as a single argument, make the first argument
the target (either an xsa or the repo), and separate commands based on
that.

Also fix a bug that causes a range check if there aren't enough
arguments.

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

diff --git a/main.go b/main.go
index 6d29235d49c0d599ccefb1b9a235905e0bab0b3d..7c64b713f57f45c8f5f376eb22215d13c345058b 100644 (file)
--- a/main.go
+++ b/main.go
@@ -49,34 +49,44 @@ func main() {
        
        args := os.Args
 
-       cmd := args[1]
+       if len(args) < 3 {
+               fmt.Printf("Not enough arguments\n")
+               os.Exit(1)
+       }
+
+       tgt := args[1]
        args = args[2:]
+       cmd := args[0]
+       args = args[1:]
 
-       if xsanum, err = strconv.Atoi(cmd); err == nil {
-               cmd = args[0]
-               args = args[1:]
-       }
-       
-       switch cmd {
-       case "repoinit":
-               main = MainRepoInit
-       case "test":
-               main = MainTest
-               loadConfig = true
-       case "new":
-               main = func(xsanum int, args []string) (int) {
-                       if xsanum == 0 {
-                               fmt.Printf("Error: Need an XSA\n")
-                               return 1
+       if xsanum, err = strconv.Atoi(tgt); err == nil {
+               switch cmd {
+               case "test":
+                       main = MainTest
+                       loadConfig = true
+               case "new":
+                       main = func(xsanum int, args []string) (int) {
+                               if xsanum == 0 {
+                                       fmt.Printf("Error: Need an XSA\n")
+                                       return 1
+                               }
+                               fmt.Printf("Would make new XSA %d\n", xsanum)
+                               return 0
                        }
-                       fmt.Printf("Would make new XSA %d\n", xsanum)
-                       return 0
+               default:
+                       fmt.Printf("Unknown command: %s\n", cmd)
+                       os.Exit(1)
+               }
+       } else if tgt == "repo" {
+               switch cmd {
+               case "init":
+                       main = MainRepoInit
+               default:
+                       fmt.Printf("Unknown command: %s\n", cmd)
+                       os.Exit(1)
                }
-       default:
-               fmt.Printf("Unknown command: %s\n", cmd)
-               os.Exit(1)
        }
-
+       
        if loadConfig {
                fmt.Printf("Would have loaded config\n");
        }

diff --git a/meta.go b/meta.go
index 6aebe28bf9dc6c4ac54b5461d1d28300f89e4d0f..e6467ce13f569ba4a1445945612f7dc9b259d2d3 100644 (file)
--- a/meta.go
+++ b/meta.go
@@ -6,6 +6,7 @@ import (
        "io/ioutil"
        "os"
        "fmt"
+       "time"
 )
 
 type ToolConfig struct {
@@ -80,11 +81,12 @@ func (tc ToolConfig) GetQemutPath() (s string) {
 
 type VersionMeta struct {
        XenVersion
-       ReleaseDate     string
-       SecurityEndDate string
+       ReleaseDate     time.Time
+       SecurityEndDate time.Time
 }
 
 type SecurityMeta struct {
+       Versions []VersionMeta
 }
 
 type XSAMeta struct {

diff --git a/repo.go b/repo.go
new file mode 100644 (file)
index 0000000..770f170
--- /dev/null
+++ b/repo.go
@@ -0,0 +1,118 @@
+package main
+
+import (
+       "fmt"
+       "os"
+)
+
+// If an existing .xsatool config exists in the current directory,
+// load that and fill in defaults; otherwise make an entirely empty
+// config.
+//
+// Then attempt to clone the repositories and set them up so that push
+// is disabled by default.  Don't overwrite existing repositories
+// unless -f is specified.
+func MainRepoInit(xsanum int, args []string) (ret int) {
+       force := false
+
+       for len(args) > 0 {
+               arg := args[0]
+               args = args[1:]
+               switch arg {
+               case "-f":
+                       force = true
+               default:
+                       fmt.Printf("repoinit: Unknown argument: %s\n", arg)
+                       return 1
+               }
+       }
+
+       fmt.Printf("Trying local config...\n")
+       if err := toolConfig.Load(); err != nil && !os.IsNotExist(err) {
+               fmt.Printf("Error opening config file: %v\n", err)
+               return 1
+       }
+
+       setDef := func(s *string, d string) {
+               if *s == "" {
+                       fmt.Printf("Setting default: %s\n", d)
+                       *s = d
+               } else {
+                       fmt.Printf("Already set to %s\n", *s)
+               }
+       }
+
+       setDef(&toolConfig.XSAPath, "xsa.git")
+       setDef(&toolConfig.XenPath, "xen.git")
+       setDef(&toolConfig.QemuuPath, "qemu-xen.git")
+       setDef(&toolConfig.QemutPath, "qemu-xen-traditional.git")
+
+       checkDir := func(target string) (clone bool, err error) {
+               _, err = os.Stat(target)
+               if err == nil {
+                       if !force {
+                               fmt.Printf("%s exists, not forcing\n", target)
+                               return false, nil
+                       }
+                       fmt.Printf("%s exists, removing...\n", target)
+                       err = os.RemoveAll(target)
+                       if err != nil {
+                               return false, fmt.Errorf("Attempting to remove %s: %v\n", target, err)
+                       }
+               } else if !os.IsNotExist(err) {
+                       return false, fmt.Errorf("Looking at target %s: %v\n", target, err)
+               }
+
+               return true, nil
+       }
+
+       cloneXen := func(target string, origin string, t XRType) (xr XenRepo, err error) {
+               clone, err := checkDir(target)
+
+               if clone {
+                       xr, err = XenRepoClone(target, origin, t)
+               } else {
+                       xr, err = XenRepoOpen(target, t)
+               }
+               
+               // Always try to disable push, even if the repo exists
+               if err == nil {
+                       err = xr.DisablePush()
+               }
+               return
+       }
+
+       cloneNormal := func(target string, origin string) (r Repo, err error) {
+               ok := false
+               if ok, err = checkDir(target); !ok {
+                       return
+               }
+               r, err = GitClone(target, origin)
+               return
+       }
+
+       var err error
+       if repos.xen, err = cloneXen(toolConfig.XenPath, "git://xenbits.xen.org/xen.git", XRXen); err != nil {
+               fmt.Printf("Trying to clone Xen: %v\n", err)
+               return 1
+       }
+       if repos.qemuu, err = cloneXen(toolConfig.QemuuPath, "git://xenbits.xen.org/qemu-xen.git", XRQemuu); err != nil {
+               fmt.Printf("Trying to clone Qemuu: %v\n", err)
+               return 1
+       }
+       if repos.qemut, err = cloneXen(toolConfig.QemutPath, "git://xenbits.xen.org/qemu-xen-traditional.git", XRQemut); err != nil {
+               fmt.Printf("Trying to clone Qemut: %v\n", err)
+               return 1
+       }
+       if repos.xsa, err = cloneNormal(toolConfig.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 = toolConfig.Save(); err != nil {
+               fmt.Print("Trying to save configfile: %v\n", err)
+               return 1
+       }
+       
+       return 0
+}

diff --git a/repoinit.go b/repoinit.go
deleted file mode 100644 (file)
index 770f170..0000000
--- a/repoinit.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package main
-
-import (
-       "fmt"
-       "os"
-)
-
-// If an existing .xsatool config exists in the current directory,
-// load that and fill in defaults; otherwise make an entirely empty
-// config.
-//
-// Then attempt to clone the repositories and set them up so that push
-// is disabled by default.  Don't overwrite existing repositories
-// unless -f is specified.
-func MainRepoInit(xsanum int, args []string) (ret int) {
-       force := false
-
-       for len(args) > 0 {
-               arg := args[0]
-               args = args[1:]
-               switch arg {
-               case "-f":
-                       force = true
-               default:
-                       fmt.Printf("repoinit: Unknown argument: %s\n", arg)
-                       return 1
-               }
-       }
-
-       fmt.Printf("Trying local config...\n")
-       if err := toolConfig.Load(); err != nil && !os.IsNotExist(err) {
-               fmt.Printf("Error opening config file: %v\n", err)
-               return 1
-       }
-
-       setDef := func(s *string, d string) {
-               if *s == "" {
-                       fmt.Printf("Setting default: %s\n", d)
-                       *s = d
-               } else {
-                       fmt.Printf("Already set to %s\n", *s)
-               }
-       }
-
-       setDef(&toolConfig.XSAPath, "xsa.git")
-       setDef(&toolConfig.XenPath, "xen.git")
-       setDef(&toolConfig.QemuuPath, "qemu-xen.git")
-       setDef(&toolConfig.QemutPath, "qemu-xen-traditional.git")
-
-       checkDir := func(target string) (clone bool, err error) {
-               _, err = os.Stat(target)
-               if err == nil {
-                       if !force {
-                               fmt.Printf("%s exists, not forcing\n", target)
-                               return false, nil
-                       }
-                       fmt.Printf("%s exists, removing...\n", target)
-                       err = os.RemoveAll(target)
-                       if err != nil {
-                               return false, fmt.Errorf("Attempting to remove %s: %v\n", target, err)
-                       }
-               } else if !os.IsNotExist(err) {
-                       return false, fmt.Errorf("Looking at target %s: %v\n", target, err)
-               }
-
-               return true, nil
-       }
-
-       cloneXen := func(target string, origin string, t XRType) (xr XenRepo, err error) {
-               clone, err := checkDir(target)
-
-               if clone {
-                       xr, err = XenRepoClone(target, origin, t)
-               } else {
-                       xr, err = XenRepoOpen(target, t)
-               }
-               
-               // Always try to disable push, even if the repo exists
-               if err == nil {
-                       err = xr.DisablePush()
-               }
-               return
-       }
-
-       cloneNormal := func(target string, origin string) (r Repo, err error) {
-               ok := false
-               if ok, err = checkDir(target); !ok {
-                       return
-               }
-               r, err = GitClone(target, origin)
-               return
-       }
-
-       var err error
-       if repos.xen, err = cloneXen(toolConfig.XenPath, "git://xenbits.xen.org/xen.git", XRXen); err != nil {
-               fmt.Printf("Trying to clone Xen: %v\n", err)
-               return 1
-       }
-       if repos.qemuu, err = cloneXen(toolConfig.QemuuPath, "git://xenbits.xen.org/qemu-xen.git", XRQemuu); err != nil {
-               fmt.Printf("Trying to clone Qemuu: %v\n", err)
-               return 1
-       }
-       if repos.qemut, err = cloneXen(toolConfig.QemutPath, "git://xenbits.xen.org/qemu-xen-traditional.git", XRQemut); err != nil {
-               fmt.Printf("Trying to clone Qemut: %v\n", err)
-               return 1
-       }
-       if repos.xsa, err = cloneNormal(toolConfig.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 = toolConfig.Save(); err != nil {
-               fmt.Print("Trying to save configfile: %v\n", err)
-               return 1
-       }
-       
-       return 0
-}