Setup basic Runtime with properties and platform.

recipe_engine/util.py

 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
+import collections
 import contextlib
 import datetime
 import functools
 import logging
 import os
+import platform
 import sys
 import traceback
 import time
 import urllib
 
 from cStringIO import StringIO
 
 class RecipeAbort(Exception):
   pass
 
@@ skipping 64 matching lines @@
     Args:
       presentation (StepPresentation) - for the current step.
       test (PlaceholderTestData) - test data for this placeholder.
 
     May optionally modify presentation as a side-effect.
     Returned value will be added to the step result.
     """
     pass
 
 
+class Platform(collections.namedtuple('Platform', ('name', 'arch', 'bits'))):
+  """Normalized operating system platform information."""
+
+  # Platform Constants.
+  LINUX = 'linux'
+  MAC = 'mac'
+  WIN = 'win'
+
+  @classmethod
+  def norm_plat(cls, plat):
+    """Returns (str): The platform constant string for the current platform.
+
+    Raises:
+      ValueError: If the current platform could not be mapped to a constant.
+    """
+    if plat.startswith('linux'):
+      return cls.LINUX
+    elif plat.startswith(('win', 'cygwin')):
+      return cls.WIN
+    elif plat.startswith(('darwin', 'mac')):
+      return cls.MAC
+    else:  # pragma: no cover
+      raise ValueError('Don\'t understand platform "%s"' % (plat,))
+
+  @staticmethod
+  def norm_bits(arch):
+    return 64 if '64' in str(arch) else 32
+
+  @classmethod
+  def probe(cls):
+    name = cls.norm_plat(sys.platform)
+    bits = cls.norm_bits(platform.machine())
+
+    # platform.machine is based on running kernel. It's possible to use 64-bit
+    # kernel with 32-bit userland, e.g. to give linker slightly more memory.
+    # Distinguish between different userland bitness by querying the python
+    # binary.
+    architecture = platform.architecture()[0]
+    if (name == cls.LINUX and
+        bits == 64 and
+        architecture == '32bit'):
+      bits = 32
+    # On Mac, the inverse of the above is true: the kernel is 32-bit but the
+    # CPU and userspace both are capable of running 64-bit programs.
+    elif (name == cls.MAC and
+          bits == 32 and
+          architecture == '64bit'):
+      bits = 64
+
+    return cls(name=name, arch='intel', bits=bits)
+
+  def is_win(self):
+    return self.name == self.WIN
+
+  def is_posix(self):
+    return self.name in (self.MAC, self.LINUX)
+
+
 def static_wraps(func):
   wrapped_fn = func
   if isinstance(func, staticmethod):
     # __get__(obj) is the way to get the function contained in the staticmethod.
     # python 2.7+ has a __func__ member, but previous to this the attribute
     # doesn't exist. It doesn't matter what the obj is, as long as it's not
     # None.
     wrapped_fn = func.__get__(object)
   return functools.wraps(wrapped_fn)
 
@@ skipping 206 matching lines @@
     it (iterable): An iterable to traverse.
     exc_types (list): An optional list of specific exception types to defer.
         If empty, Exception will be used. Any Exceptions not referenced by this
         list will skip deferring and be immediately raised.
   """
   mexc_builder = MultiException.Builder()
   for e in it:
     with mexc_builder.catch(*exc_types):
       fn(e)
   mexc_builder.raise_if_any()