home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_701 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.9 KB  |  329 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import xmlrpclib
  5. from xmlrpclib import Fault
  6. import SocketServer
  7. import BaseHTTPServer
  8. import sys
  9. import os
  10. import traceback
  11.  
  12. try:
  13.     import fcntl
  14. except ImportError:
  15.     fcntl = None
  16.  
  17.  
  18. def resolve_dotted_attribute(obj, attr, allow_dotted_names = True):
  19.     if allow_dotted_names:
  20.         attrs = attr.split('.')
  21.     else:
  22.         attrs = [
  23.             attr]
  24.     for i in attrs:
  25.         if i.startswith('_'):
  26.             raise AttributeError('attempt to access private attribute "%s"' % i)
  27.         i.startswith('_')
  28.         obj = getattr(obj, i)
  29.     
  30.     return obj
  31.  
  32.  
  33. def list_public_methods(obj):
  34.     return _[1]
  35.  
  36.  
  37. def remove_duplicates(lst):
  38.     u = { }
  39.     for x in lst:
  40.         u[x] = 1
  41.     
  42.     return u.keys()
  43.  
  44.  
  45. class SimpleXMLRPCDispatcher:
  46.     
  47.     def __init__(self, allow_none = False, encoding = None):
  48.         self.funcs = { }
  49.         self.instance = None
  50.         self.allow_none = allow_none
  51.         self.encoding = encoding
  52.  
  53.     
  54.     def register_instance(self, instance, allow_dotted_names = False):
  55.         self.instance = instance
  56.         self.allow_dotted_names = allow_dotted_names
  57.  
  58.     
  59.     def register_function(self, function, name = None):
  60.         if name is None:
  61.             name = function.__name__
  62.         
  63.         self.funcs[name] = function
  64.  
  65.     
  66.     def register_introspection_functions(self):
  67.         self.funcs.update({
  68.             'system.listMethods': self.system_listMethods,
  69.             'system.methodSignature': self.system_methodSignature,
  70.             'system.methodHelp': self.system_methodHelp })
  71.  
  72.     
  73.     def register_multicall_functions(self):
  74.         self.funcs.update({
  75.             'system.multicall': self.system_multicall })
  76.  
  77.     
  78.     def _marshaled_dispatch(self, data, dispatch_method = None):
  79.         
  80.         try:
  81.             (params, method) = xmlrpclib.loads(data)
  82.             if dispatch_method is not None:
  83.                 response = dispatch_method(method, params)
  84.             else:
  85.                 response = self._dispatch(method, params)
  86.             response = (response,)
  87.             response = xmlrpclib.dumps(response, methodresponse = 1, allow_none = self.allow_none, encoding = self.encoding)
  88.         except Fault:
  89.             fault = None
  90.             response = xmlrpclib.dumps(fault, allow_none = self.allow_none, encoding = self.encoding)
  91.         except:
  92.             (exc_type, exc_value, exc_tb) = sys.exc_info()
  93.             response = xmlrpclib.dumps(xmlrpclib.Fault(1, '%s:%s' % (exc_type, exc_value)), encoding = self.encoding, allow_none = self.allow_none)
  94.  
  95.         return response
  96.  
  97.     
  98.     def system_listMethods(self):
  99.         methods = self.funcs.keys()
  100.         if self.instance is not None:
  101.             if hasattr(self.instance, '_listMethods'):
  102.                 methods = remove_duplicates(methods + self.instance._listMethods())
  103.             elif not hasattr(self.instance, '_dispatch'):
  104.                 methods = remove_duplicates(methods + list_public_methods(self.instance))
  105.             
  106.         
  107.         methods.sort()
  108.         return methods
  109.  
  110.     
  111.     def system_methodSignature(self, method_name):
  112.         return 'signatures not supported'
  113.  
  114.     
  115.     def system_methodHelp(self, method_name):
  116.         method = None
  117.         if method_name in self.funcs:
  118.             method = self.funcs[method_name]
  119.         elif self.instance is not None:
  120.             if hasattr(self.instance, '_methodHelp'):
  121.                 return self.instance._methodHelp(method_name)
  122.             if not hasattr(self.instance, '_dispatch'):
  123.                 
  124.                 try:
  125.                     method = resolve_dotted_attribute(self.instance, method_name, self.allow_dotted_names)
  126.                 except AttributeError:
  127.                     hasattr(self.instance, '_methodHelp')
  128.                     hasattr(self.instance, '_methodHelp')
  129.                 except:
  130.                     hasattr(self.instance, '_methodHelp')<EXCEPTION MATCH>AttributeError
  131.                 
  132.  
  133.             hasattr(self.instance, '_methodHelp')<EXCEPTION MATCH>AttributeError
  134.         
  135.         if method is None:
  136.             return ''
  137.         import pydoc
  138.         return pydoc.getdoc(method)
  139.  
  140.     
  141.     def system_multicall(self, call_list):
  142.         results = []
  143.         for call in call_list:
  144.             method_name = call['methodName']
  145.             params = call['params']
  146.             
  147.             try:
  148.                 results.append([
  149.                     self._dispatch(method_name, params)])
  150.             continue
  151.             except Fault:
  152.                 fault = None
  153.                 results.append({
  154.                     'faultCode': fault.faultCode,
  155.                     'faultString': fault.faultString })
  156.                 continue
  157.                 (exc_type, exc_value, exc_tb) = sys.exc_info()
  158.                 results.append({
  159.                     'faultCode': 1,
  160.                     'faultString': '%s:%s' % (exc_type, exc_value) })
  161.                 continue
  162.             
  163.  
  164.         
  165.         return results
  166.  
  167.     
  168.     def _dispatch(self, method, params):
  169.         func = None
  170.         
  171.         try:
  172.             func = self.funcs[method]
  173.         except KeyError:
  174.             if self.instance is not None:
  175.                 if hasattr(self.instance, '_dispatch'):
  176.                     return self.instance._dispatch(method, params)
  177.                 
  178.                 try:
  179.                     func = resolve_dotted_attribute(self.instance, method, self.allow_dotted_names)
  180.                 except AttributeError:
  181.                     hasattr(self.instance, '_dispatch')
  182.                     hasattr(self.instance, '_dispatch')
  183.                 except:
  184.                     hasattr(self.instance, '_dispatch')<EXCEPTION MATCH>AttributeError
  185.                 
  186.  
  187.             hasattr(self.instance, '_dispatch')<EXCEPTION MATCH>AttributeError
  188.         except:
  189.             hasattr(self.instance, '_dispatch')
  190.  
  191.         if func is not None:
  192.             return func(*params)
  193.         raise Exception('method "%s" is not supported' % method)
  194.  
  195.  
  196.  
  197. class SimpleXMLRPCRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
  198.     rpc_paths = ('/', '/RPC2')
  199.     
  200.     def is_rpc_path_valid(self):
  201.         if self.rpc_paths:
  202.             return self.path in self.rpc_paths
  203.         return True
  204.  
  205.     
  206.     def do_POST(self):
  207.         if not self.is_rpc_path_valid():
  208.             self.report_404()
  209.             return None
  210.         
  211.         try:
  212.             max_chunk_size = 10485760
  213.             size_remaining = int(self.headers['content-length'])
  214.             L = []
  215.             while size_remaining:
  216.                 chunk_size = min(size_remaining, max_chunk_size)
  217.                 L.append(self.rfile.read(chunk_size))
  218.                 size_remaining -= len(L[-1])
  219.                 continue
  220.                 self.is_rpc_path_valid()
  221.             data = ''.join(L)
  222.             response = self.server._marshaled_dispatch(data, getattr(self, '_dispatch', None))
  223.         except Exception:
  224.             self.is_rpc_path_valid()
  225.             e = self.is_rpc_path_valid()
  226.             self.send_response(500)
  227.             if hasattr(self.server, '_send_traceback_header') and self.server._send_traceback_header:
  228.                 self.send_header('X-exception', str(e))
  229.                 self.send_header('X-traceback', traceback.format_exc())
  230.             
  231.             self.end_headers()
  232.         except:
  233.             self.is_rpc_path_valid()
  234.  
  235.         self.send_response(200)
  236.         self.send_header('Content-type', 'text/xml')
  237.         self.send_header('Content-length', str(len(response)))
  238.         self.end_headers()
  239.         self.wfile.write(response)
  240.         self.wfile.flush()
  241.         self.connection.shutdown(1)
  242.  
  243.     
  244.     def report_404(self):
  245.         self.send_response(404)
  246.         response = 'No such page'
  247.         self.send_header('Content-type', 'text/plain')
  248.         self.send_header('Content-length', str(len(response)))
  249.         self.end_headers()
  250.         self.wfile.write(response)
  251.         self.wfile.flush()
  252.         self.connection.shutdown(1)
  253.  
  254.     
  255.     def log_request(self, code = '-', size = '-'):
  256.         if self.server.logRequests:
  257.             BaseHTTPServer.BaseHTTPRequestHandler.log_request(self, code, size)
  258.         
  259.  
  260.  
  261.  
  262. class SimpleXMLRPCServer(SocketServer.TCPServer, SimpleXMLRPCDispatcher):
  263.     allow_reuse_address = True
  264.     _send_traceback_header = False
  265.     
  266.     def __init__(self, addr, requestHandler = SimpleXMLRPCRequestHandler, logRequests = True, allow_none = False, encoding = None, bind_and_activate = True):
  267.         self.logRequests = logRequests
  268.         SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
  269.         SocketServer.TCPServer.__init__(self, addr, requestHandler, bind_and_activate)
  270.         if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
  271.             flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
  272.             flags |= fcntl.FD_CLOEXEC
  273.             fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
  274.         
  275.  
  276.  
  277.  
  278. class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
  279.     
  280.     def __init__(self, allow_none = False, encoding = None):
  281.         SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
  282.  
  283.     
  284.     def handle_xmlrpc(self, request_text):
  285.         response = self._marshaled_dispatch(request_text)
  286.         print 'Content-Type: text/xml'
  287.         print 'Content-Length: %d' % len(response)
  288.         print 
  289.         sys.stdout.write(response)
  290.  
  291.     
  292.     def handle_get(self):
  293.         code = 400
  294.         (message, explain) = BaseHTTPServer.BaseHTTPRequestHandler.responses[code]
  295.         response = BaseHTTPServer.DEFAULT_ERROR_MESSAGE % {
  296.             'code': code,
  297.             'message': message,
  298.             'explain': explain }
  299.         print 'Status: %d %s' % (code, message)
  300.         print 'Content-Type: text/html'
  301.         print 'Content-Length: %d' % len(response)
  302.         print 
  303.         sys.stdout.write(response)
  304.  
  305.     
  306.     def handle_request(self, request_text = None):
  307.         if request_text is None and os.environ.get('REQUEST_METHOD', None) == 'GET':
  308.             self.handle_get()
  309.         else:
  310.             
  311.             try:
  312.                 length = int(os.environ.get('CONTENT_LENGTH', None))
  313.             except (TypeError, ValueError):
  314.                 length = -1
  315.  
  316.             if request_text is None:
  317.                 request_text = sys.stdin.read(length)
  318.             
  319.             self.handle_xmlrpc(request_text)
  320.  
  321.  
  322. if __name__ == '__main__':
  323.     print 'Running XML-RPC server on port 8000'
  324.     server = SimpleXMLRPCServer(('localhost', 8000))
  325.     server.register_function(pow)
  326.     server.register_function((lambda x, y: x + y), 'add')
  327.     server.serve_forever()
  328.  
  329.