Remove pointless JSON roundtripping.

We don't need to serialize JSON and then just directly unserialize
it. That seems to have existed only to support a v1 feature.

Author: inklesspen

endpoints/api_backend_service.py

@@ -39,13 +39,13 @@
 
 
 class ApiConfigRegistry(object):
-  """Registry of active APIs to be registered with Google API Server."""
+  """Registry of active APIs"""
 
   def __init__(self):
     # Set of API classes that have been registered.
     self.__registered_classes = set()
     # Set of API config contents served by this App Engine AppId/version
-    self.__api_configs = set()
+    self.__api_configs = []
     # Map of API method name to ProtoRPC method name.
     self.__api_methods = {}
 
@@ -54,14 +54,13 @@ def register_backend(self, config_contents):
     """Register a single API and its config contents.
 
     Args:
-      config_contents: String containing API configuration.
+      config_contents: Dict containing API configuration.
     """
     if config_contents is None:
       return
-    parsed_config = json.loads(config_contents)
-    self.__register_class(parsed_config)
-    self.__api_configs.add(config_contents)
-    self.__register_methods(parsed_config)
+    self.__register_class(config_contents)
+    self.__api_configs.append(config_contents)
+    self.__register_methods(config_contents)
 
   def __register_class(self, parsed_config):
     """Register the class implementing this config, so we only add it once.
@@ -120,7 +119,7 @@ def lookup_api_method(self, api_method_name):
 
   def all_api_configs(self):
     """Return a list of all API configration specs as registered above."""
-    return list(self.__api_configs)
+    return self.__api_configs
 
 
 class BackendServiceImpl(api_backend.BackendService):
@@ -159,7 +158,7 @@ def getApiConfigs(self, request=None):
           message='API backend app revision %s not the same as expected %s' % (
               self.__app_revision, request.appRevision))
 
-    configs = self.__api_config_registry.all_api_configs()
+    configs = [json.dumps(d) for d in self.__api_config_registry.all_api_configs()]
     return api_backend.ApiConfigList(items=configs)
 
   def logMessages(self, request):

endpoints/apiserving.py

@@ -333,8 +333,8 @@ def __register_services(api_name_version_map, api_config_registry):
     for service_factories in api_name_version_map.itervalues():
       service_classes = [service_factory.service_class
                          for service_factory in service_factories]
-      config_file = generator.pretty_print_config_to_json(service_classes)
-      api_config_registry.register_backend(config_file)
+      config_dict = generator.get_config_dict(service_classes)
+      api_config_registry.register_backend(config_dict)
 
       for service_factory in service_factories:
         protorpc_class_name = service_factory.service_class.__name__
@@ -412,8 +412,7 @@ def protorpc_to_endpoints_error(self, status, body):
 
   def get_api_configs(self):
     return {
-        'items': [json.loads(c) for c in
-                  self.api_config_registry.all_api_configs()]}
+        'items': self.api_config_registry.all_api_configs()}
 
   def __call__(self, environ, start_response):
     """Wrapper for the Endpoints server app.

endpoints/test/api_backend_service_test.py

@@ -39,12 +39,12 @@ def setUp(self):
 
   def testApiMethodsMapped(self):
     self.registry.register_backend(
-        '{"methods": {"method1": {"rosyMethod": "foo"}}}')
+        {"methods": {"method1": {"rosyMethod": "foo"}}})
     self.assertEquals('foo', self.registry.lookup_api_method('method1'))
 
   def testAllApiConfigsWithTwoConfigs(self):
-    config1 = '{"methods": {"method1": {"rosyMethod": "c1.foo"}}}'
-    config2 = '{"methods": {"method2": {"rosyMethod": "c2.bar"}}}'
+    config1 = {"methods": {"method1": {"rosyMethod": "c1.foo"}}}
+    config2 = {"methods": {"method2": {"rosyMethod": "c2.bar"}}}
     self.registry.register_backend(config1)
     self.registry.register_backend(config2)
     self.assertEquals('c1.foo', self.registry.lookup_api_method('method1'))
@@ -55,29 +55,24 @@ def testNoneApiConfigContent(self):
     self.registry.register_backend(None)
     self.assertIsNone(self.registry.lookup_api_method('method'))
 
-  def testUnparseableApiConfigContent(self):
-    config = '{"methods": {"method": {"rosyMethod": "foo"'  # Unclosed {s
-    self.assertRaises(ValueError, self.registry.register_backend, config)
-    self.assertIsNone(self.registry.lookup_api_method('method'))
-
   def testEmptyApiConfig(self):
-    config = '{}'
+    config = {}
     self.registry.register_backend(config)
     self.assertIsNone(self.registry.lookup_api_method('method'))
 
   def testApiConfigContentWithNoMethods(self):
-    config = '{"methods": {}}'
+    config = {"methods": {}}
     self.registry.register_backend(config)
     self.assertIsNone(self.registry.lookup_api_method('method'))
 
   def testApiConfigContentWithNoRosyMethod(self):
-    config = '{"methods": {"method": {}}}'
+    config = {"methods": {"method": {}}}
     self.registry.register_backend(config)
     self.assertIsNone(self.registry.lookup_api_method('method'))
 
   def testRegisterSpiRootRepeatedError(self):
-    config1 = '{"methods": {"method1": {"rosyMethod": "MyClass.Func1"}}}'
-    config2 = '{"methods": {"method2": {"rosyMethod": "MyClass.Func2"}}}'
+    config1 = {"methods": {"method1": {"rosyMethod": "MyClass.Func1"}}}
+    config2 = {"methods": {"method2": {"rosyMethod": "MyClass.Func2"}}}
     self.registry.register_backend(config1)
     self.assertRaises(api_exceptions.ApiConfigurationError,
                       self.registry.register_backend, config2)
@@ -88,9 +83,9 @@ def testRegisterSpiRootRepeatedError(self):
 
   def testRegisterSpiDifferentClasses(self):
     """This can happen when multiple classes implement an API."""
-    config1 = ('{"methods": {'
-               '  "method1": {"rosyMethod": "MyClass.Func1"},'
-               '  "method2": {"rosyMethod": "OtherClass.Func2"}}}')
+    config1 = {"methods": {
+                 "method1": {"rosyMethod": "MyClass.Func1"},
+                 "method2": {"rosyMethod": "OtherClass.Func2"}}}
     self.registry.register_backend(config1)
     self.assertEquals('MyClass.Func1',
                       self.registry.lookup_api_method('method1'))