Remove obsolete JSON-RPC code.

JSON-RPC has never been supported in released versions of the
framework. Removing this code before a refactor.

Author: inklesspen

endpoints/api_config_manager.py

@@ -36,7 +36,6 @@ class ApiConfigManager(object):
   """Manages loading api configs and method lookup."""
 
   def __init__(self):
-    self._rpc_method_dict = {}
     self._rest_methods = []
     self._configs = {}
     self._config_lock = threading.Lock()
@@ -75,7 +74,6 @@ def process_api_config_response(self, config_json):
 
 
         for method_name, method in sorted_methods:
-          self._save_rpc_method(method_name, api_version, method)
           self._save_rest_method(method_name, name, path_version, method)
 
   def _get_sorted_methods(self, methods):
@@ -167,23 +165,6 @@ def _get_path_params(match):
       result[actual_var_name] = urllib.unquote_plus(value)
     return result
 
-  def lookup_rpc_method(self, method_name, version):
-    """Lookup the JsonRPC method at call time.
-
-    The method is looked up in self._rpc_method_dict, the dictionary that
-    it is saved in for SaveRpcMethod().
-
-    Args:
-      method_name: A string containing the name of the method.
-      version: A string containing the version of the API.
-
-    Returns:
-      Method descriptor as specified in the API configuration.
-    """
-    with self._config_lock:
-      method = self._rpc_method_dict.get((method_name, version))
-    return method
-
   def lookup_rest_method(self, path, http_method):
     """Look up the rest method at call time.
 
@@ -319,19 +300,6 @@ def replace_variable(match):
                      replace_variable, pattern)
     return re.compile(pattern + '/?$')
 
-  def _save_rpc_method(self, method_name, version, method):
-    """Store JsonRpc api methods in a map for lookup at call time.
-
-    (rpcMethodName, apiVersion) => method.
-
-    Args:
-      method_name: A string containing the name of the API method.
-      version: A string containing the version of the API.
-      method: A dict containing the method descriptor (as in the api config
-        file).
-    """
-    self._rpc_method_dict[(method_name, version)] = method
-
   def _save_rest_method(self, method_name, api_name, version, method):
     """Store Rest api methods in a list for lookup at call time.
 

endpoints/api_request.py

@@ -179,14 +179,5 @@ def reconstruct_full_url(self, port_override=None):
   def copy(self):
     return copy.deepcopy(self)
 
-  def is_rpc(self):
-    # Google's JsonRPC protocol creates a handler at /rpc for any Cloud
-    # Endpoints API, with api name, version, and method name being in the
-    # body of the request.
-    # If the request is sent to /rpc, we will treat it as JsonRPC.
-    # The client libraries for iOS's Objective C use RPC and not the REST
-    # versions of the API.
-    return self.path == 'rpc'
-
   def is_batch(self):
     return self._is_batch

endpoints/endpoints_dispatcher.py

@@ -327,11 +327,7 @@ def call_backend(self, orig_request, start_response):
     Returns:
       A string containing the response body.
     """
-    if orig_request.is_rpc():
-      method_config = self.lookup_rpc_method(orig_request)
-      params = None
-    else:
-      method_config, params = self.lookup_rest_method(orig_request)
+    method_config, params = self.lookup_rest_method(orig_request)
     if not method_config:
       cors_handler = self._create_cors_handler(orig_request)
       return util.send_wsgi_not_found_response(start_response,
@@ -448,19 +444,14 @@ def handle_backend_response(self, orig_request, backend_request,
 
     self.check_error_response(response_body, response_status)
 
-    # Need to check is_rpc() against the original request, because the
-    # incoming request here has had its path modified.
-    if orig_request.is_rpc():
-      body = self.transform_jsonrpc_response(backend_request, response_body)
-    else:
-      # Check if the response from the API was empty.  Empty REST responses
-      # generate a HTTP 204.
-      empty_response = self.check_empty_response(orig_request, method_config,
+    # Check if the response from the API was empty.  Empty REST responses
+    # generate a HTTP 204.
+    empty_response = self.check_empty_response(orig_request, method_config,
                                                  start_response)
-      if empty_response is not None:
-        return empty_response
+    if empty_response is not None:
+      return empty_response
 
-      body = self.transform_rest_response(response_body)
+    body = self.transform_rest_response(response_body)
 
     cors_handler = self._create_cors_handler(orig_request)
     return util.send_wsgi_response(response_status, response_headers, body,
@@ -498,23 +489,6 @@ def lookup_rest_method(self, orig_request):
     orig_request.method_name = method_name
     return method, params
 
-  def lookup_rpc_method(self, orig_request):
-    """Looks up and returns RPC method for the currently-pending request.
-
-    Args:
-      orig_request: An ApiRequest, the original request from the user.
-
-    Returns:
-      The RPC method descriptor that was found for the current request, or None
-      if none was found.
-    """
-    if not orig_request.body_json:
-      return None
-    method_name = orig_request.body_json.get('method', '')
-    version = orig_request.body_json.get('apiVersion', '')
-    orig_request.method_name = method_name
-    return self.config_manager.lookup_rpc_method(method_name, version)
-
   def transform_request(self, orig_request, params, method_config):
     """Transforms orig_request to apiserving request.
 
@@ -533,11 +507,8 @@ def transform_request(self, orig_request, params, method_config):
       be sent to the backend.  The path is updated and parts of the body or
       other properties may also be changed.
     """
-    if orig_request.is_rpc():
-      request = self.transform_jsonrpc_request(orig_request)
-    else:
-      method_params = method_config.get('request', {}).get('parameters', {})
-      request = self.transform_rest_request(orig_request, params, method_params)
+    method_params = method_config.get('request', {}).get('parameters', {})
+    request = self.transform_rest_request(orig_request, params, method_params)
     request.path = method_config.get('rosyMethod', '')
     return request
 
@@ -674,21 +645,6 @@ def transform_rest_request(self, orig_request, params, method_parameters):
     request.body = json.dumps(request.body_json)
     return request
 
-  def transform_jsonrpc_request(self, orig_request):
-    """Translates a JsonRpc request/response into apiserving request/response.
-
-    Args:
-      orig_request: An ApiRequest, the original request from the user.
-
-    Returns:
-      A new request with the request_id updated and params moved to the body.
-    """
-    request = orig_request.copy()
-    request.request_id = request.body_json.get('id')
-    request.body_json = request.body_json.get('params', {})
-    request.body = json.dumps(request.body_json)
-    return request
-
   def check_error_response(self, body, status):
     """Raise an exception if the response from the backend was an error.
 
@@ -740,40 +696,6 @@ def transform_rest_response(self, response_body):
     body_json = json.loads(response_body)
     return json.dumps(body_json, indent=1, sort_keys=True)
 
-  def transform_jsonrpc_response(self, backend_request, response_body):
-    """Translates an apiserving response to a JsonRpc response.
-
-    Args:
-      backend_request: An ApiRequest, the transformed request that was sent to
-        the backend handler.
-      response_body: A string containing the backend response to transform
-        back to JsonRPC.
-
-    Returns:
-      A string with the updated, JsonRPC-formatted request body.
-    """
-    body_json = {'result': json.loads(response_body)}
-    return self._finish_rpc_response(backend_request.request_id,
-                                     backend_request.is_batch(), body_json)
-
-  def _finish_rpc_response(self, request_id, is_batch, body_json):
-    """Finish adding information to a JSON RPC response.
-
-    Args:
-      request_id: None if the request didn't have a request ID.  Otherwise, this
-        is a string containing the request ID for the request.
-      is_batch: A boolean indicating whether the request is a batch request.
-      body_json: A dict containing the JSON body of the response.
-
-    Returns:
-      A string with the updated, JsonRPC-formatted request body.
-    """
-    if request_id is not None:
-      body_json['id'] = request_id
-    if is_batch:
-      body_json = [body_json]
-    return json.dumps(body_json, indent=1, sort_keys=True)
-
   def _handle_request_error(self, orig_request, error, start_response):
     """Handle a request error, converting it to a WSGI response.
 
@@ -786,16 +708,8 @@ def _handle_request_error(self, orig_request, error, start_response):
       A string containing the response body.
     """
     headers = [('Content-Type', 'application/json')]
-    if orig_request.is_rpc():
-      # JSON RPC errors are returned with status 200 OK and the
-      # error details in the body.
-      status_code = 200
-      body = self._finish_rpc_response(orig_request.body_json.get('id'),
-                                       orig_request.is_batch(),
-                                       error.rpc_error())
-    else:
-      status_code = error.status_code()
-      body = error.rest_error()
+    status_code = error.status_code()
+    body = error.rest_error()
 
     response_status = '%d %s' % (status_code,
                                  httplib.responses.get(status_code,

endpoints/test/api_config_manager_test.py

@@ -28,15 +28,15 @@ def setUp(self):
 
   def test_process_api_config_empty_response(self):
     self.config_manager.process_api_config_response({})
-    actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get',
-                                                          'v1')
-    self.assertEqual(None, actual_method)
+    actual_method = self.config_manager.lookup_rest_method('guestbook_api',
+                                                           'GET')
+    self.assertEqual((None, None, None), actual_method)
 
   def test_process_api_config_invalid_response(self):
     self.config_manager.process_api_config_response({'name': 'foo'})
-    actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get',
-                                                          'v1')
-    self.assertEqual(None, actual_method)
+    actual_method = self.config_manager.lookup_rest_method('guestbook_api',
+                                                           'GET')
+    self.assertEqual((None, None, None), actual_method)
 
   def test_process_api_config(self):
     fake_method = {'httpMethod': 'GET',
@@ -48,8 +48,8 @@ def test_process_api_config(self):
               'path_version': 'X',
               'methods': {'guestbook_api.foo.bar': fake_method}}
     self.config_manager.process_api_config_response({'items': [config]})
-    actual_method = self.config_manager.lookup_rpc_method(
-        'guestbook_api.foo.bar', 'X')
+    actual_method = self.config_manager.lookup_rest_method(
+        'guestbook_api/X/greetings/123', 'GET')[1]
     self.assertEqual(fake_method, actual_method)
 
   def test_process_api_config_order_length(self):
@@ -73,9 +73,9 @@ def test_process_api_config_order_length(self):
     self.config_manager.process_api_config_response(
         {'items': [config]})
     # Make sure all methods appear in the result.
-    for method_name, _, _ in test_method_info:
-      self.assertIsNotNone(
-          self.config_manager.lookup_rpc_method(method_name, 'X'))
+    for method_name, path, _ in test_method_info:
+      request_path = 'guestbook_api/X/{}'.format(path.replace('{gid}', '123'))
+      assert (None, None, None) != self.config_manager.lookup_rest_method(request_path, 'GET')
     # Make sure paths and partial paths return the right methods.
     self.assertEqual(
         self.config_manager.lookup_rest_method(
@@ -170,19 +170,6 @@ def test_process_api_config_convert_https(self):
         'https://localhost/_ah/api',
         self.config_manager.configs[('guestbook_api', 'X')]['root'])
 
-  def test_save_lookup_rpc_method(self):
-    # First attempt, guestbook.get does not exist
-    actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get',
-                                                          'v1')
-    self.assertEqual(None, actual_method)
-
-    # Now we manually save it, and should find it
-    fake_method = {'some': 'object'}
-    self.config_manager._save_rpc_method('guestbook_api.get', 'v1', fake_method)
-    actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get',
-                                                          'v1')
-    self.assertEqual(fake_method, actual_method)
-
   def test_save_lookup_rest_method(self):
     # First attempt, guestbook.get does not exist
     method_spec = self.config_manager.lookup_rest_method(