Retrieval of information by release channel

tools/release/releases.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # This script retrieves the history of all V8 branches and
 # their corresponding Chromium revisions.
 
 # Requires a chromium checkout with branch heads:
 # gclient sync --with_branch_heads
@@ skipping 363 matching lines @@
       pass
 
     # Add the chromium ranges to the v8 candidates and master releases.
     all_ranges = BuildRevisionRanges(cr_releases)
 
     for hsh, ranges in all_ranges.iteritems():
       releases_dict.get(hsh, {})["chromium_revision"] = ranges
 
 
 # TODO(machenbach): Unify common code with method above.
-class RietrieveChromiumBranches(Step):
+class RetrieveChromiumBranches(Step):
   MESSAGE = "Retrieve Chromium branch information."
 
   def RunStep(self):
     cwd = self._options.chromium
 
     # All v8 revisions we are interested in.
     releases_dict = dict((r["revision_git"], r) for r in self["releases"])
 
     # Filter out irrelevant branches.
     branches = filter(lambda r: re.match(r"branch-heads/\d+", r),
@@ skipping 31 matching lines @@
     # Allow Ctrl-C interrupt.
     except (KeyboardInterrupt, SystemExit):  # pragma: no cover
       pass
 
     # Add the chromium branches to the v8 candidate releases.
     all_ranges = BuildRevisionRanges(cr_branches)
     for revision, ranges in all_ranges.iteritems():
       releases_dict.get(revision, {})["chromium_branch"] = ranges
 
 
+class RetrieveInformationOnChromeReleases(Step):
+  MESSAGE = 'Retrieves relevant information on the latest Chrome releases'
+
+  def Run(self):
+
+    params = None
+    result_raw = self.ReadURL(
+                             "http://omahaproxy.appspot.com/all.json",
+                             params,
+                             wait_plan=[5, 20]
+                             )
+    recent_releases = json.loads(result_raw)
+
+    canaries = []
+
+    for current_os in recent_releases:
+      for current_version in current_os["versions"]:
+        current_candidate = {
+                            "chrome_version": current_version["version"],
+                           "os": current_version["os"],
+                           "release_date": current_version["current_reldate"],
+                           "v8_version": current_version["v8_version"],
+                           }
+
+        if current_version["channel"] == "canary":
+          canaries.append(current_candidate)
+
+    chrome_releases = {"canaries": canaries}
+    self["chrome_releases"] = chrome_releases
+
+
 class CleanUp(Step):
   MESSAGE = "Clean up."
 
   def RunStep(self):
     self.CommonCleanup()
 
 
 class WriteOutput(Step):
   MESSAGE = "Print output."
 
   def Run(self):
+
+    output = {
+              "releases": self["releases"],
+              "chrome_releases": self["chrome_releases"],
+              }
+
     if self._options.csv:
       with open(self._options.csv, "w") as f:
         writer = csv.DictWriter(f,
                                 ["version", "branch", "revision",
                                  "chromium_revision", "patches_merged"],
                                 restval="",
                                 extrasaction="ignore")
         for release in self["releases"]:
           writer.writerow(release)
     if self._options.json:
       with open(self._options.json, "w") as f:
-        f.write(json.dumps(self["releases"]))
+        f.write(json.dumps(output))
     if not self._options.csv and not self._options.json:
-      print self["releases"]  # pragma: no cover
+      print output  # pragma: no cover
 
 
 class Releases(ScriptsBase):
   def _PrepareOptions(self, parser):
     parser.add_argument("-b", "--branch", default="recent",
                         help=("The branch to analyze. If 'all' is specified, "
                               "analyze all branches. If 'recent' (default) "
                               "is specified, track beta, stable and "
                               "candidates."))
     parser.add_argument("-c", "--chromium",
                         help=("The path to your Chromium src/ "
                               "directory to automate the V8 roll."))
     parser.add_argument("--csv", help="Path to a CSV file for export.")
     parser.add_argument("-m", "--max-releases", type=int, default=0,
                         help="The maximum number of releases to track.")
     parser.add_argument("--json", help="Path to a JSON file for export.")
 
   def _ProcessOptions(self, options):  # pragma: no cover
     options.force_readline_defaults = True
     return True
 
   def _Config(self):
     return {
       "BRANCHNAME": "retrieve-v8-releases",
       "PERSISTFILE_BASENAME": "/tmp/v8-releases-tempfile",
     }
 
   def _Steps(self):
+
     return [
       Preparation,
       RetrieveV8Releases,
       UpdateChromiumCheckout,
       RetrieveChromiumV8Releases,
-      RietrieveChromiumBranches,
+      RetrieveChromiumBranches,
+      RetrieveInformationOnChromeReleases,
       CleanUp,
       WriteOutput,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Releases().Run())