1 config = "python_paste.ini"
2 appname = "common"
3 wsgi_app = loadapp("config:%s" % os.path.abspath(config), appname)
4  server = make_server(‘localhost‘,80,wsgi_app)
5 server.serve_forever()

[composite:common]
use = egg:Paste#urlmap
/:showversion
/log:showversion_log
/v1:apiv1app

[pipeline:showversion_log]
pipeline = filter_log showversion

[filter:filter_log ]
#filter2 deal with time,read args belowmanage
paste.filter_factory = manage:LogFilter.factory

[app:apiv1app]
paste.app_factory = v1.router:MyRouterApp.factory

[app:showversion]
version = 1.0.0
paste.app_factory = manage:ShowVersion.factory

 1 class ShowVersion(object):
 2       ‘‘‘
 3       app
 4       ‘‘‘
 5       def __init__(self,version):
 6           self.version = version
 7       def __call__(self,environ,start_response):
 8           res = Response()
 9           res.status = ‘200 OK‘
10           res.content_type = "text/plain"
11           content = []
12           content.append("%s\n" % self.version)
13           res.body = ‘\n‘.join(content)
14           return res(environ,start_response)
15       @classmethod
16       def factory(cls,global_conf,**kwargs):
17           print ‘factory‘
18           print "kwargs:",kwargs
19           return ShowVersion(kwargs[‘version‘])

 1 class LogFilter(object):
 2       ‘‘‘
 3       Log
 4       ‘‘‘
 5       def __init__(self,app):
 6           self.app = app
 7       def __call__(self,environ,start_response):
 8           print ‘you can write log.‘
 9           return self.app(environ,start_response)
10       @classmethod
11       def factory(cls,global_conf,**kwargs):
12           return LogFilter

 1 import wsgi
 2 
 3 class ControllerTest(object):
 4     def __init__(self):
 5         print "ControllerTest!!!!"
 6     def test(self,req):
 7           print "req",req
 8           return {
 9             ‘name‘: "test",
10             ‘properties‘: "test"
11         }
12 
13 class MyRouterApp(wsgi.Router):
14       ‘‘‘
15       app
16       ‘‘‘
17       def __init__(self,mapper):
18           controller = ControllerTest()
19           mapper.connect(‘/test‘,
20                        controller=wsgi.Resource(controller),
21                        action=‘test‘,
22                        conditions={‘method‘: [‘GET‘]})
23           super(MyRouterApp, self).__init__(mapper)

  1 import datetime
  2 import json
  3 import routes
  4 import routes.middleware
  5 import webob
  6 import webob.dec
  7 import webob.exc
  8 
  9 class APIMapper(routes.Mapper):
 10     """
 11     Handle route matching when url is ‘‘ because routes.Mapper returns
 12     an error in this case.
 13     """
 14 
 15     def routematch(self, url=None, environ=None):
 16         if url is "":
 17             result = self._match("", environ)
 18             return result[0], result[1]
 19         return routes.Mapper.routematch(self, url, environ)
 20 
 21 class Router(object):
 22     def __init__(self, mapper):
 23         mapper.redirect("", "/")
 24         self.map = mapper
 25         self._router = routes.middleware.RoutesMiddleware(self._dispatch,
 26                                                           self.map)
 27 
 28     @classmethod
 29     def factory(cls, global_conf, **local_conf):
 30         return cls(APIMapper())
 31 
 32     @webob.dec.wsgify
 33     def __call__(self, req):
 34         """
 35         Route the incoming request to a controller based on self.map.
 36         If no match, return a 404.
 37         """
 38         return self._router
 39 
 40     @staticmethod
 41     @webob.dec.wsgify
 42     def _dispatch(req):
 43         """
 44         Called by self._router after matching the incoming request to a route
 45         and putting the information into req.environ.  Either returns 404
 46         or the routed WSGI app‘s response.
 47         """
 48         match = req.environ[‘wsgiorg.routing_args‘][1]
 49         if not match:
 50             return webob.exc.HTTPNotFound()
 51         app = match[‘controller‘]
 52         return app
 53 
 54 class Request(webob.Request):
 55     """Add some Openstack API-specific logic to the base webob.Request."""
 56 
 57     def best_match_content_type(self):
 58         """Determine the requested response content-type."""
 59         supported = (‘application/json‘,)
 60         bm = self.accept.best_match(supported)
 61         return bm or ‘application/json‘
 62 
 63     def get_content_type(self, allowed_content_types):
 64         """Determine content type of the request body."""
 65         if "Content-Type" not in self.headers:
 66             return
 67 
 68         content_type = self.content_type
 69 
 70         if content_type not in allowed_content_types:
 71             return
 72         else:
 73             return content_type
 74 
 75 class JSONRequestDeserializer(object):
 76     def has_body(self, request):
 77         """
 78         Returns whether a Webob.Request object will possess an entity body.
 79 
 80         :param request:  Webob.Request object
 81         """
 82         if ‘transfer-encoding‘ in request.headers:
 83             return True
 84         elif request.content_length > 0:
 85             return True
 86 
 87         return False
 88 
 89     def _sanitizer(self, obj):
 90         """Sanitizer method that will be passed to json.loads."""
 91         return obj
 92 
 93     def from_json(self, datastring):
 94         try:
 95             return json.loads(datastring, object_hook=self._sanitizer)
 96         except ValueError:
 97             msg = _(‘Malformed JSON in request body.‘)
 98             raise webob.exc.HTTPBadRequest(explanation=msg)
 99 
100     def default(self, request):
101         if self.has_body(request):
102             return {‘body‘: self.from_json(request.body)}
103         else:
104             return {}
105 
106 class JSONResponseSerializer(object):
107 
108     def _sanitizer(self, obj):
109         """Sanitizer method that will be passed to json.dumps."""
110         if isinstance(obj, datetime.datetime):
111             return obj.isoformat()
112         if hasattr(obj, "to_dict"):
113             return obj.to_dict()
114         return obj
115 
116     def to_json(self, data):
117         return json.dumps(data, default=self._sanitizer)
118 
119     def default(self, response, result):
120         response.content_type = ‘application/json‘
121         response.body = self.to_json(result)
122 
123 class Resource(object):
124     def __init__(self, controller, deserializer=None, serializer=None):
125         self.controller = controller
126         self.serializer = serializer or JSONResponseSerializer()
127         self.deserializer = deserializer or JSONRequestDeserializer()
128 
129     @webob.dec.wsgify(RequestClass=Request)
130     def __call__(self, request):
131         """WSGI method that controls (de)serialization and method dispatch."""
132         action_args = self.get_action_args(request.environ)
133         action = action_args.pop(‘action‘, None)
134 
135         deserialized_request = self.dispatch(self.deserializer,
136                                              action, request)
137         action_args.update(deserialized_request)
138 
139         action_result = self.dispatch(self.controller, action,
140                                       request, **action_args)
141         try:
142             response = webob.Response(request=request)
143             self.dispatch(self.serializer, action, response, action_result)
144             return response
145 
146         except webob.exc.HTTPException as e:
147             return e
148         # return unserializable result (typically a webob exc)
149         except Exception:
150             return action_result
151 
152     def dispatch(self, obj, action, *args, **kwargs):
153         """Find action-specific method on self and call it."""
154         try:
155             method = getattr(obj, action)
156         except AttributeError:
157             method = getattr(obj, ‘default‘)
158 
159         return method(*args, **kwargs)
160 
161     def get_action_args(self, request_environment):
162         """Parse dictionary created by routes library."""
163         try:
164             args = request_environment[‘wsgiorg.routing_args‘][1].copy()
165         except Exception:
166             return {}
167 
168         try:
169             del args[‘controller‘]
170         except KeyError:
171             pass
172 
173         try:
174             del args[‘format‘]
175         except KeyError:
176             pass
177 
178         return args

1           mapper.connect(‘/test‘,
2                        controller=wsgi.Resource(controller),
3                        action=‘test‘,
4                        conditions={‘method‘: [‘GET‘]})