automation/kernel-seed.py

   1 #!/usr/bin/python
   2 # -*- coding: utf-8 -*-
   3 #
   4 # Copyright (C) 2015 - Michael Jeanson <mjeanson@efficios.com>
   5 #                      Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   6 #
   7 # This program is free software: you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation, either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # This program is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 """ This script is used to generate a yaml list of kernel version tag """
  21
  22 import os
  23 import re
  24 import yaml
  25 import argparse
  26
  27 from distutils.version import Version
  28 from git import Repo
  29
  30
  31 class KernelVersion(Version):
  32     """ Kernel version class """
  33
  34     re26 = re.compile(r'^(2\.\d+) \. (\d+) (\. (\d+))? (\-rc(\d+))?$',
  35                       re.VERBOSE)
  36     re30 = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? (\-rc(\d+))?$', re.VERBOSE)
  37
  38
  39     def __init__(self, vstring=None):
  40         self._rc = None
  41         self._version = None
  42         if vstring:
  43             self.parse(vstring)
  44
  45
  46     def parse(self, vstring):
  47         """ Parse version string """
  48
  49         self._vstring = vstring
  50
  51         if self._vstring.startswith("2"):
  52             match = self.re26.match(self._vstring)
  53         else:
  54             match = self.re30.match(self._vstring)
  55
  56         if not match:
  57             raise ValueError("invalid version number '%s'" % self._vstring)
  58
  59         (major, minor, patch, rc_num) = match.group(1, 2, 4, 6)
  60
  61         major = int(float(major) * 10)
  62
  63         if patch:
  64             self._version = tuple(map(int, [major, minor, patch]))
  65         else:
  66             self._version = tuple(map(int, [major, minor])) + (0,)
  67
  68         if rc_num:
  69             self._rc = int(rc_num)
  70         else:
  71             self._rc = None
  72
  73
  74     def isrc(self):
  75         """ Is this version an RC """
  76         return self._rc is not None
  77
  78
  79     def __str__(self):
  80         return self._vstring
  81
  82
  83     def __repr__(self):
  84         return "KernelVersion ('%s')" % str(self)
  85
  86
  87     def _cmp(self, other):
  88         if isinstance(other, str):
  89             other = KernelVersion(other)
  90
  91         if self._version != other._version:
  92             # numeric versions don't match
  93             # prerelease stuff doesn't matter
  94             if self._version < other._version:
  95                 return -1
  96             else:
  97                 return 1
  98
  99         # have to compare rc
 100         # case 1: neither has rc; they're equal
 101         # case 2: self has rc, other doesn't; other is greater
 102         # case 3: self doesn't have rc, other does: self is greater
 103         # case 4: both have rc: must compare them!
 104
 105         if (not self._rc and not other._rc):
 106             return 0
 107         elif (self._rc and not other._rc):
 108             return -1
 109         elif (not self._rc and other._rc):
 110             return 1
 111         elif (self._rc and other._rc):
 112             if self._rc == other._rc:
 113                 return 0
 114             elif self._rc < other._rc:
 115                 return -1
 116             else:
 117                 return 1
 118         else:
 119             assert False, "never get here"
 120
 121 def main():
 122     """ Main """
 123
 124     versions = []
 125     kernel_cutoff = KernelVersion("2.6.36")
 126     kernel_git = "git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git"
 127     kernel_path = os.getcwd() + "/kernel"
 128
 129     parser = argparse.ArgumentParser()
 130     parser.add_argument("--kernel-path", help="The location of the kernel.  Default to the currentdir/linux")
 131     parser.add_argument("--kernel-git-remote", help="The git url of the kernel. Default to git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git")
 132     parser.add_argument("--kernel-cutoff", help="The lower bersion cutoff in X.X.X format. Default to 2.6.36")
 133     args = parser.parse_args()
 134
 135     if args.kernel_path:
 136         kernel_path = args.kernel_path
 137     if args.kernel_git_remote:
 138         kernel_git = args.kernel_git_remote
 139     if args.kernel_cutoff:
 140         kernel_cutoff = KernelVersion(args.kernel_cutoff)
 141
 142     print(kernel_path)
 143     print(kernel_git)
 144     print(kernel_cutoff)
 145     return
 146
 147     # Open or create the local repository
 148     if os.path.isdir(kernel_path):
 149         linux_repo = Repo(kernel_path)
 150     else:
 151         linux_repo = Repo.clone_from(kernel_git, kernel_path)
 152
 153     # Pull the latest
 154     linux_repo.remote().pull()
 155
 156     # First get all valid versions
 157     for tag in linux_repo.tags:
 158         try:
 159             version = KernelVersion(tag.name.lstrip('v'))
 160
 161             # Add only those who are superior to the cutoff version
 162             if version >= kernel_cutoff:
 163                 versions.append(version)
 164         except ValueError:
 165             #print(tag.name)
 166             continue
 167
 168     # Sort the list by version order
 169     versions.sort()
 170
 171     # Keep only one rc if it's the latest version
 172     last = True
 173     for version in reversed(versions):
 174         if version.isrc() and not last:
 175             versions.remove(version)
 176         last = False
 177
 178     #for version in versions:
 179     #    print(version)
 180
 181     # Build yaml object
 182     yversions = []
 183
 184     for version in versions:
 185         yversions.append(version.__str__())
 186
 187     print(yaml.dump(yversions, default_flow_style=False))
 188
 189
 190
 191
 192 if __name__ == "__main__":
 193     main()
 194
 195 # EOF