Remove stale android code and remove stand alone functionality.

appengine/swarming/swarming_bot/os_utilities.py

 #!/usr/bin/env python
 # Copyright 2014 The Swarming Authors. All rights reserved.
 # Use of this source code is governed by the Apache v2.0 license that can be
 # found in the LICENSE file.
 
 """OS specific utility functions.
 
 Includes code:
 - to declare the current system this code is running under.
 - to run a command on user login.
@@ skipping 19 matching lines @@
 import socket
 import string
 import subprocess
 import sys
 import tempfile
 import threading
 import time
 import urllib
 import urllib2
 
-try:
-  # The reason for this try/except is so someone can copy this single file on a
-  # new machine and execute it as-is to get the dimensions that would be set.
-  from utils import file_path
-  from utils import tools
-  from utils import zip_package
+from utils import file_path
+from utils import tools
+from utils import zip_package
 
-  THIS_FILE = os.path.abspath(zip_package.get_main_script_path() or __file__)
-except ImportError as e:
-  THIS_FILE = os.path.abspath(__file__)
-  tools = None
-  print >> sys.stderr, 'Failed to import tools: %s' % e
-
-
-# Properties from an android device that should be kept as dimension.
-ANDROID_DETAILS = frozenset(
-    [
-      # Hardware details.
-      u'ro.board.platform',
-      u'ro.product.board',  # or ro.product.device?
-      u'ro.product.cpu.abi',
-      u'ro.product.cpu.abi2',
-
-      # OS details.
-      u'ro.build.id',
-      u'ro.build.tags',
-      u'ro.build.type',
-      u'ro.build.version.sdk',
-    ])
+THIS_FILE = os.path.abspath(zip_package.get_main_script_path() or __file__)
 
 
 # https://cloud.google.com/compute/pricing#machinetype
 GCE_MACHINE_COST_HOUR_US = {
   u'n1-standard-1': 0.063,
   u'n1-standard-2': 0.126,
   u'n1-standard-4': 0.252,
   u'n1-standard-8': 0.504,
   u'n1-standard-16': 1.008,
   u'f1-micro': 0.012,
@@ skipping 41 matching lines @@
 GCE_SSD_GB_COST_MONTH = 0.17
 
 
 # https://cloud.google.com/compute/pricing#premiumoperatingsystems
 GCE_WINDOWS_COST_CORE_HOUR = 0.04
 
 
 ### Private stuff.
 
 
+# Used to calculated Swarming bot uptime.
 _STARTED_TS = time.time()
 
+
+# Cache of GCE OAuth2 token.
 _CACHED_OAUTH2_TOKEN_GCE = {}
 _CACHED_OAUTH2_TOKEN_GCE_LOCK = threading.Lock()
 
-_MONITORING_SCOPE = 'https://www.googleapis.com/auth/monitoring'
-
-
-# Make cached a no-op when client/utils/tools.py is unavailable.
-if not tools:
-  def cached(func):
-    return func
-else:
-  cached = tools.cached
-
 
 def _write(filepath, content):
   """Writes out a file and returns True on success."""
   logging.info('Writing in %s:\n%s', filepath, content)
   try:
     with open(filepath, mode='wb') as f:
       f.write(content)
     return True
   except IOError as e:
     logging.error('Failed to write %s: %s', filepath, e)
@@ skipping 255 matching lines @@
     if dev_type.startswith('03'):
       vendor = re_id.match(line[2])
       device = re_id.match(line[3])
       ven_id = vendor.group(2)
       dimensions.add(unicode(ven_id))
       dimensions.add(u'%s:%s' % (ven_id, device.group(2)))
       state.add(u'%s %s' % (vendor.group(1), device.group(1)))
   return sorted(dimensions), sorted(state)
 
 
-@cached
+@tools.cached
 def _get_SPDisplaysDataType_osx():
   """Returns an XML about the system display properties."""
   import plistlib
   sp = subprocess.check_output(
       ['system_profiler', 'SPDisplaysDataType', '-xml'])
   return plistlib.readPlistFromString(sp)[0]['_items']
 
 
 def _get_gpu_osx():
   """Returns video device as listed by 'system_profiler'. See get_gpu()."""
@@ skipping 61 matching lines @@
     if match:
       ven_id = match.group(1).lower()
     match = re.search(r'DEV_([0-9A-F]{4})', pnp_string)
     if match:
       dev_id = match.group(1).lower()
     dimensions.add(unicode(ven_id))
     dimensions.add(u'%s:%s' % (ven_id, dev_id))
   return sorted(dimensions), sorted(state)
 
 
-@cached
+@tools.cached
 def _get_mount_points_win():
   """Returns the list of 'fixed' drives in format 'X:\\'."""
   ctypes.windll.kernel32.GetDriveTypeW.argtypes = (ctypes.c_wchar_p,)
   ctypes.windll.kernel32.GetDriveTypeW.restype = ctypes.c_ulong
   DRIVE_FIXED = 3
   # https://msdn.microsoft.com/library/windows/desktop/aa364939.aspx
   return [
     letter + ':\\'
     for letter in string.lowercase
     if ctypes.windll.kernel32.GetDriveTypeW(letter + ':\\') == DRIVE_FIXED
@@ skipping 41 matching lines @@
   return dict(
       (
         items[5],
         {
           'free_mb': round(float(items[3]) / 1024., 1),
           'size_mb': round(float(items[1]) / 1024., 1),
         }
       ) for items in _run_df())
 
 
-@cached
+@tools.cached
 def _get_metadata_gce():
   """Returns the GCE metadata as a dict.
 
   Refs:
     https://cloud.google.com/compute/docs/metadata
     https://cloud.google.com/compute/docs/machine-types
 
   To get the at the command line from a GCE VM, use:
     curl --silent \
       http://metadata.google.internal/computeMetadata/v1/?recursive=true \
@@ skipping 82 matching lines @@
   try:
     with open(filepath, 'rb') as f:
       return f.read()
   except (IOError, OSError):
     return None
 
 
 ### Public API.
 
 
-@cached
+@tools.cached
 def get_os_version_number():
   """Returns the normalized OS version number as a string.
 
   Returns:
     The format depends on the OS:
     - Windows: 5.1, 6.1, etc. There is no way to distinguish between Windows 7
           and Windows Server 2008R2 since they both report 6.1.
     - OSX: 10.7, 10.8, etc.
     - Ubuntu: 12.04, 10.04, etc.
     Others will return None.
@@ skipping 19 matching lines @@
 
   if sys.platform == 'linux2':
     # On Ubuntu it will return a string like '12.04'. On Raspbian, it will look
     # like '7.6'.
     return unicode(platform.linux_distribution()[1])
 
   logging.error('Unable to determine platform version')
   return None
 
 
-@cached
+@tools.cached
 def get_os_version_name():
   """Returns the marketing name on Windows.
 
   Returns None on other OSes, since it's not problematic there. Having
   dimensions like Trusty or Snow Leopard is not useful.
   """
   if sys.platform == 'win32':
     return _get_os_version_name_win()
   return None
 
 
-@cached
+@tools.cached
 def get_os_name():
   """Returns standardized OS name.
 
   Defaults to sys.platform for OS not normalized.
 
   Returns:
     Windows, Mac, Ubuntu, Raspbian, etc.
   """
   value = {
     'cygwin': u'Windows',
@@ skipping 10 matching lines @@
     content = _safe_read('/etc/os-release')
     if content:
       os_release = dict(l.split('=', 1) for l in content.splitlines() if l)
       os_id = os_release.get('ID').strip('"')
       # Uppercase the first letter for consistency with the other platforms.
       return unicode(os_id[0].upper() + os_id[1:])
 
   return unicode(sys.platform)
 
 
-@cached
+@tools.cached
 def get_cpu_type():
   """Returns the type of processor: arm or x86."""
   machine = platform.machine().lower()
   if machine in ('amd64', 'x86_64', 'i386'):
     return u'x86'
   return unicode(machine)
 
 
-@cached
+@tools.cached
 def get_cpu_bitness():
   """Returns the number of bits in the CPU architecture as a str: 32 or 64.
 
   Unless someone ported python to PDP-10 or 286.
 
   Note: this function may return 32 bits on 64 bits OS in case of a 32 bits
   python process.
   """
   if platform.machine().endswith('64'):
     return u'64'
@@ skipping 35 matching lines @@
     # happens on OSX.
     hostname = socket.gethostname()
   return unicode(hostname)
 
 
 def get_hostname_short():
   """Returns the base host name."""
   return get_hostname().split(u'.', 1)[0]
 
 
-@cached
+@tools.cached
 def get_num_processors():
   """Returns the number of processors.
 
   Python on OSX 10.6 raises a NotImplementedError exception.
   """
   try:
     # Multiprocessing
     return multiprocessing.cpu_count()
   except:  # pylint: disable=W0702
     try:
       # Mac OS 10.6
       return int(os.sysconf('SC_NPROCESSORS_ONLN'))  # pylint: disable=E1101
     except:
       # Returns non-zero, otherwise it could generate a divide by zero later
       # when doing calculations, leading to a crash. Saw it happens on Win2K8R2
       # on python 2.7.5 on cygwin 1.7.28.
       logging.error('get_num_processors() failed to query number of cores')
       # Return an improbable number to make it easier to catch.
       return 5
 
 
-@cached
+@tools.cached
 def get_physical_ram():
   """Returns the amount of installed RAM in Mb, rounded to the nearest number.
   """
   if sys.platform == 'win32':
     # https://msdn.microsoft.com/library/windows/desktop/aa366589.aspx
     class MemoryStatusEx(ctypes.Structure):
       _fields_ = [
         ('dwLength', ctypes.c_ulong),
         ('dwMemoryLoad', ctypes.c_ulong),
         ('dwTotalPhys', ctypes.c_ulonglong),
@@ skipping 38 matching lines @@
   return 0
 
 
 def get_disks_info():
   """Returns a dict of dict of free and total disk space."""
   if sys.platform == 'win32':
     return _get_disks_info_win()
   return _get_disks_info_posix()
 
 
-@cached
+@tools.cached
 def get_gpu():
   """Returns the installed video card(s) name.
 
   Returns:
     All the video cards detected.
     tuple(list(dimensions), list(state)).
   """
   if sys.platform == 'darwin':
     dimensions, state = _get_gpu_osx()
   elif sys.platform == 'linux2':
     dimensions, state = _get_gpu_linux()
   elif sys.platform == 'win32':
     dimensions, state = _get_gpu_win()
   else:
     dimensions, state = None, None
 
   # 15ad is VMWare. It's akin not having a GPU card.
   dimensions = dimensions or [u'none']
   if '15ad' in dimensions:
     dimensions.append(u'none')
     dimensions.sort()
   return dimensions, state
 
 
-@cached
+@tools.cached
 def get_monitor_hidpi():
   """Returns True if there is an hidpi monitor detected."""
   if sys.platform == 'darwin':
     return [_get_monitor_hidpi_osx()]
   return None
 
 
-@cached
+@tools.cached
 def get_cost_hour():
   """Returns the cost in $USD/h as a floating point value if applicable."""
   if _get_metadata_gce():
     return _get_cost_hour_gce()
 
   # Get an approximate cost trying to emulate GCE equivalent cost.
   cores = get_num_processors()
   os_cost = 0.
   if sys.platform == 'darwin':
       # Apple tax. It's 50% better, right?
       os_cost = GCE_WINDOWS_COST_CORE_HOUR * 1.5 * cores
   elif sys.platform == 'win32':
       # MS tax.
       os_cost = GCE_WINDOWS_COST_CORE_HOUR * cores
 
   # Guess an equivalent machine_type.
   machine_cost = GCE_MACHINE_COST_HOUR_US.get(get_machine_type(), 0.)
 
   # Assume HDD for now, it's the cheapest. That's not true, we do have SSDs.
   disk_gb_cost = 0.
   for disk in get_disks_info().itervalues():
       disk_gb_cost += disk['free_mb'] / 1024. * (
           GCE_HDD_GB_COST_MONTH / 30. / 24.)
   return machine_cost + os_cost + disk_gb_cost
 
 
-@cached
+@tools.cached
 def get_machine_type():
   """Returns a GCE-equivalent machine type.
 
   If running on GCE, returns the right machine type. Otherwise tries to find the
   'closest' one.
   """
   if _get_metadata_gce():
     return get_machine_type_gce()
 
   ram_gb = get_physical_ram() / 1024.
@@ skipping 24 matching lines @@
         else:
           machine_type = u'n1-standard-1'
       else:
         logging.info('Failed to find a fit: %s', machine_type)
 
   if machine_type not in GCE_MACHINE_COST_HOUR_US:
     return None
   return machine_type
 
 
-@cached
+@tools.cached
 def can_send_metric():
   """True if 'send_metric' really does something."""
   if _get_metadata_gce():
-    return _MONITORING_SCOPE in _oauth2_available_scopes_gce()
+    # Scope to use Cloud Monitoring.
+    scope = 'https://www.googleapis.com/auth/monitoring'
+    return scope in _oauth2_available_scopes_gce()
   return False
 
 
 def send_metric(name, value):
   if _get_metadata_gce():
     return send_metric_gce(name, value)
   # Ignore on other platforms for now.
 
 
 ### Google Cloud Compute Engine.
 
 
-@cached
+@tools.cached
 def get_zone_gce():
   """Returns the zone containing the GCE VM."""
   metadata = _get_metadata_gce()
   if not metadata:
     return None
   # Format is projects/<id>/zones/<zone>
   return unicode(metadata['instance']['zone'].rsplit('/', 1)[-1])
 
 
-@cached
+@tools.cached
 def get_machine_type_gce():
   """Returns the GCE machine type."""
   metadata = _get_metadata_gce()
   if not metadata:
     return None
   # Format is projects/<id>/machineTypes/<machine_type>
   return unicode(metadata['instance']['machineType'].rsplit('/', 1)[-1])
 
 
-@cached
+@tools.cached
 def get_tags_gce():
   """Returns a list of instance tags or empty list if not GCE VM."""
   metadata = _get_metadata_gce()
   if not metadata:
     return []
   return metadata['instance']['tags']
 
 
 def send_metric_gce(name, value):
   """Sets a lightweight custom metric.
@@ skipping 55 matching lines @@
     logging.debug(json.load(resp))
   except urllib2.HTTPError as e:
     logging.error('send_metric failed: %s: %s' % (e, e.read()))
   except IOError as e:
     logging.error('send_metric failed: %s' % e)
 
 
 ### Windows.
 
 
-@cached
+@tools.cached
 def get_integrity_level_win():
   """Returns the integrity level of the current process as a string.
 
   TODO(maruel): It'd be nice to make it work on cygwin. The problem is that
   ctypes.windll is unaccessible and it is not known to the author how to use
   stdcall convention through ctypes.cdll.
   """
   if sys.platform != 'win32':
     return None
   if get_os_version_number() == u'5.1':
@@ skipping 103 matching lines @@
         token_info.Label.Sid, p_sid_size.contents.value - 1)
     value = res.contents.value
     return mapping.get(value) or u'0x%04x' % value
   finally:
     ctypes.windll.kernel32.CloseHandle(token)
 
 
 ### Android.
 
 
-def get_adb_list_devices(adb_path='adb'):
-  """Returns the list of devices available. This includes emulators."""
-  output = subprocess.check_output([adb_path, 'devices'])
-  devices = []
-  for line in output.splitlines():
-    if line.startswith(('*', 'List of')) or not line:
-      continue
-    # TODO(maruel): Handle 'offline', 'device', 'no device' and
-    # 'unauthorized'.
-    devices.append(line.split()[0])
-  return devices
-
-
-def get_adb_device_properties_raw(device_id, adb_path='adb'):
-  """Returns the system properties for a device."""
-  output = subprocess.check_output(
-      [adb_path, '-s', device_id, 'shell', 'cat', '/system/build.prop'])
-  properties = {}
-  for line in output.splitlines():
-    if line.startswith('#') or not line:
-      continue
-    key, value = line.split('=', 1)
-    properties[key] = value
-  return properties
-
-
-def get_dimensions_android(device_id, adb_path='adb'):
-  """Returns the default dimensions for an android device.
-
-  In this case, details are about the device, not about the host.
-  """
-  properties = get_adb_device_properties_raw(device_id, adb_path)
-  out = dict(
-      (k, [v]) for k, v in properties.iteritems() if k in ANDROID_DETAILS)
-  out[u'id'] = [device_id]
-  return out
-
-
-def get_state_android(device_id, adb_path='adb'):
-  """Returns state information about the device.
-
-  It's a big speculating TODO. Would be temperature, device uptime, partition
-  space, etc.
-  """
-  # Unused argument - pylint: disable=W0613
-  return {
-    u'device': {
-      # TODO(maruel): Fill me.
-    },
-    u'host': get_state(),
-  }
 
 
 ###
 
 
 def get_dimensions():
   """Returns the default dimensions."""
   os_name = get_os_name()
   cpu_type = get_cpu_type()
   cpu_bitness = get_cpu_bitness()
@@ skipping 321 matching lines @@
     u'dimensions': get_dimensions(),
     u'state': get_state(),
   }
   json.dump(data, sys.stdout, indent=2, sort_keys=True, separators=(',', ': '))
   print('')
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())