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

Changeset 1278

Show
Ignore:
Timestamp:
08/25/06 16:25:56
Author:
fumanchu
Message:

More (final?) config overhaul work:

  1. Removed cherrypy.config.get! Instead, you should directly inspect cherrypy.request, response, server, etc. Note that request.config.get still works fine.
  2. a) cherrypy.log is now an instance of LogManager?. It's still callable, but now is the object you inspect instead of calling config.get("log*"). b) cherrypy.log_access is now cherrypy.log.access.
  3. All threads should now have access to default Request and Response objects, not just the main thread.
  4. deadlock.timeout is now request.timeout.
  5. Renamed config.py to _cpconfig.py; cherrypy.config is now an instance of _cpconfig.Config.

I still need to decide what to do about log_config (removed for now).

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/cherrypy/__init__.py

    r1276 r1278  
    44 
    55import logging as _logging 
     6import os as _os 
     7_localdir = _os.path.dirname(__file__) 
    68 
    79from cherrypy._cperror import HTTPError, HTTPRedirect, InternalRedirect, NotFound 
    810from cherrypy._cperror import WrongConfigValue, TimeoutError 
    9 from cherrypy import config 
     11error_page = {} 
    1012 
    1113from cherrypy import _cptools 
    …… 
    3739serving = _local() 
    3840 
    39 # Bind dummy instances of default request/response 
    40 # (in the main thread only!) to help introspection. 
    41 serving.request = _cprequest.Request("localhost", "11111", "localhost") 
    42 serving.response = _cprequest.Response() 
    43  
    4441 
    4542class _ThreadLocalProxy(object): 
    4643     
    47     __slots__ = ['__attrname__', '__dict__'] 
    48      
    49     def __init__(self, attrname): 
     44    __slots__ = ['__attrname__', '_default_child', '__dict__'] 
     45     
     46    def __init__(self, attrname, default): 
    5047        self.__attrname__ = attrname 
     48        self._default_child = default 
     49     
     50    def _get_child(self): 
     51        try: 
     52            return getattr(serving, self.__attrname__) 
     53        except AttributeError: 
     54            # Bind dummy instances of default objects to help introspection. 
     55            return self._default_child 
    5156     
    5257    def __getattr__(self, name): 
    53         childobject = getattr(serving, self.__attrname__) 
    54         return getattr(childobject, name) 
     58        return getattr(self._get_child(), name) 
    5559     
    5660    def __setattr__(self, name, value): 
    57         if name == "__attrname__": 
    58             object.__setattr__(self, "__attrname__", value) 
     61        if name in ("__attrname__", "_default_child"): 
     62            object.__setattr__(self, name, value) 
    5963        else: 
    60             childobject = getattr(serving, self.__attrname__) 
    61             setattr(childobject, name, value) 
     64            setattr(self._get_child(), name, value) 
    6265     
    6366    def __delattr__(self, name): 
    64         childobject = getattr(serving, self.__attrname__) 
    65         delattr(childobject, name) 
     67        delattr(self._get_child(), name) 
    6668     
    6769    def _get_dict(self): 
    68         childobject = getattr(serving, self.__attrname__) 
     70        childobject = self._get_child() 
    6971        d = childobject.__class__.__dict__.copy() 
    7072        d.update(childobject.__dict__) 
    …… 
    7375     
    7476    def __getitem__(self, key): 
    75         childobject = getattr(serving, self.__attrname__) 
    76         return childobject[key] 
     77        return self._get_child()[key] 
    7778     
    7879    def __setitem__(self, key, value): 
    79         childobject = getattr(serving, self.__attrname__) 
    80         childobject[key] = value 
     80        self._get_child()[key] = value 
    8181 
    8282 
    …… 
    8484#   throughout the entire life of the webserver, but will redirect 
    8585#   to the "serving" object) 
    86 request = _ThreadLocalProxy('request') 
    87 response = _ThreadLocalProxy('response') 
     86from cherrypy.lib import http as _http 
     87request = _ThreadLocalProxy('request', 
     88                            _cprequest.Request(_http.Host("localhost", 80), 
     89                                               _http.Host("localhost", 1111))) 
     90response = _ThreadLocalProxy('response', _cprequest.Response()) 
    8891 
    8992# Create thread_data object as a thread-specific all-purpose storage 
    …… 
    103106        now.day, month, now.year, now.hour, now.minute, now.second) 
    104107 
    105 def log_access(): 
    106     """Default method for logging access""" 
    107     tmpl = '%(h)s %(l)s %(u)s [%(t)s] "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"' 
    108     s = tmpl % {'h': request.remote.name or request.remote.ip, 
    109                 'l': '-', 
    110                 'u': getattr(request, "login", None) or "-", 
    111                 't': logtime(), 
    112                 'r': request.request_line, 
    113                 's': response.status.split(" ", 1)[0], 
    114                 'b': response.headers.get('Content-Length', '') or "-", 
    115                 'f': request.headers.get('referer', ''), 
    116                 'a': request.headers.get('user-agent', ''), 
    117                 } 
    118     try: 
    119         request.app.access_log.log(_logging.INFO, s) 
    120     except: 
    121         log(traceback=True) 
    122  
    123108 
    124109_error_log = _logging.getLogger("cherrypy.error") 
    125110_error_log.setLevel(_logging.DEBUG) 
    126  
    127111_access_log = _logging.getLogger("cherrypy.access") 
    128112_access_log.setLevel(_logging.INFO) 
    129113 
    130 def _log_message(msg, context = '', severity = _logging.DEBUG): 
    131     """Default method for logging messages (error log). 
    132      
    133     This is not just for errors! Applications may call this at any time to 
    134     log application-specific information. 
    135     """ 
    136      
    137     try: 
    138         log = request.app.error_log 
    139     except AttributeError: 
    140         log = _error_log 
    141     log.log(severity, ' '.join((logtime(), context, msg))) 
    142  
    143 def log(msg='', context='', severity=_logging.DEBUG, traceback=False): 
    144     """Syntactic sugar for writing to the (error) log. 
    145      
    146     This is not just for errors! Applications may call this at any time to 
    147     log application-specific information. 
    148     """ 
    149     if traceback: 
    150         from cherrypy import _cperror 
    151         msg += _cperror.format_exc() 
    152     logfunc = config.get('log.error.function', _log_message) 
    153     logfunc(msg, context, severity) 
    154  
     114 
     115class LogManager(object): 
     116     
     117    screen = True 
     118    error_file = _os.path.join(_os.getcwd(), _localdir, "error.log") 
     119    # Using an access file makes CP about 10% slower. 
     120    access_file = '' 
     121     
     122    def error(self, msg='', context='', severity=_logging.DEBUG, traceback=False): 
     123        """Write to the 'error' log. 
     124         
     125        This is not just for errors! Applications may call this at any time 
     126        to log application-specific information. 
     127        """ 
     128        if traceback: 
     129            from cherrypy import _cperror 
     130            msg += _cperror.format_exc() 
     131         
     132        try: 
     133            elog = request.app.error_log 
     134        except AttributeError: 
     135            elog = _error_log 
     136        elog.log(severity, ' '.join((logtime(), context, msg))) 
     137     
     138    def __call__(self, *args, **kwargs): 
     139        return self.error(*args, **kwargs) 
     140     
     141    def access(self): 
     142        """Default method for logging access""" 
     143        tmpl = '%(h)s %(l)s %(u)s [%(t)s] "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"' 
     144        s = tmpl % {'h': request.remote.name or request.remote.ip, 
     145                    'l': '-', 
     146                    'u': getattr(request, "login", None) or "-", 
     147                    't': logtime(), 
     148                    'r': request.request_line, 
     149                    's': response.status.split(" ", 1)[0], 
     150                    'b': response.headers.get('Content-Length', '') or "-", 
     151                    'f': request.headers.get('referer', ''), 
     152                    'a': request.headers.get('user-agent', ''), 
     153                    } 
     154        try: 
     155            request.app.access_log.log(_logging.INFO, s) 
     156        except: 
     157            self.error(traceback=True) 
     158 
     159 
     160log = LogManager() 
    155161 
    156162 
    …… 
    230236        return expose_ 
    231237 
     238 
     239# Set up config last so it can wrap other top-level objects 
     240from cherrypy import _cpconfig 
     241config = _cpconfig.Config() 

  • trunk/cherrypy/_cpconfig.py

    r1275 r1278  
    2929 
    3030 
    31 Usage 
    32 ----- 
     31Declaration 
     32----------- 
    3333 
    3434Configuration data may be supplied as a Python dictionary, as a filename, 
    …… 
    6161Current namespaces: 
    6262 
    63     autoreload: Controls the autoreload mechanism in cherrypy.engine. 
    64                 These can only be declared in the global config. 
    65     deadlock:   Controls the deadlock monitoring system in cherrypy.engine. 
     63    engine:     Controls the 'application engine', including autoreload. 
    6664                These can only be declared in the global config. 
    6765    hooks:      Declares additional request-processing functions. 
    6866    log:        Configures the logging for each application. 
     67                These can only be declared in the global or / config. 
    6968    request:    Adds attributes to each Request during the tool_up phase. 
    7069    response:   Adds attributes to each Response during the tool_up phase. 
    …… 
    8382_logfmt = _logging.Formatter("%(message)s") 
    8483import os as _os 
    85 _localdir = _os.path.dirname(__file__) 
     84import types 
    8685 
    8786import cherrypy 
    …… 
    123122 
    124123default_conf = { 
    125     # Server config 
    126     'server.socket_port': 8080, 
    127     'server.socket_host': '', 
    128     'server.socket_file': '', 
    129     'server.socket_queue_size': 5, 
    130     'server.socket_timeout': 10, 
    131     'server.protocol_version': 'HTTP/1.1', 
    132     'server.reverse_dns': False, 
    133     'server.thread_pool': 10, 
    134     'server.max_request_header_size': 500 * 1024, 
    135     'server.instance': None, 
    136      
    137     # Log config 
    138     'log.to_screen': True, 
    139 ##    'log.error.function': cherrypy._log_message, 
    140     'log.error.file': _os.path.join(_os.getcwd(), _localdir, "error.log"), 
    141     # Using an access file makes CP about 10% slower. 
    142 ##    'log.access.function': cherrypy.log_access, 
    143 ##    'log.access.file': _os.path.join(_os.getcwd(), _localdir, "access.log"), 
    144      
    145     # Process management 
    146     'autoreload.on': True, 
    147     'autoreload.frequency': 1, 
    148     'deadlock.timeout': 300, 
    149     'deadlock.poll_freq': 60, 
    150      
    151     'error_page.404': '', 
    152      
    153124    'tools.log_tracebacks.on': True, 
    154125    'tools.log_headers.on': True, 
    …… 
    156127 
    157128 
    158 globalconf = default_conf.copy() 
    159  
    160 def reset(): 
    161     globalconf.clear() 
    162     update(default_conf) 
    163  
    164 def update(conf): 
    165     """Update globalconf from a dict, file or filename.""" 
    166     if isinstance(conf, basestring): 
    167         if conf not in cherrypy.engine.reload_files: 
    168             cherrypy.engine.reload_files.append(conf) 
    169         conf = _Parser().dict_from_file(conf) 
    170     elif hasattr(conf, 'read'): 
    171         conf = _Parser().dict_from_file(conf) 
    172      
    173     if isinstance(conf.get("global", None), dict): 
    174         conf = conf["global"] 
    175      
    176     if 'environment' in conf: 
    177         env = environments[conf['environment']] 
    178         for k in env: 
    179             if k not in conf: 
    180                 conf[k] = env[k] 
    181      
    182     if 'tools.staticdir.dir' in conf: 
    183         conf['tools.staticdir.section'] = "global" 
    184      
    185     globalconf.update(conf) 
    186      
    187     _configure_builtin_logging(globalconf, cherrypy._error_log) 
    188     _configure_builtin_logging(globalconf, cherrypy._access_log, "log.access.file") 
     129class Config(object): 
     130     
     131    globalconf = default_conf.copy() 
     132     
     133    def reset(self): 
     134        """Reset self.globalconf to default values.""" 
     135        self.globalconf.clear() 
     136        self.update(default_conf) 
     137     
     138    def update(self, conf): 
     139        """Update self.globalconf from a dict, file or filename.""" 
     140        if isinstance(conf, basestring): 
     141            if conf not in cherrypy.engine.reload_files: 
     142                cherrypy.engine.reload_files.append(conf) 
     143            conf = _Parser().dict_from_file(conf) 
     144        elif hasattr(conf, 'read'): 
     145            conf = _Parser().dict_from_file(conf) 
     146         
     147        if isinstance(conf.get("global", None), dict): 
     148            conf = conf["global"] 
     149         
     150        if 'environment' in conf: 
     151            env = environments[conf['environment']] 
     152            for k in env: 
     153                if k not in conf: 
     154                    conf[k] = env[k] 
     155         
     156        if 'tools.staticdir.dir' in conf: 
     157            conf['tools.staticdir.section'] = "global" 
     158         
     159        self.globalconf.update(conf) 
     160         
     161        _configure_builtin_logging(self.globalconf, cherrypy._error_log) 
     162        _configure_builtin_logging(self.globalconf, cherrypy._access_log, "log.access_file") 
     163         
     164        # Override properties specified in config. 
     165        gconf = self.globalconf 
     166        for k in gconf: 
     167            atoms = k.split(".", 1) 
     168            namespace = atoms[0] 
     169            if namespace == "server": 
     170                setattr(cherrypy.server, atoms[1], gconf[k]) 
     171            elif namespace == "engine": 
     172                setattr(cherrypy.engine, atoms[1], gconf[k]) 
     173            elif namespace == "log": 
     174                setattr(cherrypy.log, atoms[1], gconf[k]) 
     175            elif namespace == "error_page": 
     176                cherrypy.error_page[int(atoms[1])] = gconf[k] 
     177     
     178    def wrap(**kwargs): 
     179        """Decorator to set _cp_config on a handler using the given kwargs.""" 
     180        def wrapper(f): 
     181            if not hasattr(f, "_cp_config"): 
     182                f._cp_config = {} 
     183            f._cp_config.update(kwargs) 
     184            return f 
     185        return wrapper 
     186    wrap = staticmethod(wrap) 
     187 
    189188 
    190189def _add_builtin_screen_handler(log): 
    …… 
    203202    log.addHandler(h) 
    204203 
    205 def _configure_builtin_logging(conf, log, filekey="log.error.file"): 
     204def _configure_builtin_logging(conf, log, filekey="log.error_file"): 
    206205    """Create/destroy builtin log handlers as needed from conf.""" 
    207206     
    …… 
    230229            h.close() 
    231230            log.handlers.remove(h) 
    232  
    233 def get(key, default=None): 
    234     """Return the config value corresponding to key, or default.""" 
    235     try: 
    236         conf = cherrypy.request.config 
    237         if conf is None: 
    238             conf = globalconf 
    239     except AttributeError: 
    240         # There's no request, so just use globalconf. 
    241         conf = globalconf 
    242      
    243     return conf.get(key, default) 
    244  
    245  
    246 def wrap(**kwargs): 
    247     """Decorator to set _cp_config on a handler using the given kwargs.""" 
    248     def wrapper(f): 
    249         if not hasattr(f, "_cp_config"): 
    250             f._cp_config = {} 
    251         f._cp_config.update(kwargs) 
    252         return f 
    253     return wrapper 
    254231 
    255232 
    …… 
    304281        return self.as_dict() 
    305282 
    306  
    307 def log_config(): 
    308     """Log engine configuration parameters.""" 
    309     cherrypy.log("Server parameters:", 'CONFIG') 
    310      
    311     server_vars = [ 
    312                   'environment', 
    313                   'log.screen', 
    314                   'log.error.file', 
    315                   'server.protocol_version', 
    316                   'server.socket_host', 
    317                   'server.socket_port', 
    318                   'server.socket_file', 
    319                   'server.reverse_dns', 
    320                   'server.socket_queue_size', 
    321                   'server.thread_pool', 
    322                  ] 
    323      
    324     for var in server_vars: 
    325         cherrypy.log("  %s: %s" % (var, get(var)), 'CONFIG') 
    326  
    327  
    328283del ConfigParser 

  • trunk/cherrypy/_cpengine.py

    r1275 r1278  
    4343    """The application engine, which exposes a request interface to (HTTP) servers.""" 
    4444     
     45    # Configurable attributes 
    4546    request_class = _cprequest.Request 
    4647    response_class = _cprequest.Response 
     48    deadlock_poll_freq = 60 
     49    autoreload_on = False 
     50    autoreload_frequency = 1 
    4751     
    4852    def __init__(self): 
    …… 
    6771        self.state = STARTING 
    6872         
    69         conf = cherrypy.config.get 
    70          
    7173        for func in self.on_start_engine_list: 
    7274            func() 
    …… 
    7476        self.state = STARTED 
    7577         
    76         freq = float(conf('deadlock.poll_freq', 60)) 
     78        freq = self.deadlock_poll_freq 
    7779        if freq > 0: 
    7880            self.monitor_thread = threading.Timer(freq, self.monitor) 
    …… 
    8587        """Block forever (wait for stop(), KeyboardInterrupt or SystemExit).""" 
    8688        try: 
    87             autoreload = cherrypy.config.get('autoreload.on', False) 
    88             if autoreload: 
     89            if self.autoreload_on: 
    8990                i = 0 
    90                 freq = cherrypy.config.get('autoreload.frequency', 1) 
     91                freq = self.autoreload_frequency 
    9192             
    9293            while self.state != STOPPED: 
    …… 
    9495                 
    9596                # Autoreload 
    96                 if autoreload: 
     97                if self.autoreload_on: 
    9798                    i += .1 
    9899                    if i > freq: 
    …… 
    219220            for req, resp in self.servings: 
    220221                resp.check_timeout() 
    221             freq = float(cherrypy.config.get('deadlock.poll_freq', 60)) 
     222            freq = self.deadlock_poll_freq 
    222223            self.monitor_thread = threading.Timer(freq, self.monitor) 
    223224            self.monitor_thread.start() 

  • trunk/cherrypy/_cperror.py

    r1275 r1278  
    267267     
    268268    template = _HTTPErrorTemplate 
    269     error_page_file = cherrypy.config.get('error_page.%s' % code, '') 
     269    error_page_file = cherrypy.request.error_page.get(code, '') 
    270270    if error_page_file: 
    271271        try: 

  • trunk/cherrypy/_cprequest.py

    r1277 r1278  
    282282    body = None 
    283283    body_read = False 
    284     max_body_size = 100 * 1024 * 1024 
    285284     
    286285    # Dispatch attributes 
    …… 
    301300     
    302301    error_response = cherrypy.HTTPError(500).set_response 
     302    error_page = {} 
    303303    show_tracebacks = True 
    304304    throw_errors = False 
    …… 
    421421            cherrypy.response.body = [] 
    422422         
    423         log_access = cherrypy.config.get("log.access.function", cherrypy.log_access) 
     423        log_access = cherrypy.log.access 
    424424        if log_access: 
    425425            log_access() 
    …… 
    449449                    if self.process_request_body: 
    450450                        # Prepare the SizeCheckWrapper for the request body 
    451                         mbs = self.max_body_size 
     451                        mbs = cherrypy.server.max_request_body_size 
    452452                        if mbs > 0: 
    453453                            self.rfile = http.SizeCheckWrapper(self.rfile, mbs) 
    …… 
    532532    def tool_up(self): 
    533533        """Process self.config, populate self.toolmap and set up each tool.""" 
     534        self.error_page = cherrypy.error_page.copy() 
     535         
    534536        # Get all 'tools.*' config entries as a {toolname: {k: v}} dict. 
    535537        self.toolmap = tm = {} 
    536538        reqconf = self.config 
    537539        for k in reqconf: 
    538             atoms = k.split(".", 2) 
     540            atoms = k.split(".", 1) 
    539541            namespace = atoms[0] 
    540542            if namespace == "tools": 
    541                 toolname = atoms[1] 
     543                toolname, arg = atoms[1].split(".", 1) 
    542544                bucket = tm.setdefault(toolname, {}) 
    543                 bucket[atoms[2]] = reqconf[k] 
     545                bucket[arg] = reqconf[k] 
    544546            elif namespace == "hooks": 
    545547                # Attach bare hooks declared in config. 
    …… 
    555557                # Override properties of the current response object. 
    556558                setattr(cherrypy.response, atoms[1], reqconf[k]) 
     559            elif namespace == "error_page": 
     560                self.error_page[int(atoms[1])] = reqconf[k] 
    557561         
    558562        # Run tool._setup(conf) for each tool in the new toolmap. 
    …… 
    688692    body = Body() 
    689693    time = None 
     694    timeout = 300 
    690695    timed_out = False 
    691696    stream = False 
    …… 
    745750     
    746751    def check_timeout(self): 
    747         """If now > self.time + deadlock_timeout, set self.timed_out. 
     752        """If now > self.time + self.timeout, set self.timed_out. 
    748753         
    749754        This purposefully sets a flag, rather than raising an error, 
    750755        so that a monitor thread can interrupt the Response thread. 
    751756        """ 
    752         timeout = float(cherrypy.config.get('deadlock.timeout', 300)) 
    753         if time.time() > self.time + timeout: 
     757        if time.time() > self.time + self.timeout: 
    754758            self.timed_out = True 
    755759 

  • trunk/cherrypy/_cpserver.py

    r1274 r1278  
    1212    """Manager for a set of HTTP servers.""" 
    1313     
     14    socket_port = 8080 
     15    socket_host = '' 
     16    socket_file = '' 
     17    socket_queue_size = 5 
     18    socket_timeout = 10 
     19    protocol_version = 'HTTP/1.1' 
     20    reverse_dns = False 
     21    thread_pool = 10 
     22    max_request_header_size = 500 * 1024 
     23    max_request_body_size = 100 * 1024 * 1024 
     24    instance = None 
     25     
    1426    def __init__(self): 
    1527        self.httpservers = {} 
    …… 
    2032         
    2133        This function works like CherryPy 2's server.start(). It loads and 
    22         starts an httpserver based on the given server object, if any, and 
    23         config entries. 
     34        starts an httpserver based on the given server object (if provided) 
     35        and attributes of self. 
    2436        """ 
    25         httpserver, bind_addr = self.httpserver_from_config(server) 
     37        httpserver, bind_addr = self.httpserver_from_self(server) 
    2638        self.httpservers[httpserver] = bind_addr 
    2739        self.start() 
    2840     
    29     def httpserver_from_config(self, httpserver=None): 
    30         """Return a (httpserver, bind_addr) pair based on config settings.""" 
    31         conf = cherrypy.config.get 
     41    def httpserver_from_self(self, httpserver=None): 
     42        """Return a (httpserver, bind_addr) pair based on self attributes.""" 
    3243        if httpserver is None: 
    33             httpserver = conf('server.instance', None) 
     44            httpserver = self.instance 
    3445        if httpserver is None: 
    3546            from cherrypy import _cpwsgi 
    …… 
    3849            httpserver = attributes(httpserver)() 
    3950         
    40         if conf('server.socket_port'): 
    41             host = conf('server.socket_host') 
    42             port = conf('server.socket_port') 
     51        if self.socket_port: 
     52            host = self.socket_host 
     53            port = self.socket_port 
    4354            if not host: 
    4455                host = 'localhost' 
    4556            return httpserver, (host, port) 
    4657        else: 
    47             return httpserver, conf('server.socket_file') 
     58            return httpserver, self.socket_file 
    4859     
    4960    def start(self): 

  • trunk/cherrypy/_cptree.py

    r1275 r1278  
    11import logging 
    22 
    3 from cherrypy import config, _cpwsgi 
     3from cherrypy import _cpconfig, _cpwsgi 
    44 
    55 
    …… 
    4646    def merge(self, conf): 
    4747        """Merge the given config into self.config.""" 
    48         config.merge(self.conf, conf) 
     48        _cpconfig.merge(self.conf, conf) 
    4949         
    5050        # Create log handlers as specified in config. 
    5151        rootconf = self.conf.get("/", {}) 
    52         config._configure_builtin_logging(rootconf, self.access_log, "log.access.file") 
    53         config._configure_builtin_logging(rootconf, self.error_log) 
     52        _cpconfig._configure_builtin_logging(rootconf, self.access_log, "log.access_file") 
     53        _cpconfig._configure_builtin_logging(rootconf, self.error_log) 
    5454     
    5555    def guess_abs_path(self): 
    …… 
    6262        set socket_host and socket_port correctly. 
    6363        """ 
    64         port = int(config.get('server.socket_port', 80)) 
     64        port = cherrypy.server.socket_port 
    6565        if port in (443, 8443): 
    6666            scheme = "https://" 
    6767        else: 
    6868            scheme = "http://" 
    69         host = config.get('server.socket_host', '') 
     69        host = cherrypy.server.socket_host 
    7070        if port != 80: 
    7171            host += ":%s" % port 
    …… 
    8282    (WSGI application object), in which case it dispatches to all 
    8383    mounted apps. 
     84     
     85    apps: a dict of the form {script name: application}, where "script name" 
     86        is a string declaring the URL mount point (no trailing slash), 
     87        and "application" is an instance of cherrypy.Application (or an 
     88        arbitrary WSGI callable if you happen to be using a WSGI server). 
    8489    """ 
    8590     

  • trunk/cherrypy/_cpwsgi.py

    r1275 r1278  
    121121     
    122122    def parse_request(self): 
    123         mhs = int(cherrypy.config.get('server.max_request_header_size', 
    124                                       500 * 1024)) 
     123        mhs = cherrypy.server.max_request_header_size 
    125124        if mhs > 0: 
    126125            self.rfile = http.SizeCheckWrapper(self.rfile, mhs) 
    …… 
    136135        if isinstance(self.rfile, http.SizeCheckWrapper): 
    137136            self.rfile = self.rfile.rfile 
    138         mbs = int(cherrypy.config.get('request.max_body_size', 100 * 1024 * 1024)) 
     137        mbs = cherrypy.server.max_request_body_size 
    139138        if mbs > 0: 
    140139            self.rfile = http.SizeCheckWrapper(self.rfile, mbs) 
    …… 
    165164     
    166165    def __init__(self): 
    167         conf = cherrypy.config.get 
    168          
    169         sockFile = conf('server.socket_file') 
     166        server = cherrypy.server 
     167        sockFile = server.socket_file 
    170168        if sockFile: 
    171169            bind_addr = sockFile 
    172170        else: 
    173             bind_addr = (conf('server.socket_host'), 
    174                          conf('server.socket_port')) 
     171            bind_addr = (server.socket_host, server.socket_port) 
    175172         
    176173        s = _cpwsgiserver.CherryPyWSGIServer 
    …… 
    178175        # we get correct SCRIPT_NAMEs as early as possible. 
    179176        s.__init__(self, bind_addr, cherrypy.tree.apps.items(), 
    180                    conf('server.thread_pool'), 
    181                    conf('server.socket_host'), 
    182                    request_queue_size = conf('server.socket_queue_size'), 
    183                    timeout = conf('server.socket_timeout'), 
     177                   server.thread_pool, 
     178                   server.socket_host, 
     179                   request_queue_size = server.socket_queue_size, 
     180                   timeout = server.socket_timeout, 
    184181                   ) 
    185         s.protocol = conf('server.protocol_version', 'HTTP/1.1') 
     182        s.protocol = server.protocol_version 
    186183 

  • trunk/cherrypy/lib/caching.py

    r1243 r1278  
    9292    # Ignore POST, PUT, DELETE. 
    9393    # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.10. 
    94     invalid = cherrypy.config.get("tools.caching.invalid_methods", 
    95                                   ("POST", "PUT", "DELETE")) 
     94    invalid = cherrypy.request.config.get("tools.caching.invalid_methods", 
     95                                          ("POST", "PUT", "DELETE")) 
    9696    if cherrypy.request.method in invalid: 
    9797        cherrypy.request.cached = c = False 

  • trunk/cherrypy/lib/sessions.py

    r1261 r1278  
    354354close.failsafe = True 
    355355 
     356 
     357_def_session = RamSession() 
     358 
    356359def init(storage_type='ram', path=None, path_header=None, name='session_id', 
    357360         timeout=60, domain=None, secure=False, locking='implicit', 
    …… 
    370373     
    371374    if not hasattr(cherrypy, "session"): 
    372         cherrypy.session = cherrypy._ThreadLocalProxy('session') 
     375        cherrypy.session = cherrypy._ThreadLocalProxy('session', _def_session) 
    373376     
    374377    # Create and attach a new Session instance to cherrypy.request. 

  • trunk/cherrypy/test/benchmark.py

    r1275 r1278  
    6666    'server.socket_port': 8080, 
    6767    'server.max_request_header_size': 0, 
    68     'request.max_body_size': 0, 
     68    'server.max_request_body_size': 0, 
    6969    }) 
    7070 
    …… 
    181181     
    182182    def args(self): 
    183         port = cherrypy.config.get('server.socket_port') 
     183        port = cherrypy.server.socket_port 
    184184        assert self.concurrency > 0 
    185185        assert self.requests > 0 
    …… 
    241241    print 
    242242    print ("Client Thread Report (1000 requests, 14 byte response body, " 
    243            "%s server threads):" % cherrypy.config.get('server.thread_pool')) 
     243           "%s server threads):" % cherrypy.server.thread_pool) 
    244244    print_report(thread_report()) 
    245245     
    246246    print 
    247247    print ("Client Thread Report (1000 requests, 14 bytes via staticdir, " 
    248            "%s server threads):" % cherrypy.config.get('server.thread_pool')) 
     248           "%s server threads):" % cherrypy.server.thread_pool) 
    249249    print_report(thread_report("%s/static/index.html" % SCRIPT_NAME)) 
    250250     
    251251    print 
    252252    print ("Size Report (1000 requests, 50 client threads, " 
    253            "%s server threads):" % cherrypy.config.get('server.thread_pool')) 
     253           "%s server threads):" % cherrypy.server.thread_pool) 
    254254    print_report(size_report()) 
    255255 

  • trunk/cherrypy/test/helper.py

    r1274 r1278  
    155155def _test_main_thread(): 
    156156    try: 
    157         webtest.WebCase.PORT = cherrypy.config.get('server.socket_port') 
     157        webtest.WebCase.PORT = cherrypy.server.socket_port 
    158158        webtest.main() 
    159159    finally: 

  • trunk/cherrypy/test/test.py

    r1275 r1278  
    4040         
    4141        if isinstance(conf, basestring): 
    42             conf = cherrypy.config.dict_from_config_file(conf) 
     42            conf = cherrypy.config._Parser().dict_from_file(conf) 
    4343        baseconf = {'server.socket_host': '127.0.0.1', 
    4444                    'server.socket_port': self.port, 

  • trunk/cherrypy/test/test_caching.py

    r1275 r1278  
    121121        # This also gives us a chance to test 0 expiry with no other headers 
    122122        self.assertHeader("Pragma", "no-cache") 
    123         if cherrypy.config.get('server.protocol_version') == "HTTP/1.1": 
     123        if cherrypy.server.protocol_version == "HTTP/1.1": 
    124124            self.assertHeader("Cache-Control", "no-cache") 
    125125        d = self.assertHeader("Date") 
    …… 
    130130        self.assertStatus("200 OK") 
    131131        self.assertHeader("Pragma", "no-cache") 
    132         if cherrypy.config.get('server.protocol_version') == "HTTP/1.1": 
     132        if cherrypy.server.protocol_version == "HTTP/1.1": 
    133133            self.assertHeader("Cache-Control", "no-cache") 
    134134        d = self.assertHeader("Date") 
    …… 
    139139        self.assertStatus("200 OK") 
    140140        self.assertHeader("Pragma", "no-cache") 
    141         if cherrypy.config.get('server.protocol_version') == "HTTP/1.1": 
     141        if cherrypy.server.protocol_version == "HTTP/1.1": 
    142142            self.assertHeader("Cache-Control", "no-cache") 
    143143        d = self.assertHeader("Date") 
    …… 
    149149        # overwritten here ... 
    150150        self.assertHeader("Pragma", "no-cache") 
    151         if cherrypy.config.get('server.protocol_version') == "HTTP/1.1": 
     151        if cherrypy.server.protocol_version == "HTTP/1.1": 
    152152            self.assertHeader("Cache-Control", "no-cache") 
    153153        d = self.assertHeader("Date") 

  • trunk/cherrypy/test/test_config.py

    r1275 r1278  
    11"""Tests for the CherryPy configuration system.""" 
     2 
    23from cherrypy.test import test 
    34test.prefer_parent_path() 
    …… 
    1516         
    1617        def index(self, key): 
    17             return cherrypy.config.get(key, "None") 
     18            return cherrypy.request.config.get(key, "None") 
    1819        index.exposed = True 
    1920        global_ = index 
    …… 
    2627         
    2728        def index(self, key): 
    28             return cherrypy.config.get(key, "None") 
     29            return cherrypy.request.config.get(key, "None") 
    2930        index.exposed = True 
    3031        nex = index 
    3132         
    3233        def bar(self, key): 
    33             return cherrypy.config.get(key, "None") 
     34            return cherrypy.request.config.get(key, "None") 
    3435        bar.exposed = True 
    3536        bar._cp_config = {'foo': 'this3', 'bax': 'this4'} 
    …… 
    3839         
    3940        def index(self, key): 
    40             return str(cherrypy.config.get(key, "None")) 
     41            return str(cherrypy.request.config.get(key, "None")) 
    4142        index.exposed = True 
    4243     
    …… 
    7475            self.getPage(path + "?key=" + key) 
    7576            self.assertBody(expected) 
     77     
     78    def testExternalDispatch(self): 
     79        # 'cherrypy.request' should reference a default instance 
     80        cherrypy.request.app = cherrypy.tree.apps[""] 
     81        cherrypy.request.dispatch("/foo/bar") 
     82        expectedconf = { 
     83            # From CP defaults 
     84            'tools.log_headers.on': False, 
     85            'tools.log_tracebacks.on': True, 
     86            'request.show_tracebacks': True, 
     87            'log.screen': False, 
     88            'environment': 'test_suite', 
     89            'autoreload.on': False, 
     90            # From globalconf 
     91            'luxuryyacht': 'throatwobblermangrove', 
     92            # From Root._cp_config 
     93            'bar': 'that', 
     94            # From Foo._cp_config 
     95            'baz': 'that2', 
     96            # From Foo.bar._cp_config 
     97            'foo': 'this3', 
     98            'bax': 'this4', 
    &n