Use config.json to enable Isolated gRPC proxy

client/isolate_storage.py

 #!/usr/bin/env python
 # 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.
 
 """A low-level blob storage/retrieval interface to the Isolate server"""
 
 import base64
 import binascii
 import collections
@@ skipping 36 matching lines @@
 
 # Chunk size to use when reading from network stream.
 NET_IO_FILE_CHUNK = 16 * 1024
 
 
 # Read timeout in seconds for downloads from isolate storage. If there's no
 # response from the server within this timeout whole download will be aborted.
 DOWNLOAD_READ_TIMEOUT = 60
 
 
-# A class to use to communicate with the server by default. Can be changed by
-# 'set_storage_api_class'. Default is IsolateServer.
-_storage_api_cls = None
+# Stores the gRPC proxy address. Must be set if the storage API class is
+# IsolateServerGrpc (call 'set_grpc_proxy').
+_grpc_proxy = None
 
 
 class Item(object):
   """An item to push to Storage.
 
   Its digest and size may be provided in advance, if known. Otherwise they will
   be derived from content(). If digest is provided, it MUST correspond to
   hash algorithm used by Storage.
 
   When used with Storage, Item starts its life in a main thread, travels
@@ skipping 450 matching lines @@
     pass
 
 
 class IsolateServerGrpc(StorageApi):
   """StorageApi implementation that downloads and uploads to a gRPC service.
 
   Limitations: only works for the default-gzip namespace, and with zero offsets
   while fetching.
   """
 
-  def __init__(self, server, namespace):
+  def __init__(self, server, namespace, proxy):
     super(IsolateServerGrpc, self).__init__()
     logging.info('Using gRPC for Isolate')
     self._server = server
     self._lock = threading.Lock()
     self._memory_use = 0
     self._num_pushes = 0
     self._already_exists = 0
 
     # Proxies only support the default-gzip namespace for now.
     # TODO(aludwin): support other namespaces if necessary
     assert namespace == 'default-gzip'
     self._namespace = namespace
 
     # Make sure grpc was successfully imported
     assert grpc
     assert bytestream_pb2
 
-    proxy = os.environ.get('ISOLATED_GRPC_PROXY', '')
-    roots = os.environ.get('ISOLATED_GRPC_PROXY_TLS_ROOTS')
-    overd = os.environ.get('ISOLATED_GRPC_PROXY_TLS_OVERRIDE')
+    roots = os.environ.get('ISOLATE_GRPC_PROXY_TLS_ROOTS')
+    overd = os.environ.get('ISOLATE_GRPC_PROXY_TLS_OVERRIDE')
 
     # The "proxy" envvar must be of the form:
     # http[s]://<server>[:port][/prefix]
     m = re.search('^(https?):\/\/([^\/]+)/?(.*)$', proxy)
     if not m:
       raise ValueError(('gRPC proxy must have the form: '
                         'http[s]://<server>[:port][/prefix] '
                         '(given: %s)') % proxy)
     transport = m.group(1)
     host = m.group(2)
@@ skipping 132 matching lines @@
     assert all(i.digest is not None and i.size is not None for i in items)
     # Assume all Items are missing, and attach _PushState to them. The gRPC
     # implementation doesn't actually have a push state, we just attach empty
     # objects to satisfy the StorageApi interface.
     missing_items = {}
     for item in items:
       missing_items[item] = _IsolateServerGrpcPushState()
     return missing_items
 
 
-def set_storage_api_class(cls):
-  """Replaces StorageApi implementation used by default."""
-  global _storage_api_cls
-  assert _storage_api_cls is None
-  assert issubclass(cls, StorageApi)
-  _storage_api_cls = cls
+def set_grpc_proxy(proxy):
+  """Sets the StorageApi to use the specified proxy."""
+  global _grpc_proxy
+  assert _grpc_proxy is None
+  _grpc_proxy = proxy
 
 
 def get_storage_api(url, namespace):
   """Returns an object that implements low-level StorageApi interface.
 
   It is used by Storage to work with single isolate |namespace|. It should
   rarely be used directly by clients, see 'get_storage' for
   a better alternative.
 
   Arguments:
     url: URL of isolate service to use shared cloud based storage.
     namespace: isolate namespace to operate in, also defines hashing and
         compression scheme used, i.e. namespace names that end with '-gzip'
         store compressed data.
 
   Returns:
     Instance of StorageApi subclass.
   """
-  cls = _storage_api_cls or IsolateServer
-  return cls(url, namespace)
+  if _grpc_proxy is not None:
+    return IsolateServerGrpc(url, namespace, _grpc_proxy)
+  return IsolateServer(url, namespace)