Download Install Tutorial Docs FAQ Tools Wiki ∇ License Team IRC Planet Involvement Shop Book

Changeset 908

Show
Ignore:
Timestamp:
01/02/06 02:29:42
Author:
fumanchu
Message:

First crack at multiapp CP:

  1. The biggest casualty: cherrypy.root is gone; it's now cherrypy.app.root. But cherrypy.root = Root() is now cherrypy.new(root=Root()), which creates a new app, selects it, and binds the root object to it all in one step.
  2. cherrypy.app is a new threadlocalproxy (like request and response) that points to the current thread's serving.app. Set serving.app by calling cherrypy.new, cherrypy.use(app), or cherrypy.dispatch(path). This must be done in main threads as well as HTTP-request threads.
  3. Each serving.app is an instance of cherrypy.Application, and has its own config attribute. These config attributes generally replace cherrypy.config.configs (or the old name, "configMap"). In addition, a few of the config entries (like socket.port, etc) have been split out into a new cherrypy.config.serverconf dict, which isn't path-specific.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/multiapp/cherrypy/__init__.py

    r887 r908  
    44 
    55import datetime 
     6import os 
    67import sys 
    78import types 
    …… 
    1920    from cherrypy._cpthreadinglocal import local 
    2021 
    21 # Create a threadlocal object to hold the request and response 
    22 # objects. In this way, we can easily dump those objects when 
     22# Create a threadlocal object to hold the app, request and response 
     23# references. In this way, we can easily dump those objects when 
    2324# we stop/start a new HTTP conversation, yet still refer to 
    2425# them as module-level globals in a thread-safe way. 
    25 serving = local() 
     26class _Serving(local): 
     27     
     28    def __init__(self): 
     29        # Called each time the local object is used in a separate thread. 
     30        # When those threads are HTTP conversation threads, the 
     31        # cherrypy.server object will re-assign these attributes asap. 
     32        # When the local thread is a main thread (not part of an HTTP 
     33        # request), only self.app should be re-assigned. Call 
     34        # cherrypy.use(app) to set it more easily in app code. 
     35        self.app = None 
     36        self.request = None 
     37        self.response = None 
     38 
     39serving = _Serving() 
     40 
     41 
     42class Application(object): 
     43     
     44    def __init__(self, root=None): 
     45        self.root = root 
     46        self.config = { 
     47            'global': { 
     48                'server.environment': "development", 
     49            }, 
     50            '/favicon.ico': { 
     51                'static_filter.on': True, 
     52                'static_filter.file': os.path.join(os.path.dirname(__file__), 
     53                                                   "favicon.ico"), 
     54            }, 
     55        } 
     56     
     57    def mount_point(self): 
     58        return self.config["global"].get("http.mount_point", "/") 
     59     
     60    def dispatch_path(self, mounted_path): 
     61        path = mounted_path[len(self.mount_point()):] 
     62        if not path.startswith("/"): 
     63            path = "/" + path 
     64        return path 
     65 
     66 
     67apps = [] 
     68 
     69def use(app): 
     70    """Use the given Application object in the current thread.""" 
     71    serving.app = app 
     72    if app not in apps: 
     73        apps.append(app) 
     74 
     75def new(root=None): 
     76    """Return a new Application object and use it in the current thread.""" 
     77    app = Application(root) 
     78    use(app) 
     79    return app 
     80 
     81def dispatch(path): 
     82    """Return and use() an Application object based on the given path.""" 
     83    matches = [] 
     84    for app in apps: 
     85        mount = app.mount_point() 
     86        if path.startswith(mount): 
     87            matches.append((mount, app)) 
     88     
     89    if not matches: 
     90        raise NotFound(path) 
     91     
     92    # Use the longest matching mount point 
     93    matches.sort() 
     94    mount, app = matches[-1] 
     95     
     96    use(app) 
     97    return app 
     98 
    2699 
    27100class _ThreadLocalProxy: 
    …… 
    42115        delattr(childobject, name) 
    43116 
    44 # Create request and response object (the same objects will be used 
     117# Create app, request and response object (the same objects will be used 
    45118#   throughout the entire life of the webserver, but will redirect 
    46119#   to the "serving" object) 
     120app = _ThreadLocalProxy('app') 
    47121request = _ThreadLocalProxy('request') 
    48122response = _ThreadLocalProxy('response') 

  • branches/multiapp/cherrypy/_cphttpserver.py

    r887 r908  
    2020    def address_string(self): 
    2121        """ Try to do a reverse DNS based on server.reverse_dns in the config file """ 
    22         if cherrypy.config.get('server.reverse_dns'): 
     22        if cherrypy.config.serverconf.get('server.reverse_dns'): 
    2323            return BaseHTTPRequestHandler.address_string(self) 
    2424        else: 
    …… 
    4242     
    4343    def parse_request(self): 
     44        conf = cherrypy.config.serverconf.get 
    4445        # Extended to provide header and body length limits. 
    45         mhs = int(cherrypy.config.get('server.max_request_header_size', 
    46                                       500 * 1024)) 
     46        mhs = int(conf('server.max_request_header_size', 500 * 1024)) 
    4747        self.rfile = httptools.SizeCheckWrapper(self.rfile, mhs) 
    4848        try: 
    …… 
    6060                if path == "*": 
    6161                    path = "global" 
    62                 mbs = int(cherrypy.config.get('server.max_request_body_size', 
    63                                               100 * 1024 * 1024, path=path)) 
     62                mbs = int(conf('server.max_request_body_size', 100 * 1024 * 1024)) 
    6463                self.rfile.maxlen = mbs 
    6564        return presult 
    …… 
    6766    def handle_one_request(self): 
    6867        """Handle a single HTTP request.""" 
     68        conf = cherrypy.config.serverconf.get 
    6969         
    7070        self.raw_requestline = self.rfile.readline() 
    …… 
    7979            request = cherrypy.server.request(self.client_address, 
    8080                                              self.address_string(), "http") 
    81             request.multithread = cherrypy.config.get("server.thread_pool") > 1 
     81            request.multithread = conf("server.thread_pool") > 1 
    8282            request.multiprocess = False 
    8383            response = request.run(self.raw_requestline, self._headerlist(), 
    …… 
    8888            raise 
    8989        except: 
    90             tb = _cputil.formatExc() 
    91             cherrypy.log(tb) 
    92             if cherrypy.config.get("server.throw_errors", False): 
     90            cherrypy.log(traceback=True) 
     91            if conf("server.throw_errors", False): 
    9392                msg = "THROWN ERROR: %s" % sys.exc_info()[0].__name__ 
    9493                s = "500 Internal Server Error" 
    …… 
    9796                b = [msg] 
    9897            else: 
    99                 if not cherrypy.config.get("server.show_tracebacks", False): 
    100                     tb = "" 
    101                 s, h, b = _cputil.bareError(tb) 
     98                s, h, b = _cputil.bareError() 
    10299         
    103100        try: 
    …… 
    181178        # but we have to in order to implement SSL and IPv6 support! 
    182179         
     180        conf = cherrypy.config.serverconf.get 
     181         
    183182        # Set protocol_version 
    184         httpproto = cherrypy.config.get('server.protocol_version') or "HTTP/1.0" 
     183        httpproto = conf('server.protocol_version') or "HTTP/1.0" 
    185184        self.RequestHandlerClass.protocol_version = httpproto 
    186185         
    187         self.request_queue_size = cherrypy.config.get('server.socket_queue_size') 
     186        self.request_queue_size = conf('server.socket_queue_size') 
    188187         
    189188        # Select the appropriate server based on config options 
    190         sockFile = cherrypy.config.get('server.socket_file') 
     189        sockFile = conf('server.socket_file') 
    191190        if sockFile: 
    192191            # AF_UNIX socket 
    …… 
    206205        else: 
    207206            # AF_INET or AF_INET6 socket 
    208             host = cherrypy.config.get('server.socket_host') 
    209             port = cherrypy.config.get('server.socket_port') 
     207            host = conf('server.socket_host') 
     208            port = conf('server.socket_port') 
    210209            self.server_address = (host, port) 
    211210             
    …… 
    314313     
    315314    def __init__(self): 
    316         self.numThreads = cherrypy.config.get('server.thread_pool') 
     315        self.numThreads = cherrypy.config.serverconf.get('server.thread_pool') 
    317316        self.ThreadClass = ServerThread 
    318317        self.requestQueue = Queue.Queue() 
    …… 
    399398     
    400399    # Select the appropriate server based on config options 
    401     if cherrypy.config.get('server.thread_pool', 1) > 1: 
     400    if cherrypy.config.serverconf.get('server.thread_pool', 1) > 1: 
    402401        ServerClass = PooledThreadServer 
    403402    else: 

  • branches/multiapp/cherrypy/_cphttptools.py

    r904 r908  
    99from cherrypy import _cputil, _cpcgifs 
    1010from cherrypy.filters import applyFilters 
    11 from cherrypy.lib import cptools, httptools 
     11from cherrypy.lib import cptools, httptools, profiler 
    1212 
    1313 
    …… 
    6565        self.simpleCookie = Cookie.SimpleCookie() 
    6666         
    67         if cherrypy.profiler: 
    68             cherrypy.profiler.run(self._run) 
     67        # Set up the profiler if requested. 
     68        if cherrypy.config.serverconf.get("profiling.on", False): 
     69            ppath = cherrypy.config.serverconf.get("profiling.path", "") 
     70            profiler.Profiler(ppath).run(self._run) 
    6971        else: 
    7072            self._run() 
    …… 
    122124            raise 
    123125        except: 
    124             if cherrypy.config.get("server.throw_errors", False): 
     126            if cherrypy.config.serverconf.get("server.throw_errors", False): 
    125127                raise 
    126128            cherrypy.response.handleError(sys.exc_info()) 
    …… 
    129131        rl = self.requestLine 
    130132        method, path, qs, proto = httptools.parseRequestLine(rl) 
    131         if path == "*": 
    132             path = "global" 
    133133         
    134134        self.method = method 
    …… 
    141141        # Change object_path in filters to change 
    142142        # the object that will get rendered 
    143         self.object_path = path 
     143        cherrypy.dispatch(path) 
     144        self.object_path = cherrypy.app.dispatch_path(path) 
    144145         
    145146        # Compare request and server HTTP versions, in case our server does 
    …… 
    159160        # cherrypy.request.version == request.protocol in a Version instance. 
    160161        self.version = httptools.Version.from_http(self.protocol) 
    161         server_v = cherrypy.config.get("server.protocol_version", "HTTP/1.0") 
     162        server_v = cherrypy.config.serverconf.get("server.protocol_version", "HTTP/1.0") 
    162163        server_v = httptools.Version.from_http(server_v) 
    163164         
    …… 
    372373        self.headers = httptools.HeaderMap() 
    373374        self.headerMap = self.headers # Backward compatibility 
    374         content_type = cherrypy.config.get('server.default_content_type', 'text/html') 
     375        content_type = cherrypy.config.serverconf.get('server.default_content_type', 
     376                                                      'text/html') 
    375377        self.headers.update({ 
    376378            "Content-Type": content_type, 

  • branches/multiapp/cherrypy/_cpserver.py

    r905 r908  
    99import cherrypy 
    1010from cherrypy import _cphttptools, filters 
    11 from cherrypy.lib import autoreload, profiler, cptools 
     11from cherrypy.lib import autoreload, cptools 
    1212 
    1313# Use a flag to indicate the state of the application server. 
    …… 
    5252        self.interrupt = None 
    5353         
    54         conf = cherrypy.config.get 
     54        conf = cherrypy.config.serverconf.get 
    5555         
    5656        if serverClass is _missing: 
    …… 
    9393     
    9494    def _start(self): 
     95        conf = cherrypy.config.serverconf.get 
    9596        # Output config options to log 
    96         if cherrypy.config.get("server.log_config_options", True): 
     97        if conf("server.log_config_options", True): 
    9798            cherrypy.config.outputConfigMap() 
    9899         
    99100        try: 
    100             configure() 
     101            if cherrypy.codecoverage: 
     102                from cherrypy.lib import covercp 
     103                covercp.start() 
     104             
     105            # set cgi.maxlen which will limit the size of POST request bodies 
     106            cgi.maxlen = conf('server.max_request_size') 
     107             
     108            # Initialize the built in filters 
     109            filters.init() 
    101110             
    102111            for func in cherrypy.server.on_start_server_list + cherrypy.server.onStartServerList: 
    …… 
    134143            return 
    135144         
    136         if cherrypy.config.get('server.socket_port'): 
    137             host = cherrypy.config.get('server.socket_host') 
    138             port = cherrypy.config.get('server.socket_port') 
     145        conf = cherrypy.config.serverconf.get 
     146        if conf('server.socket_port'): 
     147            host = conf('server.socket_host') 
     148            port = conf('server.socket_port') 
    139149             
    140150            wait_for_free_port(host, port) 
    …… 
    144154            on_what = "http://%s:%s/" % (host, port) 
    145155        else: 
    146             on_what = "socket file: %s" % cherrypy.config.get('server.socket_file') 
     156            on_what = "socket file: %s" % conf('server.socket_file') 
    147157         
    148158        # Instantiate the server. 
    …… 
    171181             
    172182            # Wait for port to be occupied 
    173             if cherrypy.config.get('server.socket_port'): 
    174                 host = cherrypy.config.get('server.socket_host') 
    175                 port = cherrypy.config.get('server.socket_port') 
     183            conf = cherrypy.config.serverconf.get 
     184            if conf('server.socket_port'): 
     185                host = conf('server.socket_host') 
     186                port = conf('server.socket_port') 
    176187                wait_for_occupied_port(host, port) 
    177188     
    …… 
    276287def check_config(): 
    277288    err = cherrypy.WrongConfigValue 
    278     for name, section in cherrypy.config.configs.iteritems(): 
    279         for k, v in section.iteritems(): 
    280             if k == "server.environment": 
    281                 if v and v not in cherrypy.config.environments: 
    282                     raise err("'%s' is not a registered environment." % v) 
    283  
    284  
    285 def configure(): 
    286     """Perform one-time actions to prepare the CherryPy core.""" 
    287     if cherrypy.codecoverage: 
    288         from cherrypy.lib import covercp 
    289         covercp.start() 
    290      
    291     conf = cherrypy.config.get 
    292     # TODO: config.checkConfigOptions() 
    293      
    294     # If sessions are stored in files and we 
    295     # use threading, we need a lock on the file 
    296     if (conf('server.thread_pool') > 1 
    297         and conf('session.storage_type') == 'file'): 
    298         cherrypy._sessionFileLock = threading.RLock() 
    299      
    300     # set cgi.maxlen which will limit the size of POST request bodies 
    301     cgi.maxlen = conf('server.max_request_size') 
    302      
    303     # Set up the profiler if requested. 
    304     if conf("profiling.on", False): 
    305         ppath = conf("profiling.path", "") 
    306         cherrypy.profiler = profiler.Profiler(ppath) 
    307     else: 
    308         cherrypy.profiler = None 
    309      
    310     # Initialize the built in filters 
    311     filters.init() 
     289    for app in cherrypy.apps: 
     290        for name, section in app.config.iteritems(): 
     291            for k, v in section.iteritems(): 
     292                if k == "server.environment": 
     293                    if v and v not in cherrypy.config.environments: 
     294                        raise err("'%s' is not a registered environment." % v) 
    312295 
    313296 
    314297def check_port(host, port): 
    315298    """Raise an error if the given port is not free on the given host.""" 
    316     sock_file = cherrypy.config.get('server.socket_file') 
     299    sock_file = cherrypy.config.serverconf.get('server.socket_file') 
    317300    if sock_file: 
    318301        return 

  • branches/multiapp/cherrypy/_cputil.py

    r901 r908  
    3333    if nameList == ['global']: 
    3434        # Special-case a Request-URI of * to allow for our default handler. 
    35         root = getattr(cherrypy, 'root', None) 
     35        root = getattr(cherrypy.app, 'root', None) 
    3636        if root is None: 
    3737            return [('root', None), ('global_', None), ('index', None)] 
    3838        gh = getattr(root, 'global_', _cpGlobalHandler) 
    39         return [('root', cherrypy.root), ('global_', gh), ('index', None)] 
     39        return [('root', cherrypy.app.root), ('global_', gh), ('index', None)] 
    4040     
    4141    nameList = ['root'] + nameList + ['index'] 
    4242     
    4343    # Convert the list of names into a list of objects 
    44     node = cherrypy 
     44    node = cherrypy.app 
    4545    objectTrail = [] 
    4646    for name in nameList: 
    …… 
    117117                } 
    118118     
    119     if cherrypy.config.get('server.log_to_screen', True): 
     119    if cherrypy.config.serverconf.get('server.log_to_screen', True): 
    120120        print s 
    121121     
    122     fname = cherrypy.config.get('server.log_access_file', '') 
     122    fname = cherrypy.config.serverconf.get('server.log_access_file', '') 
    123123    if fname: 
    124124        f = open(fname, 'ab') 
    …… 
    140140    s = ' '.join((logtime(), context, level, msg)) 
    141141     
    142     if cherrypy.config.get('server.log_to_screen', True): 
     142    if cherrypy.config.serverconf.get('server.log_to_screen', True): 
    143143        print s 
    144144     
    145     fname = cherrypy.config.get('server.log_file', '') 
     145    fname = cherrypy.config.serverconf.get('server.log_file', '') 
    146146    #logdir = os.path.dirname(fname) 
    147147    #if logdir and not os.path.exists(logdir): 
    …… 
    232232    logmsg = "" 
    233233     
    234     if cherrypy.config.get('server.log_tracebacks', True): 
     234    if cherrypy.config.serverconf.get('server.log_tracebacks', True): 
    235235        logmsg = tb 
    236     if cherrypy.config.get('server.log_request_headers', True): 
     236    if cherrypy.config.serverconf.get('server.log_request_headers', True): 
    237237        h = ["  %s: %s" % (k, v) for k, v in cherrypy.request.header_list] 
    238238        logmsg += 'Request Headers:\n' + '\n'.join(h) 
    …… 
    352352    """ Default _cp_on_error method """ 
    353353    # Allow logging of only *unexpected* HTTPError's. 
    354     if (not cherrypy.config.get('server.log_tracebacks', True) 
    355         and cherrypy.config.get('server.log_unhandled_tracebacks', True)): 
     354    if (not cherrypy.config.serverconf.get('server.log_tracebacks', True) 
     355        and cherrypy.config.serverconf.get('server.log_unhandled_tracebacks', True)): 
    356356        cherrypy.log(traceback=True) 
    357357     

  • branches/multiapp/cherrypy/_cpwsgi.py

    r887 r908  
    5555     
    5656    # Trap screen output from BaseHTTPRequestHandler.log_message() 
    57     if not cherrypy.config.get('server.log_to_screen'): 
     57    if not cherrypy.config.serverconf.get('server.log_to_screen'): 
    5858        sys.stderr = NullWriter() 
    5959     
    …… 
    7878        raise 
    7979    except: 
    80         if cherrypy.config.get("server.throw_errors", False): 
     80        if cherrypy.config.serverconf.get("server.throw_errors", False): 
    8181            raise 
    82         tb = _cputil.formatExc() 
    83         cherrypy.log(tb) 
    84         if not cherrypy.config.get("server.show_tracebacks", False): 
    85             tb = "" 
    86         s, h, b = _cputil.bareError(tb) 
     82        cherrypy.log(traceback=True) 
     83        s, h, b = _cputil.bareError() 
    8784        exc = sys.exc_info() 
    8885     
    …… 
    126123    def __init__(self, socket, addr, server): 
    127124        _cpwsgiserver.HTTPRequest.__init__(self, socket, addr, server) 
    128         mhs = int(cherrypy.config.get('server.max_request_header_size', 
    129                                       500 * 1024)) 
     125        mhs = int(cherrypy.config.serverconf.get('server.max_request_header_size', 
     126                                                 500 * 1024)) 
    130127        self.rfile = httptools.SizeCheckWrapper(self.rfile, mhs) 
    131128     
    …… 
    149146                self.rfile.bytes_read = 0 
    150147                path = self.environ["SCRIPT_NAME"] 
    151                 if path == "*": 
    152                     path = "global" 
    153                 else: 
    154                     path = "/" + path 
    155                 mbs = int(cherrypy.config.get('server.max_request_body_size', 
    156                                               100 * 1024 * 1024, path=path)) 
     148                mbs = int(cherrypy.config.serverconf.get('server.max_request_body_size', 
     149                                                         100 * 1024 * 1024)) 
    157150                self.rfile.maxlen = mbs 
    158151 
    …… 
    171164     
    172165    def __init__(self, app=wsgiApp): 
    173         conf = cherrypy.config.get 
     166        conf = cherrypy.config.serverconf.get 
    174167         
    175         sockFile = cherrypy.config.get('server.socket_file') 
     168        sockFile = conf('server.socket_file') 
    176169        if sockFile: 
    177170            bind_addr = sockFile 

  • branches/multiapp/cherrypy/config.py

    r892 r908  
    99 
    1010 
    11 # This configs dict holds the settings metadata for all cherrypy objects. 
    12 # Keys are URL paths, and values are dicts. 
    13 configs = {} 
    14 configMap = configs # Backward compatibility 
    15  
    16 default_global = { 
     11default_serverconf = { 
    1712    'server.socket_port': 8080, 
    1813    'server.socket_host': '', 
    1914    'server.socket_file': '', 
    2015    'server.socket_queue_size': 5, 
     16    'server.reverse_dns': False, 
     17    'autoreload.on': False, 
     18    'autoreload.frequency': 1, 
    2119    'server.protocol_version': 'HTTP/1.0', 
     20    'server.thread_pool': 0, 
    2221    'server.log_to_screen': True, 
    2322    'server.log_tracebacks': True, 
    2423    'server.log_file': '', 
    25     'server.reverse_dns': False, 
    26     'server.thread_pool': 0, 
    27     'server.environment': "development", 
    28  
    29     '/favicon.ico': { 
    30         'static_filter.on': True, 
    31         'static_filter.file': os.path.join(os.path.dirname(__file__), "favicon.ico"),} 
     24    'server.log_config_options': False, 
     25    'server.log_file_not_found': False, 
     26    'server.log_request_headers': False, 
    3227    } 
     28serverconf = default_serverconf.copy() 
    3329 
    3430environments = { 
    …… 
    3632        'autoreload.on': True, 
    3733        'log_debug_info_filter.on': True, 
    38         'server.log_file_not_found': True, 
    3934        'server.show_tracebacks': True, 
    40         'server.log_request_headers': True, 
    4135        }, 
    4236    "staging": { 
    4337        'autoreload.on': False, 
    4438        'log_debug_info_filter.on': False, 
    45         'server.log_file_not_found': False, 
    4639        'server.show_tracebacks': False, 
    47         'server.log_request_headers': False, 
    4840        }, 
    4941    "production": { 
    5042        'autoreload.on': False, 
    5143        'log_debug_info_filter.on': False, 
    52         'server.log_file_not_found': False, 
    5344        'server.show_tracebacks': False, 
    54         'server.log_request_headers': False, 
    5545        }, 
    5646    } 
    …… 
    6252    already defined in the configs. 
    6353    """ 
     54     
     55    appconf = cherrypy.app.config 
     56     
    6457    if updateMap is None: 
    6558        updateMap = {} 
    …… 
    7164        updateMap.update(dict_from_config_file(file)) 
    7265     
    73     # Load new conf into cherrypy.configs 
     66    # Load new conf into cherrypy configs 
    7467    for section, valueMap in updateMap.iteritems(): 
    7568        # Handle shortcut syntax for "global" section 
    76         #   example: update({'server.socket_port': 80}) 
     69        #   example: update({'http.show_tracebacks': True}) 
    7770        if not isinstance(valueMap, dict): 
    7871            valueMap = {section: valueMap} 
    7972            section = 'global' 
    8073         
    81         bucket = configs.setdefault(section, {}) 
     74        if section == "server": 
     75            bucket = serverconf 
     76        else: 
     77            bucket = appconf.setdefault(section, {}) 
     78         
    8279        if overwrite: 
    8380            bucket.update(valueMap) 
    …… 
    8683                bucket.setdefault(key, value) 
    8784 
    88 def reset(useDefaults=True): 
    89     """Clear configuration and restore defaults""" 
    90     configs.clear() 
    91     if useDefaults: 
    92         update(default_global) 
    93 reset() 
    9485 
    9586def get(key, default_value=None, return_section=False, path = None): 
    …… 
    9889    specified, return the path to the value, instead of the value itself. 
    9990    """ 
     91     
     92    configs = cherrypy.app.config 
    10093     
    10194    if path is None: 
    …… 
    156149    """ 
    157150    # Needed by the session filter 
     151     
     152    configs = cherrypy.app.config 
    158153     
    159154    try: 
    …… 
    233228    """Log server configuration parameters""" 
    234229    cherrypy.log("Server parameters:", 'CONFIG') 
    235      
    236     serverVars = [ 
    237                   'server.environment', 
    238                   'server.log_to_screen', 
    239                   'server.log_file', 
    240                   'server.log_tracebacks', 
    241                   'server.log_request_headers', 
    242                   'server.protocol_version', 
    243                   'server.socket_host', 
    244                   'server.socket_port', 
    245                   'server.socket_file', 
    246                   'server.reverse_dns', 
    247                   'server.socket_queue_size', 
    248                   'server.thread_pool', 
    249                  ] 
    250  
    251     for var in serverVars: 
    252         cherrypy.log("  %s: %s" % (var, get(var)), 'CONFIG') 
    253  
     230    for k, v in serverconf.iteritems(): 
     231        cherrypy.log("  %s: %s" % (k, v), 'CONFIG') 
     232 

  • branches/multiapp/cherrypy/filters/__init__.py

    r903 r908  
    5656    inputs, outputs = [], [] 
    5757     
    58     conf = cherrypy.config.get 
     58    conf = cherrypy.config.serverconf.get 
    5959     
    6060    for filtercls in input_filters + conf('server.input_filters', []): 
    …… 
    106106        if method: 
    107107            special_methods.append(method) 
    108  
     108     
    109109    if method_name in _input_methods: 
    110110        # Run special filters after defaults. 

  • branches/multiapp/cherrypy/filters/cachefilter.py

    r906 r908  
    103103     
    104104    def __init__(self): 
    105         cache_class = cherrypy.config.get("cache_filter.cacheClass", MemoryCache) 
     105        cache_class = cherrypy.config.serverconf.get("cache_filter.cacheClass", 
     106                                                     MemoryCache) 
    106107        cherrypy._cache = cache_class() 
    107108     

  • branches/multiapp/cherrypy/lib/covercp.py

    r856 r908  
    345345     
    346346    import cherrypy 
    347     cherrypy.root = CoverStats() 
    348     cherrypy.config.update({'server.socket_port': port, 
    349                             'server.thread_pool': 10, 
    350                             'server.environment': "production", 
    351                             }) 
     347    cherrypy.new(root = CoverStats()) 
     348    cherrypy.config.update({ 
     349        'server': { 
     350            'server.socket_port': port, 
     351            'server.thread_pool': 10, 
     352            }, 
     353        'global': { 
     354            'server.environment': "production", 
     355            }, 
     356        }) 
    352357    cherrypy.server.start() 
    353358 

  • branches/multiapp/cherrypy/lib/cptools.py

    r896 r908  
    5252    from cherrypy.lib.cptools import ExposeItems 
    5353    ... 
    54     cherrypy.root.foo = ExposeItems(mylist) 
    55     cherrypy.root.bar = ExposeItems(mydict) 
     54    cherrypy.app.root.foo = ExposeItems(mylist) 
     55    cherrypy.app.root.bar = ExposeItems(mydict) 
    5656    """ 
    5757    exposed = True 
    …… 
    7676    response = cherrypy.response 
    7777     
    78     # If path is relative, make absolute using cherrypy.root's module. 
    79     # If there is no cherrypy.root, or it doesn't have a __module__ 
     78    # If path is relative, make absolute using cherrypy.app.root's module. 
     79    # If there is no cherrypy.app.root, or it doesn't have a __module__ 
    8080    # attribute, then users should fix the issue by making path absolute. 
    8181    # That is, CherryPy should not guess where the application root is 
    82     # any further than trying cherrypy.root.__module__, and it certainly 
     82    # any further than trying cherrypy.app.root.__module__, and it certainly 
    8383    # should *not* use cwd (since CP may be invoked from a variety of 
    8484    # paths). If using static_filter, you can make your relative paths 
    8585    # become absolute by supplying a value for "static_filter.root". 
    8686    if not os.path.isabs(path): 
    87         root = os.path.dirname(sys.modules[cherrypy.root.__module__].__file__) 
     87        root = os.path.dirname(sys.modules[cherrypy.app.root.__module__].__file__) 
    8888        path = os.path.join(root, path) 
    8989     

  • branches/multiapp/cherrypy/lib/httptools.py

    r899 r908  
    299299def parseRequestLine(requestLine): 
    300300    """Return (method, path, querystring, protocol) from a requestLine.""" 
    301     method, path, protocol = requestLine.split() 
    302      
    303     # path may be an abs_path (including "http://host.domain.tld"); 
     301    method, url, protocol = requestLine.split() 
     302    path, qs = parse_request_url(url) 
     303    return method, path, qs, protocol 
     304 
     305def parse_request_url(url): 
     306    """Return (relative path, querystring) from a requestline url.""" 
     307     
     308    # url may be an abs_path (including "http://host.domain.tld"); 
    304309    # Ignore scheme, location, and fragments (so config lookups work). 
    305310    # [Therefore, this assumes all hosts are valid for this server.] 
    306     scheme, location, path, params, qs, frag = urlparse(path) 
     311    scheme, location, path, params, qs, frag = urlparse(url) 
    307312    if path == "*": 
    308313        # "...the request does not apply to a particular resource, 
    …… 
    325330        atoms = [urllib.unquote(x) for x in re.split("(?i)%2F", path)] 
    326331        path = "%2F".join(atoms) 
    327      
    328     return method, path, qs, protocol 
     332    return path, qs 
     333 
    329334 
    330335def parseQueryString(queryString, keep_blank_values=True): 

  • branches/multiapp/cherrypy/lib/profiler.py

    r882 r908  
    131131    import cherrypy 
    132132    cherrypy.root = Profiler(path) 
    133     cherrypy.config.update({'server.socket_port': int(port), 
    134                             'server.thread_pool': 10, 
    135                             'server.environment': "production", 
    136                             'session.storageType': "ram", 
    137                             }) 
     133    cherrypy.config.update({ 
     134        'server': { 
     135            'server.socket_port': int(port), 
     136            'server.thread_pool': 10, 
     137            }, 
     138        'global': { 
     139            'server.environment': "production", 
     140            'session.storageType': "ram", 
     141            }, 
     142        }) 
    138143    cherrypy.server.start() 
    139144 

  • branches/multiapp/cherrypy/test/__init__.py

    r762 r908  
    77#    - test if tabs and whitespaces are handled correctly in source file (option -W) 
    88#    - test if absolute pathnames work fine on windows 
    9 #    - test sessions 
    10 #    - test threading server 
    119#    - test forking server 
    1210#    - test process pooling server 

  • branches/multiapp/cherrypy/test/helper.py

    r893 r908  
    3030import cherrypy 
    3131from cherrypy import _cpwsgi 
     32from cherrypy.lib import httptools 
    3233import webtest 
    3334 
    …… 
    4344    if not handled: 
    4445        cherrypy._cputil._cp_on_error() 
    45  
    46  
    47 class VirtualRootFilter: 
    48      
    49     def __init__(self, prefix): 
    50         self.prefix = prefix 
    51      
    52     def on_start_resource(self): 
    53         path = cherrypy.request.object_path 
    54         if path.startswith(self.prefix): 
    55             cherrypy.request.object_path = path[len(self.prefix):] 
    56 vroot = "" 
    57 ##vr