Remove not used code

mock/api/service.py

@@ -8,6 +8,7 @@
 
 LOG = logging.getLogger('mock.api.service')
 
+
 class Mock(wsgi.Application):
 
     def __init__(self, config):

mock/wsgi.py

@@ -273,153 +273,3 @@ def print_generator(app_iter):
             #sys.stdout.flush()
             yield part
         print
-
-
-class Router(object):
-    """WSGI middleware that maps incoming requests to WSGI apps."""
-
-    def __init__(self, mapper):
-        """Create a router for the given routes.Mapper.
-
-        Each route in `mapper` must specify a 'controller', which is a
-        WSGI app to call.  You'll probably want to specify an 'action' as
-        well and have your controller be an object that can route
-        the request to the action-specific method.
-
-        Examples:
-          mapper = routes.Mapper()
-          sc = ServerController()
-
-          # Explicit mapping of one route to a controller+action
-          mapper.connect(None, '/svrlist', controller=sc, action='list')
-
-          # Actions are all implicitly defined
-          mapper.resource('server', 'servers', controller=sc)
-
-          # Pointing to an arbitrary WSGI app.  You can specify the
-          # {path_info:.*} parameter so the target app can be handed just that
-          # section of the URL.
-          mapper.connect(None, '/v1.0/{path_info:.*}', controller=BlogApp())
-
-        """
-        self.map = mapper
-        self._router = routes.middleware.RoutesMiddleware(self._dispatch,
-                                                          self.map)
-
-    @webob.dec.wsgify(RequestClass=Request)
-    def __call__(self, req):
-        """Route the incoming request to a controller based on self.map.
-
-        If no match, return a 404.
-
-        """
-        return self._router
-
-    @staticmethod
-    @webob.dec.wsgify(RequestClass=Request)
-    def _dispatch(req):
-        """Dispatch the request to the appropriate controller.
-
-        Called by self._router after matching the incoming request to a route
-        and putting the information into req.environ.  Either returns 404
-        or the routed WSGI app's response.
-
-        """
-        match = req.environ['wsgiorg.routing_args'][1]
-        if not match:
-            return webob.exc.HTTPNotFound()
-        app = match['controller']
-        return app
-
-
-class ComposingRouter(Router):
-    def __init__(self, mapper=None, routers=None):
-        if mapper is None:
-            mapper = routes.Mapper()
-        if routers is None:
-            routers = []
-        for router in routers:
-            router.add_routes(mapper)
-        super(ComposingRouter, self).__init__(mapper)
-
-
-class ComposableRouter(Router):
-    """Router that supports use by ComposingRouter."""
-
-    def __init__(self, mapper=None):
-        if mapper is None:
-            mapper = routes.Mapper()
-        self.add_routes(mapper)
-        super(ComposableRouter, self).__init__(mapper)
-
-    def add_routes(self, mapper):
-        """Add routes to given mapper."""
-        pass
-
-
-class ExtensionRouter(Router):
-    """A router that allows extensions to supplement or overwrite routes.
-
-    Expects to be subclassed.
-    """
-    def __init__(self, application, mapper=None):
-        if mapper is None:
-            mapper = routes.Mapper()
-        self.application = application
-        self.add_routes(mapper)
-        mapper.connect('{path_info:.*}', controller=self.application)
-        super(ExtensionRouter, self).__init__(mapper)
-
-    def add_routes(self, mapper):
-        pass
-
-    @classmethod
-    def factory(cls, global_config, **local_config):
-        """Used for paste app factories in paste.deploy config files.
-
-        Any local configuration (that is, values under the [filter:APPNAME]
-        section of the paste config) will be passed into the `__init__` method
-        as kwargs.
-
-        A hypothetical configuration would look like:
-
-            [filter:analytics]
-            redis_host = 127.0.0.1
-            paste.filter_factory = nova.api.analytics:Analytics.factory
-
-        which would result in a call to the `Analytics` class as
-
-            import nova.api.analytics
-            analytics.Analytics(app_from_paste, redis_host='127.0.0.1')
-
-        You could of course re-implement the `factory` method in subclasses,
-        but using the kwarg passing it shouldn't be necessary.
-
-        """
-        def _factory(app):
-            conf = global_config.copy()
-            conf.update(local_config)
-            return cls(app)
-        return _factory
-
-
-def render_response(body, status=(200, 'OK'), headers=None):
-    """Forms a WSGI response"""
-    resp = webob.Response()
-    resp.status = '%s %s' % status
-    resp.headerlist = headers or [('Content-Type', 'application/json')]
-
-    resp.body = json.dumps(body)
-
-    return resp
-
-
-def render_exception(error):
-    """Forms a WSGI response based on the current error."""
-    return render_response(status=(error.code, error.title), body={
-        'error': {
-            'code': error.code,
-            'title': error.title,
-            'message': str(error),
-        }
-    })