Setup basic Runtime with properties and platform.

recipe_engine/recipe_api.py

 # Copyright 2016 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.
 
 from __future__ import absolute_import
 import contextlib
 import collections
 import copy
 import keyword
 import re
@@ skipping 66 matching lines @@
     def do_something(self):
       self.step_client.whatever()
 
   Args:
     name (str): the name of the recipe engine client to install.
   """
   return _UnresolvedRequirement('client', name)
 
 
 class PropertiesClient(object):
-  """A recipe engine client representing the recipe engine properties."""
+  """A recipe engine client representing the recipe engine properties.
+
+  The retained properties are frozen, and can be safely passed around.
+  """
 
   IDENT = 'properties'
 
-  def __init__(self, engine):
-    self._engine = engine
+  def __init__(self, rt):
+    self._rt = rt
 
-  def get_properties(self):
-    return copy.deepcopy(self._engine.properties)
+  @property
+  def properties(self):
+    """Returns (types.FrozenDict): Frozen properties."""
+    return self._rt.properties
+
+  def mutable_properties(self):

[iannucci, 2016/10/19 16:41:03]

this seems really dangerous to me; we've never exposed a mutable properties
dictionary to user code before. We didn't do this specifically to prevent people
from using it as a loosely coupled global variable mechanism (which they used
properties for previous to recipes).

Why do we need this?

[dnj, 2016/10/19 16:44:05]

The mutable properties function returns a deepcopy, so this should be 100% safe.

+    """Returns (dict): Mutable original properties dict."""
+    return self._rt.mutable_properties()
 
 
 class StepClient(object):
   """A recipe engine client representing step running and introspection."""
 
   IDENT = 'step'
 
   def __init__(self, engine):
     self._engine = engine
 
@@ skipping 14 matching lines @@
 
     Args:
       step_dict (dict): A step dictionary to run.
 
     Returns:
       A StepData object containing the result of running the step.
     """
     return self._engine.run_step(StepConfig.create(**step_dict))
 
 
+class PlatformClient(object):
+  """A recipe engine client to expose a common view of the running platform."""
+
+  IDENT = 'platform'
+
+  def __init__(self, plat):
+    self._plat = plat
+
+    # Export normalization methods.
+    self.norm_plat = plat.norm_plat
+    self.norm_bits = plat.norm_bits
+
+    # Export platform constants.
+    self.WIN = plat.WIN
+    self.LINUX = plat.LINUX
+    self.MAC = plat.MAC
+
+  @property
+  def name(self):
+    return self._plat.name
+
+  @property
+  def bits(self):
+    return self._plat.bits
+
+  @property
+  def arch(self):
+    return self._plat.arch
+
+
 class DependencyManagerClient(object):
   """A recipe engine client representing the dependency manager."""
 
   IDENT = 'dependency_manager'
 
   def __init__(self, engine):
     self._engine = engine
 
   def depend_on(self, recipe, properties, **kwargs):
     return self._engine.depend_on(recipe, properties, **kwargs)
@@ skipping 788 matching lines @@
     """
     Gets the BoundProperty version of this Property. Requires a name.
     """
     return BoundProperty(
         self._default, self.help, self.kind, name, property_type, module,
         self.param_name)
 
 class UndefinedPropertyException(TypeError):
   pass