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 ##vroot = "/vpath" 
    58 test_vrf = VirtualRootFilter(vroot) 
    5946 
    6047 
    …… 
    140127    def getPage(self, url, headers=None, method="GET", body=None): 
    141128        """Open the url with debugging support. Return status, headers, body.""" 
     129        cherrypy.dispatch(httptools.parse_request_url(url)[0]) 
     130         
    142131        # Install a custom error handler, so errors in the server will: 
    143132        # 1) show server tracebacks in the test output, and 
    144133        # 2) stop the HTTP request (if any) and ignore further assertions. 
    145         cherrypy.root._cp_on_error = onerror 
     134        cherrypy.app.root._cp_on_error = onerror 
    146135        # Backward compatibility: 
    147         cherrypy.root._cpOnError = onerror 
    148          
    149         if vroot: 
    150             if url != "*": 
    151                 url = vroot + url 
    152             filters = getattr(cherrypy.root, "_cp_filters", None) 
    153             if filters is None: 
    154                 cherrypy.root._cp_filters = filters = [] 
    155             if test_vrf not in filters: 
    156                 filters.append(test_vrf) 
     136        cherrypy.app.root._cpOnError = onerror 
    157137         
    158138        if cherrypy.server.httpserver is None: 
    …… 
    196176CPTestRunner = webtest.TerseTestRunner(verbosity=2) 
    197177 
    198 def setConfig(conf): 
    199     """Set the config using a copy of conf.""" 
    200     if isinstance(conf, basestring): 
    201         # assume it's a filename 
    202         cherrypy.config.update(file=conf) 
    203     else: 
    204         cherrypy.config.update(conf.copy()) 
    205  
    206178 
    207179def run_test_suite(moduleNames, server, conf): 
    …… 
    211183    of test modules. The config, however, is reset for each module. 
    212184    """ 
    213     setConfig(conf) 
     185    cherrypy.apps = [] 
     186    cherrypy.config.serverconf = cherrypy.config.default_serverconf.copy() 
     187    cherrypy.config.serverconf.update(conf) 
    214188    cherrypy.server.start_with_callback(_run_test_suite_thread, 
    215189                                        args=(moduleNames, conf), 
    …… 
    220194        # Must run each module in a separate suite, 
    221195        # because each module uses/overwrites cherrypy globals. 
    222         cherrypy.config.reset() 
    223         setConfig(conf) 
     196        cherrypy.apps = [] 
     197        cherrypy.config.serverconf = cherrypy.config.default_serverconf.copy() 
     198        cherrypy.config.serverconf.update(conf) 
    224199         
    225200        suite = CPTestLoader.loadTestsFromName(testmod) 
     201        for app in cherrypy.apps: 
     202            app.config['global'].update({"server.environment": "production"}) 
     203         
    226204        CPTestRunner.run(suite) 
    227205    thread.interrupt_main() 
    …… 
    230208    """Run __main__ as a test module, with webtest debugging.""" 
    231209    if conf is None: 
    232         conf = {} 
    233     setConfig(conf) 
     210        conf = {'server.log_to_screen': False, 
     211                'server.log_tracebacks': False, 
     212                'server.log_file': '', 
     213                } 
     214    cherrypy.config.serverconf.update(conf) 
     215    if getattr(cherrypy.app, "config", None) is not None: 
     216        cherrypy.config.update({"server.environment": "production"}) 
    234217    cherrypy.server.start_with_callback(_test_main_thread, serverClass=server) 
    235218 
    236219def _test_main_thread(): 
    237220    try: 
    238         webtest.WebCase.PORT = cherrypy.config.get('server.socket_port') 
     221        webtest.WebCase.PORT = cherrypy.config.serverconf.get('server.socket_port') 
    239222        webtest.main() 
    240223    finally: 

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

    r891 r908  
    240240                    'server.thread_pool': 10, 
    241241                    'server.log_to_screen': False, 
    242                     'server.environment': "production", 
    243                     'server.show_tracebacks': True, 
    244242                    } 
    245243        elif isinstance(conf, basestring): 
    …… 
    288286        # would stick a second instance of webtest in sys.modules, 
    289287        # and we wouldn't be able to globally override the port anymore. 
    290         import helper, test_states 
     288        import cherrypy, helper, test_states 
    291289        s = [self.available_servers[name] for name in self.servers] 
    292290        s.sort() 
    …… 
    295293            print 
    296294            print "Running tests:", name 
     295            cherrypy.apps = [] 
     296            cherrypy.config.serverconf = cherrypy.config.default_serverconf.copy() 
     297            cherrypy.config.serverconf.update(conf) 
    297298            reload(test_states) 
    298299            test_states.run(cls, conf) 

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

    r856 r908  
    1010    index.exposed = True 
    1111 
    12 cherrypy.root = Root() 
     12cherrypy.new(root = Root()) 
    1313cherrypy.config.update({ 
    14         'server.environment': 'production', 
    15         'server.log_to_screen': False, 
    1614        'base_url_filter.on': True, 
    1715        'base_url_filter.base_url': 'http://www.mydomain.com' 
    …… 
    2422    def testBaseUrlFilter(self): 
    2523        self.getPage("/") 
    26         self.assertHeader('Location', 
    27                           "http://www.mydomain.com%s/dummy" % helper.vroot) 
     24        self.assertHeader('Location', "http://www.mydomain.com/dummy") 
    2825 
    2926 

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

    r906 r908  
    1616    index.exposed = True 
    1717 
    18 cherrypy.root = Root() 
     18cherrypy.new(root = Root()) 
    1919cherrypy.config.update({ 
    20         'server.log_to_screen': False, 
    21         'server.environment': 'production', 
    2220        'cache_filter.on': True, 
    2321}) 

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

    r856 r908  
    1414    index.exposed = True 
    1515 
    16 cherrypy.root = Root() 
     16cherrypy.new(root = Root()) 
    1717cherrypy.config.update({ 
    18         'server.log_to_screen': False, 
    19         'server.environment': 'production', 
    2018        'gzip_filter.on': True, 
    2119        'encoding_filter.on': True, 

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

    r856 r908  
    55import StringIO 
    66import cherrypy 
     7 
    78 
    89class Root: 
    …… 
    2627    prod = index 
    2728 
    28 cherrypy.root = Root() 
    29 cherrypy.root.foo = Foo() 
    30 cherrypy.root.env = Env() 
     29cherrypy.new(root = Root()) 
     30cherrypy.app.root.foo = Foo() 
     31cherrypy.app.root.env = Env() 
    3132cherrypy.config.update({ 
    32     'global': {'server.log_to_screen': False, 
    33                'server.environment': 'production', 
    34                'server.show_tracebacks': True, 
     33    'global': {'server.show_tracebacks': True, 
    3534               }, 
    3635    '/': { 
    …… 
    5958    def testConfig(self): 
    6059        tests = [ 
    61             ('*',        'luxuryyacht', 'throatwobblermangrove'), 
    6260            ('/',        'nex', 'None'), 
    6361            ('/',        'foo', 'this'), 

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

    r894 r908  
    2525    global_.exposed = True 
    2626 
    27 cherrypy.root = Root() 
     27cherrypy.new(root = Root()) 
    2828 
    2929 
    …… 
    3737            if isinstance(value, types.FunctionType): 
    3838                value.exposed = True 
    39         setattr(cherrypy.root, name.lower(), cls()) 
     39        setattr(cherrypy.app.root, name.lower(), cls()) 
    4040class Test(object): 
    4141    __metaclass__ = TestType 
    …… 
    295295    get.exposed = True 
    296296 
    297 cherrypy.root.divorce = Divorce() 
     297cherrypy.app.root.divorce = Divorce() 
    298298 
    299299 
    …… 
    330330 
    331331cherrypy.config.update({ 
    332     'global': {'server.log_to_screen': False, 
    333                'server.environment': 'production', 
    334                'server.show_tracebacks': True, 
     332    'global': {'server.show_tracebacks': True, 
    335333               }, 
    336     '/flatten': { 
    337         'server.log_file': log_file, 
    338         'server.log_access_file': log_access_file, 
    339     }, 
    340334    '/params': { 
    341335        'server.log_file': log_file, 
    …… 
    343337    '/internalredirect/secure': { 
    344338        'auth.on': True, 
    345     }, 
    346     '/error': { 
    347         'server.log_file': log_file, 
    348         'server.log_tracebacks': True, 
    349339    }, 
    350340    '/error/page_streamed': { 
    …… 
    360350        'error_page.404': "nonexistent.html", 
    361351    }, 
    362     '/error/log_unhandled': { 
    363         'server.log_tracebacks': False, 
    364         'server.log_unhandled_tracebacks': True, 
    365     }, 
    366     '/error/rethrow': { 
    367         'server.throw_errors': True, 
    368     }, 
    369352}) 
    370  
    371353 
    372354import helper 
    …… 
    431413        open(log_access_file, "wb").write("") 
    432414         
     415        cherrypy.config.serverconf.update({ 
     416            'server.log_file': log_file, 
     417            'server.log_access_file': log_access_file, 
     418        }) 
    433419        self.getPage("/flatten/as_string") 
    434420        self.assertBody('content') 
    …… 
    438424        self.assertBody('content') 
    439425        self.assertStatus('200 OK') 
     426         
     427        cherrypy.config.serverconf.update({ 
     428            'server.log_file': '', 
     429            'server.log_access_file': '', 
     430        }) 
    440431         
    441432        data = open(log_access_file, "rb").readlines() 
    …… 
    446437                haslength = True 
    447438        if haslength: 
    448             self.assert_(data[0].endswith('] "GET %s/flatten/as_string HTTP/1.1" 200 7\n' 
    449                                           % helper.vroot)) 
     439            self.assert_(data[0].endswith('] "GET /flatten/as_string HTTP/1.1" 200 7\n')) 
    450440        else: 
    451             self.assert_(data[0].endswith('] "GET %s/flatten/as_string HTTP/1.1" 200 -\n' 
    452                                           % helper.vroot)) 
     441            self.assert_(data[0].endswith('] "GET /flatten/as_string HTTP/1.1" 200 -\n')) 
    453442         
    454443        self.assertEqual(data[1][:15], '127.0.0.1 - - [') 
    …… 
    458447                haslength = True 
    459448        if haslength: 
    460             self.assert_(data[1].endswith('] "GET %s/flatten/as_yield HTTP/1.1" 200 7\n' 
    461                                           % helper.vroot)) 
     449            self.assert_(data[1].endswith('] "GET /flatten/as_yield HTTP/1.1" 200 7\n')) 
    462450        else: 
    463             self.assert_(data[1].endswith('] "GET %s/flatten/as_yield HTTP/1.1" 200 -\n' 
    464                                           % helper.vroot)) 
     451            self.assert_(data[1].endswith('] "GET /flatten/as_yield HTTP/1.1" 200 -\n')) 
    465452         
    466453        data = open(log_file, "rb").readlines() 
    …… 
    471458        try: 
    472459            # Test that tracebacks get written to the error log. 
     460            cherrypy.config.serverconf.update({ 
     461                'server.log_file': log_file, 
     462                'server.log_tracebacks': True, 
     463            }) 
    473464            self.getPage("/error/page_method") 
    474465            self.assertInBody("raise ValueError()") 
    …… 
    477468            self.assertEqual(data[6], '    raise ValueError()\n') 
    478469             
     470            cherrypy.config.serverconf.update({ 
     471                'server.log_tracebacks': False, 
     472                'server.log_unhandled_tracebacks': True, 
     473            }) 
    479474            # Test that unhandled tracebacks get written to the error log 
    480475            # if log_tracebacks is False but log_unhandled_tracebacks is True. 
    …… 
    488483        finally: 
    489484            ignore.pop() 
     485            cherrypy.config.serverconf.update({ 
     486                'server.log_file': '', 
     487                'server.log_tracebacks': False, 
     488                'server.log_unhandled_tracebacks': False, 
     489            }) 
    490490     
    491491    def testRedirect(self): 
    …… 
    499499        self.getPage("/redirect?id=3") 
    500500        self.assertStatus(('302 Found', '303 See Other')) 
    501         self.assertInBody("<a href='http://127.0.0.1:%s%s/redirect/?id=3'>" 
    502                           "http://127.0.0.1:%s%s/redirect/?id=3</a>" % 
    503                           (self.PORT, helper.vroot, self.PORT, helper.vroot)) 
    504          
    505         if helper.vroot: 
    506             # Corner case: the "trailing slash" redirect could be tricky if 
    507             # we're using a virtual root and the URI is "/vroot" (no slash). 
    508             self.getPage("") 
    509             self.assertStatus(('302 Found', '303 See Other')) 
    510             self.assertInBody("<a href='http://127.0.0.1:%s%s/'>" 
    511                               "http://127.0.0.1:%s%s/</a>" % 
    512                               (self.PORT, helper.vroot, self.PORT, helper.vroot)) 
     501        self.assertInBody("<a href='http://127.0.0.1:%s/redirect/?id=3'>" 
     502                          "http://127.0.0.1:%s/redirect/?id=3</a>" % 
     503                          (self.PORT, self.PORT)) 
    513504         
    514505        self.getPage("/redirect/by_code?code=300") 
    …… 
    569560        self.getPage("/redirect/stringify") 
    570561        self.assertStatus('200 OK') 
    571         protocol = cherrypy.config.get('server.protocol_version') 
     562        protocol = cherrypy.config.serverconf.get('server.protocol_version') 
    572563        if protocol == "HTTP/1.1": 
    573564            self.assertBody("(['http://127.0.0.1:%s/'], 303)" % self.PORT) 
    …… 
    598589             
    599590            import cherrypy 
    600             # streamResponse should be True for this path. 
     591            # http.streamResponse should be True for this path. 
    601592            if cherrypy.server.httpserver is None: 
    602593                self.assertRaises(ValueError, self.getPage, 
    …… 
    632623         
    633624        # Test server.throw_errors (ticket #186). 
     625        cherrypy.config.serverconf.update({'server.throw_errors': True}) 
    634626        httpcls = cherrypy.server.httpserverclass 
    635627        if httpcls: 
    …… 
    638630        else: 
    639631            self.assertRaises(ValueError, self.getPage, "/error/rethrow") 
     632        cherrypy.config.serverconf.update({'server.throw_errors': False}) 
    640633     
    641634    def testRanges(self): 
    642         protocol = cherrypy.config.get('server.protocol_version') 
     635        protocol = cherrypy.config.serverconf.get('server.protocol_version') 
    643636        if protocol == "HTTP/1.1": 
    644637            self.getPage("/ranges/get_ranges", [('Range', 'bytes=3-6')]) 
    …… 
    787780        self.assertStatus("501 Not Implemented") 
    788781         
    789         # Request the OPTIONS method with a Request-URI of "*". 
    790         self.getPage("*", method="OPTIONS") 
    791         self.assertStatus("200 OK") 
    792         # Content-Length header required for OPTIONS with no response body. 
    793         # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.2 
    794         self.assertHeader("Content-Length", "0") 
    795          
    796         # Now be really dastardly and delete our custom global_ handler, 
    797         # to see if the default one works. 
    798         del Root.global_ 
    799         self.getPage("*", method="OPTIONS") 
    800         self.assertStatus("200 OK") 
    801         self.assertHeader("Allow", 'HEAD, GET, POST, PUT, OPTIONS') 
    802          
    803782        # For method dispatchers: make sure that an HTTP method doesn't 
    804783        # collide with a virtual path atom. If you build HTTP-method 
    …… 
    821800        self.getPage("/favicon.ico") 
    822801        self.assertBody(data) 
    823          
    824         self.getPage("/favicon.ico") 
    825         self.assertBody(data) 
    826802     
    827803    def testCookies(self): 
    …… 
    842818        httpcls = cherrypy.server.httpserverclass 
    843819        if httpcls: 
    844             cherrypy.config.update({'server.max_request_header_size': 10}) 
     820            cherrypy.config.serverconf.update({'server.max_request_header_size': 10}) 
    845821            self.getPage("/maxrequestsize/index") 
    846822            self.assertStatus("413 Request Entity Too Large") 
    847823            self.assertInBody("Request Entity Too Large") 
    848             cherrypy.config.update({'server.max_request_header_size': 0}) 
     824            cherrypy.config.serverconf.update({'server.max_request_header_size': 0}) 
    849825             
    850826            # Test for http://www.cherrypy.org/ticket/421 
    …… 
    871847        httpcls = cherrypy.server.httpserverclass 
    872848        if httpcls: 
    873             cherrypy.config.update({ 
    874                 '%s/maxrequestsize' % helper.vroot: {'server.max_request_body_size': 3}}) 
     849            cherrypy.config.serverconf.update({'server.max_request_body_size': 3}) 
    875850            self.getPage('/maxrequestsize/upload', h, "POST", b) 
    876851            self.assertStatus("413 Request Entity Too Large") 
    …… 
    888863        self.assertHeader('Content-Type', 'text/html') 
    889864         
    890         cherrypy.config.update({'server.default_content_type': 'text/plain'}) 
     865        cherrypy.config.serverconf.update({'server.default_content_type': 'text/plain'}) 
    891866        self.getPage('/') 
    892867        self.assertHeader('Content-Type', 'text/plain') 

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

    r903 r908  
    77import cherrypy 
    88from cherrypy import filters 
    9 from cherrypy.filters.basefilter import BaseFilter 
    10  
    11  
    12 class Numerify(BaseFilter): 
    13      
    14     def before_finalize(self): 
    15         if not cherrypy.config.get("numerify_filter.on", False): 
    16             return 
    17          
    18         def number_it(body): 
    19             for chunk in body: 
    20                 chunk = chunk.replace("pie", "3.14159") 
    21                 yield chunk 
    22         cherrypy.response.body = number_it(cherrypy.response.body) 
    23  
    24  
    25 class AccessFilter(BaseFilter): 
    26      
    27     def before_request_body(self): 
    28         if not cherrypy.config.get("access_filter.on", False): 
    29             return 
    30          
    31         if not getattr(cherrypy.request, "login", None): 
    32             raise cherrypy.HTTPError(401) 
    33  
    34  
    35 # It's not mandatory to inherit from BaseFilter. 
    36 class NadsatFilter: 
    37      
    38     def before_finalize(self): 
    39         self.ended = False 
    40         def nadsat_it_up(body): 
    41             for chunk in body: 
    42                 chunk = chunk.replace("good", "horrorshow") 
    43                 chunk = chunk.replace("piece", "lomtick") 
    44                 yield chunk 
    45         cherrypy.response.body = nadsat_it_up(cherrypy.response.body) 
    46      
    47     def on_end_request(self): 
    48         # This runs after the request has been completely written out. 
    49         cherrypy.response.body = "razdrez" 
    50         self.ended = True 
    51  
     9from custom_filters import NadsatFilter, Numerify 
    5210 
    5311 
    …… 
    5715    index.exposed = True 
    5816 
    59 cherrypy.root = Root() 
     17cherrypy.new(root = Root()) 
    6018 
    6119 
    …… 
    6927            if isinstance(value, types.FunctionType): 
    7028                value.exposed = True 
    71         setattr(cherrypy.root, name.lower(), cls()) 
     29        setattr(cherrypy.app.root, name.lower(), cls()) 
    7230class Test(object): 
    7331    __metaclass__ = TestType 
    …… 
    9553 
    9654cherrypy.config.update({ 
    97     'global': { 
     55    'server': { 
    9856        # METHOD TWO: 
    9957        # Declare a classname in server.input_filters. 
    100         'server.input_filters': ["cherrypy.test.test_custom_filters.AccessFilter"], 
    101         'server.log_to_screen': False, 
    102         'server.environment': 'production', 
     58        'server.input_filters': ["cherrypy.test.custom_filters.AccessFilter"], 
     59    }, 
     60    'global': { 
    10361        'server.show_tracebacks': True, 
    10462    }, 
    …… 
    13391    def testCPFilterList(self): 
    13492        # Lazily import _nf, since filters.__init__ will reimport this module. 
    135         _nf = cherrypy.root.cpfilterlist._cp_filters[0] 
     93        _nf = cherrypy.apps[0].root.cpfilterlist._cp_filters[0] 
    13694         
    13795        self.getPage("/cpfilterlist/") 

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

    r876 r908  
    1515    mao_zedong.exposed = True 
    1616 
    17 cherrypy.root = Root() 
     17cherrypy.new(root = Root()) 
    1818cherrypy.config.update({ 
    19         'server.log_to_screen': False, 
    20         'server.environment': 'production', 
    2119        'encoding_filter.on': True, 
    2220        'decoding_filter.on': True 

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

    r856 r908  
    2424    noshow_stream.exposed = True 
    2525 
    26 cherrypy.root = Root() 
     26cherrypy.new(root = Root()) 
    2727cherrypy.config.update({ 
    28     'global': {'server.log_to_screen': False, 
    29                'server.environment': 'production', 
    30                'server.show_tracebacks': True, 
     28    'global': {'server.show_tracebacks': True, 
    3129               'gzip_filter.on': True, 
    3230               }, 

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

    r856 r908  
    1313    bug326.exposed = True 
    1414 
    15 cherrypy.root = Root() 
     15cherrypy.new(root = Root()) 
    1616 
    1717cherrypy.config.update({ 
    18         'server.log_to_screen': False, 
    19         'server.environment': 'production', 
    2018        'log_debug_info_filter.on': True, 
    2119}) 
    …… 
    4745""" 
    4846            cherrypy.config.update({ 
    49                 ('%s/bug326' % helper.vroot): { 
     47                '/bug326': { 
    5048                    'server.max_request_body_size': 3, 
    5149                    'server.environment': 'development', 

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

    r778 r908  
    1616 
    1717import cherrypy 
    18 from cherrypy import _cpwsgi 
     18 
    1919 
    2020class HelloWorld: 
    …… 
    2424    wsgi_asp = index 
    2525 
    26 cherrypy.root = HelloWorld() 
    27 cherrypy.root.test = HelloWorld() 
     26r = HelloWorld() 
     27cherrypy.new(r) 
     28r.test = HelloWorld() 
    2829 
    2930cherrypy.config.update({"server.environment": "production"}) 

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

    r886 r908  
    8888        return "index for dir4, not exposed" 
    8989 
    90 cherrypy.root = Root() 
    91 cherrypy.root.exposing = Exposing() 
    92 cherrypy.root.exposingnew = ExposingNewStyle() 
    93 cherrypy.root.dir1 = Dir1() 
    94 cherrypy.root.dir1.dir2 = Dir2() 
    95 cherrypy.root.dir1.dir2.dir3 = Dir3() 
    96 cherrypy.root.dir1.dir2.dir3.dir4 = Dir4() 
     90def get_tree(): 
     91    root = Root() 
     92    root.exposing = Exposing() 
     93    root.exposingnew = ExposingNewStyle() 
     94    root.dir1 = Dir1() 
     95    root.dir1.dir2 = Dir2() 
     96    root.dir1.dir2.dir3 = Dir3() 
     97    root.dir1.dir2.dir3.dir4 = Dir4() 
     98    return root 
     99 
     100app = cherrypy.Application() 
     101cherrypy.use(app) 
     102app.root = get_tree() 
     103# config.update will inspect cherrypy.app (a threadlocal) 
     104# to update the appropriate app's config. 
    97105cherrypy.config.update({ 
    98         'server.log_to_screen': False, 
    99         'server.environment': "production", 
     106        'http.mount_point': "/", 
    100107}) 
    101108 
     109cherrypy.new(root=get_tree()) 
     110cherrypy.config.update({ 
     111        'http.mount_point': "/app2", 
     112}) 
     113 
    102114 
    103115import helper 
    104116 
     117def urljoin(*atoms): 
     118    url = "/".join(atoms) 
     119    while "//" in url: 
     120        url = url.replace("//", "/") 
     121    return url 
     122 
     123 
    105124class ObjectMappingTest(helper.CPWebCase): 
    106125     
    107126    def testObjectMapping(self): 
    108         self.getPage('/') 
    109         self.assertBody('world') 
    110          
    111         self.getPage("/dir1/myMethod") 
    112         self.assertBody("myMethod from dir1, object Path is:'/dir1/myMethod'") 
    113          
    114         self.getPage("/this/method/does/not/exist") 
    115         self.assertBody("default:('this', 'method', 'does', 'not', 'exist')") 
    116          
    117         self.getPage("/extra/too/much") 
    118         self.assertBody("('too', 'much')") 
    119          
    120         self.getPage("/other") 
    121         self.assertBody('other') 
    122          
    123         self.getPage("/notExposed") 
    124         self.assertBody("default:('notExposed',)") 
    125          
    126         self.getPage("/dir1/dir2/") 
    127         self.assertBody('index for dir2, path is:%s/dir1/dir2/' % helper.vroot) 
    128          
    129         self.getPage("/dir1/dir2") 
    130         self.assert_(self.status in ('302 Found', '303 See Other')) 
    131         self.assertHeader('Location', 'http://%s:%s%s/dir1/dir2/' 
    132                           % (self.HOST, self.PORT, helper.vroot)) 
    133          
    134         self.getPage("/dir1/dir2/dir3/dir4/index") 
    135         self.assertBody("default for dir1, param is:('dir2', 'dir3', 'dir4', 'index')") 
    136          
    137         self.getPage("/redirect") 
    138         self.assertStatus('302 Found') 
    139         self.assertHeader('Location', 'http://%s:%s%s/dir1/' 
    140                           % (self.HOST, self.PORT, helper.vroot)) 
    141          
    142         # Test that we can use URL's which aren't all valid Python identifiers 
    143         # This should also test the %XX-unquoting of URL's. 
    144         self.getPage("/Von%20B%fclow?ID=14") 
    145         self.assertBody("ID is 14") 
    146          
    147         # Test that %2F in the path doesn't get unquoted too early; 
    148         # that is, it should not be used to separate path components. 
    149         # See ticket #393. 
    150         self.getPage("/page%2Fname") 
    151         self.assertBody("default:('page/name',)") 
     127        def getPage(path): 
     128            return self.getPage(urljoin(mount_point, path)) 
     129         
     130        for mount_point in ("/", "/app2"): 
     131            getPage('/') 
     132            self.assertBody('world') 
     133             
     134            getPage("/dir1/myMethod") 
     135            self.assertBody("myMethod from dir1, object Path is:'/dir1/myMethod'") 
     136             
     137            getPage("/this/method/does/not/exist") 
     138            self.assertBody("default:('this', 'method', 'does', 'not', 'exist')") 
     139             
     140            getPage("/extra/too/much") 
     141            self.assertBody("('too', 'much')") 
     142             
     143            getPage("/other") 
     144            self.assertBody('other') 
     145             
     146            getPage("/notExposed") 
     147            self.assertBody("default:('notExposed',)") 
     148             
     149            d1d2 = "/dir1/dir2/" 
     150            getPage(d1d2) 
     151            self.assertBody('index for dir2, path is:%s' % 
     152                            urljoin(mount_point, d1d2)) 
     153             
     154            getPage("/dir1/dir2") 
     155            self.assert_(self.status in ('302 Found', '303 See Other')) 
     156            self.assertHeader('Location', 'http://%s:%s%s' 
     157                              % (self.HOST, self.PORT, 
     158                                 urljoin(mount_point, d1d2))) 
     159             
     160            getPage("/dir1/dir2/dir3/dir4/index") 
     161            self.assertBody("default for dir1, param is:('dir2', 'dir3', 'dir4', 'index')") 
     162             
     163            getPage("/redirect") 
     164            self.assertStatus('302 Found') 
     165            self.assertHeader('Location', 'http://%s:%s%s' 
     166                              % (self.HOST, self.PORT, 
     167                                 urljoin(mount_point, "/dir1/"))) 
     168             
     169            # Test that we can use URL's which aren't all valid Python identifiers 
     170            # This should also test the %XX-unquoting of URL's. 
     171            getPage("/Von%20B%fclow?ID=14") 
     172            self.assertBody("ID is 14") 
     173             
     174            # Test that %2F in the path doesn't get unquoted too early; 
     175            # that is, it should not be used to separate path components. 
     176            # See ticket #393. 
     177            getPage("/page%2Fname") 
     178            self.assertBody("default:('page/name',)") 
    152179     
    153180    def testPositionalParams(self): 

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

    r872 r908  
    1515        return "salut" 
    1616    other.exposed = True 
    17      
    18 cherrypy.root = Root() 
     17 
     18cherrypy.new(root = Root()) 
     19cherrypy.config.update({ 
     20    '/other': { 
     21        'response_headers_filter.on': True, 
     22        'response_headers_filter.headers': [("Content-Language", "fr"), 
     23                                            ('Content-Type', 'text/plain')] 
     24        }, 
     25    }) 
     26 
    1927 
    2028import helper 
    …… 
    2836 
    2937    def testResponseHeadersFilter(self): 
    30         cherrypy.config.update({'/other': { 
    31             'response_headers_filter.on': True, 
    32             'response_headers_filter.headers': [("Content-Language", "fr"), 
    33                                                 ('Content-Type', 'text/plain')] 
    34         }}) 
    3538        self.getPage('/other') 
    3639        self.assertHeader("Content-Language", "fr") 

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

    r856 r908  
    1616    testStr.exposed = True 
    1717     
    18 cherrypy.root = Root() 
     18cherrypy.new(root = Root()) 
    1919cherrypy.config.update({ 
    20         'server.log_to_screen': False, 
    21         'server.environment': 'production', 
    2220        'session_filter.on': True, 
    2321        'session_filter.storage_type' : 'file', 

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

    r871 r908  
    99    index.exposed = True 
    1010 
    11 cherrypy.root = Test() 
     11cherrypy.new(root = Test()) 
     12cherrypy.config.update({ 
     13        'session_filter.on': True, 
     14        'session_authenticate_filter.on': True, 
     15        }) 
    1216 
    13 cherrypy.config.update({ 
    14         'server.log_to_screen': False, 
    15         'server.environment': 'production', 
    16         'session_filter.on': True, 
    17 }) 
    1817 
    19 cherrypy.config.update({'/': 
    20                         {'session_authenticate_filter.on':True, 
    21                          } 
    22                         }) 
    2318import helper 
    2419 
    …… 
    2621     
    2722    def testSessionAuthenticateFilter(self): 
    28         protocol = cherrypy.config.get('server.protocol_version') 
     23        protocol = cherrypy.config.serverconf.get('server.protocol_version') 
    2924        # request a page and check for login form 
    3025        self.getPage('/') 

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

    r897 r908  
    2121    restart.exposed = True 
    2222 
    23 cherrypy.root = Root() 
     23cherrypy.new(root = Root()) 
    2424cherrypy.config.update({ 
    25     'global': { 
    26         'server.log_to_screen': False, 
    27         'server.environment': 'production', 
    28     }, 
    29 }) 
     25    'server': {'server.log_to_screen': False}, 
     26    'server.environment': 'production', 
     27    }) 
    3028 
    3129class Dependency: 
    …… 
    6967         
    7068        if self.serverClass: 
    71             host = cherrypy.config.get('server.socket_host') 
    72             port = cherrypy.config.get('server.socket_port') 
     69            host = cherrypy.config.serverconf.get('server.socket_host') 
     70            port = cherrypy.config.serverconf.get('server.socket_port') 
    7371            self.assertRaises(IOError, cherrypy._cpserver.check_port, host, port) 
    7472         
    …… 
    176174 
    177175def run(server, conf): 
    178     helper.setConfig(conf) 
     176    cherrypy.config.serverconf.update(conf) 
     177    cherrypy.config.update({'server.environment': 'production'}) 
    179178    ServerStateTests.serverClass = server 
    180179    suite = helper.CPTestLoader.loadTestsFromTestCase(ServerStateTests) 

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

    r900 r908  
    2323 
    2424 
    25 cherrypy.root = Root() 
    26 cherrypy.root.static = Static() 
     25cherrypy.new(root = Root()) 
     26cherrypy.app.root.static = Static() 
    2727 
    2828cherrypy.config.update({ 
    2929    'global': { 
    3030        'static_filter.on': False, 
    31         'server.log_to_screen': False, 
    32         'server.environment': 'production', 
    3331    }, 
    3432    '/static': { 
    …… 
    5149    }, 
    5250}) 
     51 
    5352 
    5453import helper 

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

    r899 r908  
    1212    def load_tut_module(self, tutorialName): 
    1313        """Import or reload tutorial module as needed.""" 
    14         cherrypy.config.reset() 
     14         
     15        cherrypy.apps = [] 
    1516         
    1617        target = "cherrypy.tutorial." + tutorialName 
    …… 
    2021            module = __import__(target, globals(), locals(), ['']) 
    2122         
    22         cherrypy.config.update({'server.socket_host': self.HOST, 
    23                                 'server.socket_port': self.PORT, 
    24                                 'server.thread_pool': 10, 
    25                                 'server.log_to_screen': False, 
    26                                 'server.environment': "production", 
    27                                 }) 
     23        cherrypy.config.update({'server.environment': 'production'}) 
    2824     
    2925    def test01HelloWorld(self): 
    …… 
    160156        self.getPage("/toggleTracebacks") 
    161157        self.assertEqual(cherrypy.config.get('server.show_tracebacks'), not tracebacks) 
    162         self.assertStatus("302 Found") 
     158        self.assertStatus(('302 Found', '303 See Other')) 
    163159         
    164160        self.getPage("/error?code=500") 

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

    r883 r908  
    2323 
    2424 
    25 cherrypy.root = Root() 
    26 cherrypy.root.mydom2 = VHost("Domain 2") 
    27 cherrypy.root.mydom3 = VHost("Domain 3") 
     25r = Root() 
     26cherrypy.new(r) 
     27r.mydom2 = VHost("Domain 2") 
     28r.mydom3 = VHost("Domain 3") 
    2829 
    2930cherrypy.config.update({ 
    30         'server.logToScreen': False, 
    31         'server.environment': 'production', 
    3231        'virtual_host_filter.on': True, 
    3332        'virtual_host_filter.www.mydom2.com': '/mydom2', 
    …… 
    3534        'virtual_host_filter.www.mydom4.com': '/dom4', 
    3635}) 
     36 
    3737 
    3838import helper 

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

    r856 r908  
    5252    test_argument_passing.exposed = True 
    5353 
    54 cherrypy.root = Root() 
    55 cherrypy.root.xmlrpc = XmlRpc() 
     54r = Root() 
     55cherrypy.new(r) 
     56r.xmlrpc = XmlRpc() 
    5657 
    5758 
    …… 
    5960 
    6061cherrypy.config.update({ 
    61     'global': {'server.log_to_screen': False, 
    62                'server.environment': 'production', 
    63                'server.show_tracebacks': True, 
    64                'server.socket_host': helper.CPWebCase.HOST, 
    65                'server.socket_port': helper.CPWebCase.PORT, 
    66                }, 
    67     '/xmlrpc': {'xmlrpc_filter.on':True}, 
     62    'server': { 
     63       'server.socket_host': helper.CPWebCase.HOST, 
     64       'server.socket_port': helper.CPWebCase.PORT, 
     65       }, 
     66    'global': {'server.show_tracebacks': True}, 
     67    '/xmlrpc': {'xmlrpc_filter.on': True}, 
    6868    }) 
    6969 
    …… 
    136136 
    137137if __name__ == '__main__': 
    138     from cherrypy import _cpwsgi 
    139     serverClass = _cpwsgi.WSGIServer 
    140     helper.testmain(serverClass) 
     138    helper.testmain("cherrypy._cpwsgi.WSGIServer") 
    141139 

  • branches/multiapp/cherrypy/tutorial/bonus-sqlobject.py

    r762 r908  
    166166print "If you're running this application for the first time, please go to http://localhost:8080/reset once in order to create the database!" 
    167167 
    168 cherrypy.root = ContactManager() 
     168cherrypy.new(root = ContactManager()) 
    169169cherrypy.server.start() 

  • branches/multiapp/cherrypy/tutorial/tut01_helloworld.py

    r762 r908  
    2525# to objects, so we need to mount a request handler object here. A request 
    2626# to '/' will be mapped to cherrypy.root.index(). 
    27 cherrypy.root = HelloWorld() 
     27cherrypy.new(root = HelloWorld()) 
    2828 
    2929if __name__ == '__main__': 

  • branches/multiapp/cherrypy/tutorial/tut02_expose_methods.py

    r762 r908  
    2020    showMessage.exposed = True 
    2121 
    22 cherrypy.root = HelloWorld() 
     22cherrypy.new(root = HelloWorld()) 
    2323 
    2424if __name__ == '__main__': 

  • branches/multiapp/cherrypy/tutorial/tut03_get_and_post.py

    r762 r908  
    4141 
    4242 
    43 cherrypy.root = WelcomePage() 
     43cherrypy.new(root = WelcomePage()) 
    4444 
    4545 

  • branches/multiapp/cherrypy/tutorial/tut04_complex_site.py

    r762 r908  
    7575 
    7676# Of course we can also mount request handler objects right here! 
    77 cherrypy.root = HomePage() 
    78 cherrypy.root.joke = JokePage() 
    79 cherrypy.root.links = LinksPage() 
     77cherrypy.new(root = HomePage()) 
     78cherrypy.app.root.joke = JokePage() 
     79cherrypy.app.root.links = LinksPage() 
    8080 
    8181# Remember, we don't need to mount ExtraLinksPage here, because 

  • branches/multiapp/cherrypy/tutorial/tut05_derived_objects.py

    r762 r908  
    7070 
    7171 
    72 cherrypy.root = HomePage() 
     72cherrypy.new(root = HomePage()) 
    7373 
    7474 

  • branches/multiapp/cherrypy/tutorial/tut06_default_method.py

    r762 r908  
    5151 
    5252 
    53 cherrypy.root = UsersPage() 
     53cherrypy.new(root = UsersPage()) 
    5454 
    5555 

  • branches/multiapp/cherrypy/tutorial/tut07_sessions.py

    r856 r908  
    2828 
    2929 
    30 cherrypy.root = HitCounter() 
     30cherrypy.new(root = HitCounter()) 
    3131cherrypy.config.update({'session_filter.on': True}) 
    3232 

  • branches/multiapp/cherrypy/tutorial/tut08_generators_and_yield.py

    r762 r908  
    3333    index.exposed = True 
    3434 
    35 cherrypy.root = GeneratorDemo() 
     35cherrypy.new(root = GeneratorDemo()) 
    3636 
    3737 

  • branches/multiapp/cherrypy/tutorial/tut09_files.py

    r762 r908  
    8787 
    8888 
    89 cherrypy.root = FileDemo() 
     89cherrypy.new(root = FileDemo()) 
    9090 
    9191if __name__ == '__main__': 

  • branches/multiapp/cherrypy/tutorial/tut10_http_errors.py

    r856 r908  
    6262 
    6363 
    64 cherrypy.root = HTTPErrorDemo() 
     64cherrypy.new(root = HTTPErrorDemo()) 
    6565 
    6666# Set a custom response for 403 errors. 

  • branches/multiapp/cherrypy/tutorial/tutorial.conf

    r650 r908  
    1 [global] 
     1[server] 
    22server.socketPort = 8080 
    33server.threadPool = 10 
     4 
     5[global] 
    46server.environment = "production" 
    57# server.showTracebacks = True 

Hosted by WebFaction

Log in as guest/cpguest to create tickets