Setup basic Runtime with properties and platform.

recipe_modules/platform/api.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 sys
-import platform
-
 from recipe_engine import recipe_api
 
 
-def norm_plat(plat):
-  if plat.startswith('linux'):
-    return 'linux'
-  elif plat.startswith(('win', 'cygwin')):
-    return 'win'
-  elif plat.startswith(('darwin', 'mac')):
-    return 'mac'
-  else:  # pragma: no cover
-    raise ValueError('Don\'t understand platform "%s"' % plat)
-
-
-def norm_bits(arch):
-  return 64 if '64' in str(arch) else 32
-
-
 class PlatformApi(recipe_api.RecipeApi):
   """
   Provides host-platform-detection properties.
 
   Mocks:
     name (str): A value equivalent to something that might be returned by
       sys.platform.
     bits (int): Either 32 or 64.
   """
 
-  def __init__(self, **kwargs):
-    super(PlatformApi, self).__init__(**kwargs)
-    self._name = norm_plat(sys.platform)
-
-    self._arch = 'intel'
-    self._bits = norm_bits(platform.machine())
-
-    if self._test_data.enabled:
-      # Default to linux/64, unless test case says otherwise.
-      self._name = norm_plat(self._test_data.get('name', 'linux'))
-      self._bits = norm_bits(self._test_data.get('bits', 64))
-    else:  # pragma: no cover
-      # 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.
-      if (self._name == 'linux' and
-          self._bits == 64 and
-          platform.architecture()[0] == '32bit'):
-        self._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 (self._name == 'mac' and
-            self._bits == 32 and
-            platform.architecture()[0] == '64bit'):
-        self._bits = 64
+  platform_client = recipe_api.RequireClient('platform')
 
   @property
   def is_win(self):
     return self.name == 'win'
 
   @property
   def is_mac(self):
     return self.name == 'mac'
 
   @property
   def is_linux(self):
     return self.name == 'linux'

[iannucci, 2016/10/15 00:39:45]

these should probably pass-through too?

[dnj, 2016/10/15 00:59:27]

Well, my thought is that at this point the strings are standardized, so I don't
mind adding module-use functionality here, since recipe engine doesn't need
these checks.

 
   @property
   def name(self):
-    return self._name
+    if self._test_data.enabled:
+      # Default to linux, unless test case says otherwise.
+      return self.platform_client.norm_plat(
+          self._test_data.get('name', 'linux'))

[iannucci, 2016/10/15 00:39:45]

Hm... I think you need to move this up a level; if someone starts importing the
platform client directly, and they mock the os with api.platform, they'll get
conflicting values in their test. This probably implies having the ability to
specify test clients...

[dnj, 2016/10/15 00:59:27]

Yeah. I think that would be a good manifestation of test clients.

ATM though since those don't exist, I think this is fine? Someone importing
clients directly means they need to know how those clients function.

[iannucci, 2016/10/15 01:04:09]

fair enough, but I wouldn't leave this gap open too long. Otherwise we'll be
scratching our heads at this in 6 months....

+    return self.platform_client.name # pragma: no cover
 
   @property
   def bits(self):
     # The returned bitness corresponds to the userland. If anyone ever wants
     # to query for bitness of the kernel, another accessor should be added.
-    return self._bits
+    if self._test_data.enabled:
+      # Default to 64-bit, unless test case says otherwise.
+      return self.platform_client.norm_bits(self._test_data.get('bits', 64))
+    return self.platform_client.bits # pragma: no cover
 
   @property
   def arch(self):
-    return self._arch
+    return self.platform_client.arch
 
-  @staticmethod
   def normalize_platform_name(platform):
     """One of python's sys.platform values -> 'win', 'linux' or 'mac'."""
-    return norm_plat(platform)  # pragma: no cover
+    return self.platform_client.norm_plat(platform)  # pragma: no cover