Since xenversion is already pretty large (and soon going to get larger).
Signed-off-by: George Dunlap <george.dunlap@citrix.com>
have to edit the metadata file by hand.
**TODO** Add a way to specify multiple versions in one go; e.g.,
-`master,4.9,4.8` or something.
+`master,4.9,4.8` or something. Also, allow omission of the patch name
+if it matches the normal format; i.e., `set patches 4.9,4.8` would
+automatically use `xsa228-4.9.patch` for both 4.9 and 4.8.
## Excluding a particular Xen version from an XSA
+++ /dev/null
-package main
-
-import (
- "fmt"
- "io/ioutil"
- "math"
- "regexp"
- "strconv"
-)
-
-type XenVersion string
-
-const XenVersionMaster = XenVersion("master")
-
-// This is a bit weird but it hides the implementation
-func (v XenVersion) String() string {
- return string(v)
-}
-
-func (v XenVersion) parse() (major, minor int, err error) {
- if v == "master" {
- // NB if Xen's major ever exceeds 2 billion, we'll
- // need to deprecate the 32-bit build of this tool.
- return math.MaxInt32, 0, nil
- }
-
- major = -1
- minor = -1
-
- submatch := regexp.MustCompile("^([0-9]+).([0-9]+)$").FindStringSubmatch(string(v))
-
- if len(submatch) != 3 {
- err = fmt.Errorf("Bad XenVersion: %s", string(v))
- return
- }
-
- major, err = strconv.Atoi(submatch[1])
- if err != nil {
- return
- }
-
- if major >= math.MaxInt32 {
- err = fmt.Errorf("Version too large")
- major = -1
- return
- }
-
- minor, err = strconv.Atoi(submatch[2])
-
- return
-}
-
-func (v XenVersion) Check() bool {
- _, _, err := v.parse()
-
- return err == nil
-}
-
-func (v XenVersion) gt(v2 XenVersion, orEqual bool) bool {
- majorA, minorA, err := v.parse()
- if err != nil {
- fmt.Printf("Parsing: %v\n", err)
- panic("Unexpected error")
- }
-
- majorB, minorB, err := v2.parse()
- if err != nil {
- fmt.Printf("Parsing: %v\n", err)
- panic("Unexpected error")
- }
-
- if majorA > majorB {
- return true
- }
-
- if majorA < majorB {
- return false
- }
-
- // Now we know majors are equal
-
- if minorA > minorB {
- return true
- }
-
- if orEqual && minorA == minorB {
- return true
- }
-
- return false
-}
-
-// a.IsGreaterEqualThan(b) returns a >= b
-func (v XenVersion) IsGreaterEqualThan(v2 XenVersion) bool {
- return v.gt(v2, true)
-}
-
-// a.IsGreaterEqualThan(b) returns a > b
-func (v XenVersion) IsGreaterThan(v2 XenVersion) bool {
- return v.gt(v2, false)
-}
-
-func (v XenVersion) PrevVersiongit () (next XenVersion, err error) {
- major, minor, err := v.parse()
- if err != nil {
- err = fmt.Errorf("Parsing version %v: %v\n", v, err)
- return
- }
-
- if minor > 0 {
- minor--
- next = XenVersion(fmt.Sprintf("%d.%d\n", major, minor))
- return
- }
-
- // FIXME If we ever move to 5.x, or need to extend this to
- // 3.x, we'll have to sort something out here; probably a
- // table mapping major version -> highest release minor
- err = fmt.Errorf("Don't know how to roll back major number")
- return
-}
-
-type XenVersionSlice []XenVersion
-
-// Len is the number of elements in the collection.
-func (vl XenVersionSlice) Len() int {
- return len(vl)
-}
-
-// Less reports whether the element with
-// index i should sort before the element with index j.
-func (vl XenVersionSlice) Less(i, j int) bool {
- return vl[i].IsGreaterThan(vl[j])
-}
-
-// Swap swaps the elements with indexes i and j.
-func (vl XenVersionSlice) Swap(i, j int) {
- tmp := vl[j]
- vl[j] = vl[i]
- vl[i] = tmp
-}
-
-type XenVersionFull string
-
-func (v XenVersionFull) String() string {
- return string(v)
-}
-
-func (v XenVersionFull) parse() (ver XenVersion, p int, err error) {
- if v == "master" {
- return "master", 0, nil
- }
-
- submatch := regexp.MustCompile("^([0-9]+.[0-9]+).([0-9]+)$").FindStringSubmatch(string(v))
-
- if len(submatch) != 3 {
- err = fmt.Errorf("Bad XenVersionFull: %s", string(v))
- return
- }
-
- ver = XenVersion(submatch[1])
- p, err = strconv.Atoi(submatch[2])
-
- return
-}
-
-func (v XenVersionFull) Check() bool {
- _, _, err := v.parse()
-
- return (err == nil)
-}
-
-func (v XenVersionFull) XenVersion() XenVersion {
- ver, _, err := v.parse()
- if err != nil {
- return "error"
- }
- return ver
-}
-
-func (v XenVersionFull) Point() int {
- _, point, err := v.parse()
- if err != nil {
- return -1
- }
- return point
-}
-
-type XenRepo struct {
- Repo
- XRType Tree
-}
-
-func XenRepoOpen(path string, t Tree) (xr *XenRepo, err error) {
- xr = &XenRepo{}
- fmt.Printf("Opening %s\n", path)
- xr.Repo, err = GitOpen(path)
- if err != nil {
- return
- }
-
- // FIXME: Decide whether to do this automatically or not
- // fmt.Printf("Fetching\n")
- // out, err := xr.Fetch()
- // if err != nil {
- // return
- // }
- //fmt.Print(string(out))
-
- xr.XRType = t
-
- return
-}
-
-func XenRepoClone(target string, origin string, t Tree) (xr *XenRepo, err error) {
- xr = &XenRepo{}
- xr.Repo, err = GitClone(target, origin)
- if err != nil {
- return
- }
- xr.XRType = t
- return
-}
-
-func (xr *XenRepo) releaseTagPrefix() (s string) {
- switch xr.XRType {
- case TreeXen:
- return "RELEASE-"
- case TreeQemuU:
- return "qemu-xen-"
- case TreeQemuT:
- return "xen-"
- }
-
- return
-}
-
-func XenStableBranch(v XenVersion) string {
- if v == XenVersionMaster {
- return "staging"
- } else {
- return "staging-" + v.String()
- }
-}
-
-func (xr *XenRepo) GetTag(ver XenVersionFull) (tag string) {
- if ver.XenVersion() == XenVersionMaster {
- tag = "master"
- } else {
- tag = xr.releaseTagPrefix() + ver.String()
- }
- return
-}
-
-func (xr *XenRepo) GetRefVersion(v XenVersion) (ref string, err error) {
- ref, err = xr.ParseRef(XenStableBranch(v))
- return
-}
-
-// NB this leaves the tree in a non-deterministic state
-func (xr *XenRepo) MakeStableBranch(v XenVersion) (err error) {
- stableBranch := XenStableBranch(v)
-
- branches, err := xr.Branches(stableBranch)
- if err != nil {
- return
- }
-
- if len(branches) > 0 {
- fmt.Printf("Stable branch for version %v (%v) already exists\n",
- v, stableBranch)
- return
- }
-
- // This should automatically set things up correctly from origin
- _, err = xr.Checkout(stableBranch)
-
- return
-}
-
-// Check out stable-$version (or 'master')
-func (xr *XenRepo) tagsToVersions(tags []string) (versions []XenVersionFull, err error) {
- re := regexp.MustCompile("^" + xr.releaseTagPrefix() + "([0-9]+.[0-9]+.[0-9]+)$")
-
- for _, tag := range tags {
- submatch := re.FindStringSubmatch(tag)
- if len(submatch) == 2 {
- fv := XenVersionFull(submatch[1])
- v := fv.XenVersion()
- if v != "error" {
- versions = append(versions, fv)
- } else {
- fmt.Printf("Weird, can't get version from matched fullversion %s\n",
- fv)
- }
- }
- }
-
- return
-}
-
-func (xr *XenRepo) GetVersions() (versions []XenVersionFull, err error) {
- tags, err := xr.Tags()
- if err != nil {
- return
- }
-
- versions, err = xr.tagsToVersions(tags)
-
- return
-}
-
-// FIXME: The ideal here would actually be to pull all URLs with a git
-// reference out of Config.mk and add the git proxy if available
-type XenBuildConfig struct {
- config string
-}
-
-func gitURL(repo string) (url string) {
- cacheConfig := &G.config.Tool.Cache
- if cacheConfig.MirrorDir != "" {
- return "file://" + cacheConfig.MirrorDir + repo
- }
-
- // FIXME: Pull this out of Config.mk
-
- url = "git://xenbits.xenproject.org/" + repo
-
- if cacheConfig.ProxyURL != "" {
- url = cacheConfig.ProxyURL + url
- }
-
- return
-}
-
-// Not really sure what to call "OVMF_UPSTREAM" part of
-// "OVMF_UPSTREAM_URL" and "OVMF_UPSTREAM_REPO"
-func (c *XenBuildConfig) AddRepoCachedURL(configSpec string, repo string) {
- c.config += configSpec + "_URL ?= " + gitURL(repo) + "\n"
-}
-
-func (c *XenBuildConfig) AddRepoPathAndRevision(configSpec string, path string, revision string) {
- c.config += configSpec + "_URL ?= file://" + path + "\n"
- c.config += configSpec + "_REVISION ?= " + revision + "\n"
-}
-
-func (c *XenBuildConfig) Write(buildpath string) (err error) {
- err = ioutil.WriteFile(buildpath+"/.config", []byte(c.config), 0666)
- return
-}
--- /dev/null
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "regexp"
+)
+
+type XenRepo struct {
+ Repo
+ XRType Tree
+}
+
+func XenRepoOpen(path string, t Tree) (xr *XenRepo, err error) {
+ xr = &XenRepo{}
+ fmt.Printf("Opening %s\n", path)
+ xr.Repo, err = GitOpen(path)
+ if err != nil {
+ return
+ }
+
+ // FIXME: Decide whether to do this automatically or not
+ // fmt.Printf("Fetching\n")
+ // out, err := xr.Fetch()
+ // if err != nil {
+ // return
+ // }
+ //fmt.Print(string(out))
+
+ xr.XRType = t
+
+ return
+}
+
+func XenRepoClone(target string, origin string, t Tree) (xr *XenRepo, err error) {
+ xr = &XenRepo{}
+ xr.Repo, err = GitClone(target, origin)
+ if err != nil {
+ return
+ }
+ xr.XRType = t
+ return
+}
+
+func (xr *XenRepo) releaseTagPrefix() (s string) {
+ switch xr.XRType {
+ case TreeXen:
+ return "RELEASE-"
+ case TreeQemuU:
+ return "qemu-xen-"
+ case TreeQemuT:
+ return "xen-"
+ }
+
+ return
+}
+
+func XenStableBranch(v XenVersion) string {
+ if v == XenVersionMaster {
+ return "staging"
+ } else {
+ return "staging-" + v.String()
+ }
+}
+
+func (xr *XenRepo) GetTag(ver XenVersionFull) (tag string) {
+ if ver.XenVersion() == XenVersionMaster {
+ tag = "master"
+ } else {
+ tag = xr.releaseTagPrefix() + ver.String()
+ }
+ return
+}
+
+func (xr *XenRepo) GetRefVersion(v XenVersion) (ref string, err error) {
+ ref, err = xr.ParseRef(XenStableBranch(v))
+ return
+}
+
+// NB this leaves the tree in a non-deterministic state
+func (xr *XenRepo) MakeStableBranch(v XenVersion) (err error) {
+ stableBranch := XenStableBranch(v)
+
+ branches, err := xr.Branches(stableBranch)
+ if err != nil {
+ return
+ }
+
+ if len(branches) > 0 {
+ fmt.Printf("Stable branch for version %v (%v) already exists\n",
+ v, stableBranch)
+ return
+ }
+
+ // This should automatically set things up correctly from origin
+ _, err = xr.Checkout(stableBranch)
+
+ return
+}
+
+// Check out stable-$version (or 'master')
+func (xr *XenRepo) tagsToVersions(tags []string) (versions []XenVersionFull, err error) {
+ re := regexp.MustCompile("^" + xr.releaseTagPrefix() + "([0-9]+.[0-9]+.[0-9]+)$")
+
+ for _, tag := range tags {
+ submatch := re.FindStringSubmatch(tag)
+ if len(submatch) == 2 {
+ fv := XenVersionFull(submatch[1])
+ v := fv.XenVersion()
+ if v != "error" {
+ versions = append(versions, fv)
+ } else {
+ fmt.Printf("Weird, can't get version from matched fullversion %s\n",
+ fv)
+ }
+ }
+ }
+
+ return
+}
+
+func (xr *XenRepo) GetVersions() (versions []XenVersionFull, err error) {
+ tags, err := xr.Tags()
+ if err != nil {
+ return
+ }
+
+ versions, err = xr.tagsToVersions(tags)
+
+ return
+}
+
+// FIXME: The ideal here would actually be to pull all URLs with a git
+// reference out of Config.mk and add the git proxy if available
+type XenBuildConfig struct {
+ config string
+}
+
+func gitURL(repo string) (url string) {
+ cacheConfig := &G.config.Tool.Cache
+ if cacheConfig.MirrorDir != "" {
+ return "file://" + cacheConfig.MirrorDir + repo
+ }
+
+ // FIXME: Pull this out of Config.mk
+
+ url = "git://xenbits.xenproject.org/" + repo
+
+ if cacheConfig.ProxyURL != "" {
+ url = cacheConfig.ProxyURL + url
+ }
+
+ return
+}
+
+// Not really sure what to call "OVMF_UPSTREAM" part of
+// "OVMF_UPSTREAM_URL" and "OVMF_UPSTREAM_REPO"
+func (c *XenBuildConfig) AddRepoCachedURL(configSpec string, repo string) {
+ c.config += configSpec + "_URL ?= " + gitURL(repo) + "\n"
+}
+
+func (c *XenBuildConfig) AddRepoPathAndRevision(configSpec string, path string, revision string) {
+ c.config += configSpec + "_URL ?= file://" + path + "\n"
+ c.config += configSpec + "_REVISION ?= " + revision + "\n"
+}
+
+func (c *XenBuildConfig) Write(buildpath string) (err error) {
+ err = ioutil.WriteFile(buildpath+"/.config", []byte(c.config), 0666)
+ return
+}
--- /dev/null
+package main
+
+import (
+ "fmt"
+ "math"
+ "regexp"
+ "strconv"
+)
+
+type XenVersion string
+
+const XenVersionMaster = XenVersion("master")
+
+// This is a bit weird but it hides the implementation
+func (v XenVersion) String() string {
+ return string(v)
+}
+
+func (v XenVersion) parse() (major, minor int, err error) {
+ if v == "master" {
+ // NB if Xen's major ever exceeds 2 billion, we'll
+ // need to deprecate the 32-bit build of this tool.
+ return math.MaxInt32, 0, nil
+ }
+
+ major = -1
+ minor = -1
+
+ submatch := regexp.MustCompile("^([0-9]+).([0-9]+)$").FindStringSubmatch(string(v))
+
+ if len(submatch) != 3 {
+ err = fmt.Errorf("Bad XenVersion: %s", string(v))
+ return
+ }
+
+ major, err = strconv.Atoi(submatch[1])
+ if err != nil {
+ return
+ }
+
+ if major >= math.MaxInt32 {
+ err = fmt.Errorf("Version too large")
+ major = -1
+ return
+ }
+
+ minor, err = strconv.Atoi(submatch[2])
+
+ return
+}
+
+func (v XenVersion) Check() bool {
+ _, _, err := v.parse()
+
+ return err == nil
+}
+
+func (v XenVersion) gt(v2 XenVersion, orEqual bool) bool {
+ majorA, minorA, err := v.parse()
+ if err != nil {
+ fmt.Printf("Parsing: %v\n", err)
+ panic("Unexpected error")
+ }
+
+ majorB, minorB, err := v2.parse()
+ if err != nil {
+ fmt.Printf("Parsing: %v\n", err)
+ panic("Unexpected error")
+ }
+
+ if majorA > majorB {
+ return true
+ }
+
+ if majorA < majorB {
+ return false
+ }
+
+ // Now we know majors are equal
+
+ if minorA > minorB {
+ return true
+ }
+
+ if orEqual && minorA == minorB {
+ return true
+ }
+
+ return false
+}
+
+// a.IsGreaterEqualThan(b) returns a >= b
+func (v XenVersion) IsGreaterEqualThan(v2 XenVersion) bool {
+ return v.gt(v2, true)
+}
+
+// a.IsGreaterEqualThan(b) returns a > b
+func (v XenVersion) IsGreaterThan(v2 XenVersion) bool {
+ return v.gt(v2, false)
+}
+
+func (v XenVersion) PrevVersiongit () (next XenVersion, err error) {
+ major, minor, err := v.parse()
+ if err != nil {
+ err = fmt.Errorf("Parsing version %v: %v\n", v, err)
+ return
+ }
+
+ if minor > 0 {
+ minor--
+ next = XenVersion(fmt.Sprintf("%d.%d\n", major, minor))
+ return
+ }
+
+ // FIXME If we ever move to 5.x, or need to extend this to
+ // 3.x, we'll have to sort something out here; probably a
+ // table mapping major version -> highest release minor
+ err = fmt.Errorf("Don't know how to roll back major number")
+ return
+}
+
+type XenVersionSlice []XenVersion
+
+// Len is the number of elements in the collection.
+func (vl XenVersionSlice) Len() int {
+ return len(vl)
+}
+
+// Less reports whether the element with
+// index i should sort before the element with index j.
+func (vl XenVersionSlice) Less(i, j int) bool {
+ return vl[i].IsGreaterThan(vl[j])
+}
+
+// Swap swaps the elements with indexes i and j.
+func (vl XenVersionSlice) Swap(i, j int) {
+ tmp := vl[j]
+ vl[j] = vl[i]
+ vl[i] = tmp
+}
+
+type XenVersionFull string
+
+func (v XenVersionFull) String() string {
+ return string(v)
+}
+
+func (v XenVersionFull) parse() (ver XenVersion, p int, err error) {
+ if v == "master" {
+ return "master", 0, nil
+ }
+
+ submatch := regexp.MustCompile("^([0-9]+.[0-9]+).([0-9]+)$").FindStringSubmatch(string(v))
+
+ if len(submatch) != 3 {
+ err = fmt.Errorf("Bad XenVersionFull: %s", string(v))
+ return
+ }
+
+ ver = XenVersion(submatch[1])
+ p, err = strconv.Atoi(submatch[2])
+
+ return
+}
+
+func (v XenVersionFull) Check() bool {
+ _, _, err := v.parse()
+
+ return (err == nil)
+}
+
+func (v XenVersionFull) XenVersion() XenVersion {
+ ver, _, err := v.parse()
+ if err != nil {
+ return "error"
+ }
+ return ver
+}
+
+func (v XenVersionFull) Point() int {
+ _, point, err := v.parse()
+ if err != nil {
+ return -1
+ }
+ return point
+}
+
projects / people / gdunlap / xsatool / commitdiff