siesta.py
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:15k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. """
  2. @file siesta.py
  3. @brief A tiny llsd based RESTful web services framework
  4. $LicenseInfo:firstyear=2008&license=mit$
  5. Copyright (c) 2008-2010, Linden Research, Inc.
  6. Permission is hereby granted, free of charge, to any person obtaining a copy
  7. of this software and associated documentation files (the "Software"), to deal
  8. in the Software without restriction, including without limitation the rights
  9. to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10. copies of the Software, and to permit persons to whom the Software is
  11. furnished to do so, subject to the following conditions:
  12. The above copyright notice and this permission notice shall be included in
  13. all copies or substantial portions of the Software.
  14. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17. AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18. LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19. OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20. THE SOFTWARE.
  21. $/LicenseInfo$
  22. """
  23. from indra.base import config
  24. from indra.base import llsd
  25. from webob import exc
  26. import webob
  27. import re, socket
  28. try:
  29.     from cStringIO import StringIO
  30. except ImportError:
  31.     from StringIO import StringIO
  32. try:
  33.     import cjson
  34.     json_decode = cjson.decode
  35.     json_encode = cjson.encode
  36.     JsonDecodeError = cjson.DecodeError
  37.     JsonEncodeError = cjson.EncodeError
  38. except ImportError:
  39.     import simplejson
  40.     json_decode = simplejson.loads
  41.     json_encode = simplejson.dumps
  42.     JsonDecodeError = ValueError
  43.     JsonEncodeError = TypeError
  44. llsd_parsers = {
  45.     'application/json': json_decode,
  46.     llsd.BINARY_MIME_TYPE: llsd.parse_binary,
  47.     'application/llsd+notation': llsd.parse_notation,
  48.     llsd.XML_MIME_TYPE: llsd.parse_xml,
  49.     'application/xml': llsd.parse_xml,
  50.     }
  51. def mime_type(content_type):
  52.     '''Given a Content-Type header, return only the MIME type.'''
  53.     return content_type.split(';', 1)[0].strip().lower()
  54.     
  55. class BodyLLSD(object):
  56.     '''Give a webob Request or Response an llsd based "content" property.
  57.     Getting the content property parses the body, and caches the result.
  58.     Setting the content property formats a payload, and the body property
  59.     is set.'''
  60.     def _llsd__get(self):
  61.         '''Get, set, or delete the LLSD value stored in this object.'''
  62.         try:
  63.             return self._llsd
  64.         except AttributeError:
  65.             if not self.body:
  66.                 raise AttributeError('No llsd attribute has been set')
  67.             else:
  68.                 mtype = mime_type(self.content_type)
  69.                 try:
  70.                     parser = llsd_parsers[mtype]
  71.                 except KeyError:
  72.                     raise exc.HTTPUnsupportedMediaType(
  73.                         'Content type %s not supported' % mtype).exception
  74.                 try:
  75.                     self._llsd = parser(self.body)
  76.                 except (llsd.LLSDParseError, JsonDecodeError, TypeError), err:
  77.                     raise exc.HTTPBadRequest(
  78.                         'Could not parse body: %r' % err.args).exception
  79.             return self._llsd
  80.     def _llsd__set(self, val):
  81.         req = getattr(self, 'request', None)
  82.         if req is not None:
  83.             formatter, ctype = formatter_for_request(req)
  84.             self.content_type = ctype
  85.         else:
  86.             formatter, ctype = formatter_for_mime_type(
  87.                 mime_type(self.content_type))
  88.         self.body = formatter(val)
  89.     def _llsd__del(self):
  90.         if hasattr(self, '_llsd'):
  91.             del self._llsd
  92.     content = property(_llsd__get, _llsd__set, _llsd__del)
  93. class Response(webob.Response, BodyLLSD):
  94.     '''Response class with LLSD support.
  95.     A sensible default content type is used.
  96.     Setting the llsd property also sets the body.  Getting the llsd
  97.     property parses the body if necessary.
  98.     If you set the body property directly, the llsd property will be
  99.     deleted.'''
  100.     default_content_type = 'application/llsd+xml'
  101.     def _body__set(self, body):
  102.         if hasattr(self, '_llsd'):
  103.             del self._llsd
  104.         super(Response, self)._body__set(body)
  105.     def cache_forever(self):
  106.         self.cache_expires(86400 * 365)
  107.     body = property(webob.Response._body__get, _body__set,
  108.                     webob.Response._body__del,
  109.                     webob.Response._body__get.__doc__)
  110. class Request(webob.Request, BodyLLSD):
  111.     '''Request class with LLSD support.
  112.     Sensible content type and accept headers are used by default.
  113.     Setting the content property also sets the body. Getting the content
  114.     property parses the body if necessary.
  115.     If you set the body property directly, the content property will be
  116.     deleted.'''
  117.     
  118.     default_content_type = 'application/llsd+xml'
  119.     default_accept = ('application/llsd+xml; q=0.5, '
  120.                       'application/llsd+notation; q=0.3, '
  121.                       'application/llsd+binary; q=0.2, '
  122.                       'application/xml; q=0.1, '
  123.                       'application/json; q=0.0')
  124.     def __init__(self, environ=None, *args, **kwargs):
  125.         if environ is None:
  126.             environ = {}
  127.         else:
  128.             environ = environ.copy()
  129.         if 'CONTENT_TYPE' not in environ:
  130.             environ['CONTENT_TYPE'] = self.default_content_type
  131.         if 'HTTP_ACCEPT' not in environ:
  132.             environ['HTTP_ACCEPT'] = self.default_accept
  133.         super(Request, self).__init__(environ, *args, **kwargs)
  134.     def _body__set(self, body):
  135.         if hasattr(self, '_llsd'):
  136.             del self._llsd
  137.         super(Request, self)._body__set(body)
  138.     def path_urljoin(self, *parts):
  139.         return '/'.join([path_url.rstrip('/')] + list(parts))
  140.     body = property(webob.Request._body__get, _body__set,
  141.                     webob.Request._body__del, webob.Request._body__get.__doc__)
  142.     def create_response(self, content=None, status='200 OK',
  143.                         conditional_response=webob.NoDefault):
  144.         resp = self.ResponseClass(status=status, request=self,
  145.                                   conditional_response=conditional_response)
  146.         resp.content = content
  147.         return resp
  148.     def curl(self):
  149.         '''Create and fill out a pycurl easy object from this request.'''
  150.  
  151.         import pycurl
  152.         c = pycurl.Curl()
  153.         c.setopt(pycurl.URL, self.url())
  154.         if self.headers:
  155.             c.setopt(pycurl.HTTPHEADER,
  156.                      ['%s: %s' % (k, self.headers[k]) for k in self.headers])
  157.         c.setopt(pycurl.FOLLOWLOCATION, True)
  158.         c.setopt(pycurl.AUTOREFERER, True)
  159.         c.setopt(pycurl.MAXREDIRS, 16)
  160.         c.setopt(pycurl.NOSIGNAL, True)
  161.         c.setopt(pycurl.READFUNCTION, self.body_file.read)
  162.         c.setopt(pycurl.SSL_VERIFYHOST, 2)
  163.         
  164.         if self.method == 'POST':
  165.             c.setopt(pycurl.POST, True)
  166.             post301 = getattr(pycurl, 'POST301', None)
  167.             if post301 is not None:
  168.                 # Added in libcurl 7.17.1.
  169.                 c.setopt(post301, True)
  170.         elif self.method == 'PUT':
  171.             c.setopt(pycurl.PUT, True)
  172.         elif self.method != 'GET':
  173.             c.setopt(pycurl.CUSTOMREQUEST, self.method)
  174.         return c
  175. Request.ResponseClass = Response
  176. Response.RequestClass = Request
  177. llsd_formatters = {
  178.     'application/json': json_encode,
  179.     'application/llsd+binary': llsd.format_binary,
  180.     'application/llsd+notation': llsd.format_notation,
  181.     'application/llsd+xml': llsd.format_xml,
  182.     'application/xml': llsd.format_xml,
  183.     }
  184. formatter_qualities = (
  185.     ('application/llsd+xml', 1.0),
  186.     ('application/llsd+notation', 0.5),
  187.     ('application/llsd+binary', 0.4),
  188.     ('application/xml', 0.3),
  189.     ('application/json', 0.2),
  190.     )
  191. def formatter_for_mime_type(mime_type):
  192.     '''Return a formatter that encodes to the given MIME type.
  193.     The result is a pair of function and MIME type.'''
  194.     try:
  195.         return llsd_formatters[mime_type], mime_type
  196.     except KeyError:
  197.         raise exc.HTTPInternalServerError(
  198.             'Could not use MIME type %r to format response' %
  199.             mime_type).exception
  200. def formatter_for_request(req):
  201.     '''Return a formatter that encodes to the preferred type of the client.
  202.     The result is a pair of function and actual MIME type.'''
  203.     ctype = req.accept.best_match(formatter_qualities)
  204.     try:
  205.         return llsd_formatters[ctype], ctype
  206.     except KeyError:
  207.         raise exc.HTTPNotAcceptable().exception
  208. def wsgi_adapter(func, environ, start_response):
  209.     '''Adapt a Siesta callable to act as a WSGI application.'''
  210.     # Process the request as appropriate.
  211.     try:
  212.         req = Request(environ)
  213.         #print req.urlvars
  214.         resp = func(req, **req.urlvars)
  215.         if not isinstance(resp, webob.Response):
  216.             try:
  217.                 formatter, ctype = formatter_for_request(req)
  218.                 resp = req.ResponseClass(formatter(resp), content_type=ctype)
  219.                 resp._llsd = resp
  220.             except (JsonEncodeError, TypeError), err:
  221.                 resp = exc.HTTPInternalServerError(
  222.                     detail='Could not format response')
  223.     except exc.HTTPException, e:
  224.         resp = e
  225.     except socket.error, e:
  226.         resp = exc.HTTPInternalServerError(detail=e.args[1])
  227.     return resp(environ, start_response)
  228. def llsd_callable(func):
  229.     '''Turn a callable into a Siesta application.'''
  230.     def replacement(environ, start_response):
  231.         return wsgi_adapter(func, environ, start_response)
  232.     return replacement
  233. def llsd_method(http_method, func):
  234.     def replacement(environ, start_response):
  235.         if environ['REQUEST_METHOD'] == http_method:
  236.             return wsgi_adapter(func, environ, start_response)
  237.         return exc.HTTPMethodNotAllowed()(environ, start_response)
  238.     return replacement
  239. http11_methods = 'OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT'.split()
  240. http11_methods.sort()
  241. def llsd_class(cls):
  242.     '''Turn a class into a Siesta application.
  243.     A new instance is created for each request.  A HTTP method FOO is
  244.     turned into a call to the handle_foo method of the instance.'''
  245.     def foo(req, **kwargs):
  246.         instance = cls()
  247.         method = req.method.lower()
  248.         try:
  249.             handler = getattr(instance, 'handle_' + method)
  250.         except AttributeError:
  251.             allowed = [m for m in http11_methods
  252.                        if hasattr(instance, 'handle_' + m.lower())]
  253.             raise exc.HTTPMethodNotAllowed(
  254.                 headers={'Allow': ', '.join(allowed)}).exception
  255.         #print "kwargs: ", kwargs
  256.         return handler(req, **kwargs)
  257.     def replacement(environ, start_response):
  258.         return wsgi_adapter(foo, environ, start_response)
  259.     return replacement
  260. def curl(reqs):
  261.     import pycurl
  262.     m = pycurl.CurlMulti()
  263.     curls = [r.curl() for r in reqs]
  264.     io = {}
  265.     for c in curls:
  266.         fp = StringIO()
  267.         hdr = StringIO()
  268.         c.setopt(pycurl.WRITEFUNCTION, fp.write)
  269.         c.setopt(pycurl.HEADERFUNCTION, hdr.write)
  270.         io[id(c)] = fp, hdr
  271.     m.handles = curls
  272.     try:
  273.         while True:
  274.             ret, num_handles = m.perform()
  275.             if ret != pycurl.E_CALL_MULTI_PERFORM:
  276.                 break
  277.     finally:
  278.         m.close()
  279.     for req, c in zip(reqs, curls):
  280.         fp, hdr = io[id(c)]
  281.         hdr.seek(0)
  282.         status = hdr.readline().rstrip()
  283.         headers = []
  284.         name, values = None, None
  285.         # XXX We don't currently handle bogus header data.
  286.         for line in hdr.readlines():
  287.             if not line[0].isspace():
  288.                 if name:
  289.                     headers.append((name, ' '.join(values)))
  290.                 name, value = line.strip().split(':', 1)
  291.                 value = [value]
  292.             else:
  293.                 values.append(line.strip())
  294.         if name:
  295.             headers.append((name, ' '.join(values)))
  296.         resp = c.ResponseClass(fp.getvalue(), status, headers, request=req)
  297. route_re = re.compile(r'''
  298.     {                 # exact character "{"
  299.     (w*)              # "config" or variable (restricted to a-z, 0-9, _)
  300.     (?:([:~])([^}]+))? # optional :type or ~regex part
  301.     }                 # exact character "}"
  302.     ''', re.VERBOSE)
  303. predefined_regexps = {
  304.     'uuid': r'[a-f0-9][a-f0-9-]{31,35}',
  305.     'int': r'd+',
  306.     'host': r'[a-z0-9][a-z0-9-.]*',
  307.     }
  308. def compile_route(route):
  309.     fp = StringIO()
  310.     last_pos = 0
  311.     for match in route_re.finditer(route):
  312.         #print "matches: ", match.groups()
  313.         fp.write(re.escape(route[last_pos:match.start()]))
  314.         var_name = match.group(1)
  315.         sep = match.group(2)
  316.         expr = match.group(3)
  317.         if var_name == 'config':
  318.             expr = re.escape(str(config.get(var_name)))
  319.         else:
  320.             if expr:
  321.                 if sep == ':':
  322.                     expr = predefined_regexps[expr]
  323.                 # otherwise, treat what follows '~' as a regexp
  324.             else:
  325.                 expr = '[^/]+'
  326.             if var_name != '':
  327.                 expr = '(?P<%s>%s)' % (var_name, expr)
  328.             else:
  329.                 expr = '(%s)' % (expr,)
  330.         fp.write(expr)
  331.         last_pos = match.end()
  332.     fp.write(re.escape(route[last_pos:]))
  333.     compiled_route = '^%s$' % fp.getvalue()
  334.     #print route, "->", compiled_route
  335.     return compiled_route
  336. class Router(object):
  337.     '''WSGI routing class.  Parses a URL and hands off a request to
  338.     some other WSGI application.  If no suitable application is found,
  339.     responds with a 404.'''
  340.     def __init__(self):
  341.         self._new_routes = []
  342.         self._routes = []
  343.         self._paths = []
  344.     def add(self, route, app, methods=None):
  345.         self._new_routes.append((route, app, methods))
  346.     def _create_routes(self):
  347.         for route, app, methods in self._new_routes:
  348.             self._paths.append(route)
  349.             self._routes.append(
  350.                 (re.compile(compile_route(route)),
  351.                  app,
  352.                  methods and dict.fromkeys(methods)))
  353.         self._new_routes = []
  354.     def __call__(self, environ, start_response):
  355.         # load up the config from the config file. Only needs to be
  356.         # done once per interpreter. This is the entry point of all
  357.         # siesta applications, so this is where we trap it.
  358.         _conf = config.get_config()
  359.         if _conf is None:
  360.             import os.path
  361.             fname = os.path.join(
  362.                 environ.get('ll.config_dir', '/local/linden/etc'),
  363.                 'indra.xml')
  364.             config.load(fname)
  365.         # proceed with handling the request
  366.         self._create_routes()
  367.         path_info = environ['PATH_INFO']
  368.         request_method = environ['REQUEST_METHOD']
  369.         allowed = []
  370.         for regex, app, methods in self._routes:
  371.             m = regex.match(path_info)
  372.             if m:
  373.                 #print "groupdict:",m.groupdict()
  374.                 if not methods or request_method in methods:
  375.                     environ['paste.urlvars'] = m.groupdict()
  376.                     return app(environ, start_response)
  377.                 else:
  378.                     allowed += methods
  379.         if allowed:
  380.             allowed = dict.fromkeys(allows).keys()
  381.             allowed.sort()
  382.             resp = exc.HTTPMethodNotAllowed(
  383.                 headers={'Allow': ', '.join(allowed)})
  384.         else:
  385.             resp = exc.HTTPNotFound()
  386.         return resp(environ, start_response)