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

Changeset 856

Show
Ignore:
Timestamp:
12/03/05 12:44:11
Author:
rdelon
Message:

Big change: camelCase to lower_with_underscore names (still need to update the book)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/CHANGELOG.txt

    r744 r856  
     12005-12-03: 
     2    * Huge change: switching to lowercase_with_underscore names everywhere ... CP keeps backward compatibility though (remi) 
     3 
    142005-10-21: 
    25    * CherryPy-2.1.0 released 

  • trunk/cherrypy/__init__.py

    r835 r856  
    4848response = _ThreadLocalProxy('response') 
    4949 
    50 # Create threadData object as a thread-specific all-purpose storage 
    51 threadData = local() 
     50# Create thread_data object as a thread-specific all-purpose storage 
     51thread_data = local() 
     52threadData = thread_data # Backward compatibility 
    5253 
    5354# Create variables needed for session (see lib/sessionfilter.py for more info) 
    5455from filters import sessionfilter 
    5556session = sessionfilter.SessionWrapper() 
    56 _sessionDataHolder = {} # Needed for RAM sessions only 
    57 _sessionLockDict = {} # Needed for RAM sessions only 
    58 _sessionLastCleanUpTime = datetime.datetime.now() 
     57_session_data_holder = {} # Needed for RAM sessions only 
     58_session_lock_dict = {} # Needed for RAM sessions only 
     59_session_last_clean_up_time = datetime.datetime.now() 
    5960 
    6061def expose(func=None, alias=None): 
    …… 
    6566        if alias is not None: 
    6667            if isinstance(alias, basestring): 
    67                 parentDict[alias] = func 
     68                parents[alias] = func 
    6869            else: 
    6970                for a in alias: 
    70                     parentDict[a] = func 
     71                    parents[a] = func 
    7172        return func 
    7273     
    73     parentDict = sys._getframe(1).f_locals 
     74    parents = sys._getframe(1).f_locals 
    7475    if isinstance(func, (types.FunctionType, types.MethodType)): 
    7576        # expose is being called directly, before the method has been bound 
    …… 
    8687    # to allow profiler and coverage tools to work on it. 
    8788    import _cputil 
    88     logfunc = _cputil.getSpecialAttribute('_cpLogMessage') 
     89    logfunc = _cputil.get_special_attribute('_cp_log_message', '_cpLogMessage') 
    8990    logfunc(msg, context, severity) 
    9091 

  • trunk/cherrypy/_cperror.py

    r839 r856  
    2121    """Exception raised when processing should be handled by a different path. 
    2222     
    23     If you supply 'params', it will be used to re-populate paramMap. 
     23    If you supply 'params', it will be used to re-populate params. 
    2424    If 'params' is a dict, it will be used directly. 
    2525    If 'params' is a string, it will be converted to a dict using cgi.parse_qs. 
    2626     
    27     If you omit 'params', the paramMap from the original request will 
     27    If you omit 'params', the params from the original request will 
    2828    remain in effect, including any POST parameters. 
    2929    """ 
    …… 
    4545                    if len(val) == 1: 
    4646                        pm[key] = val[0] 
    47                 request.paramMap = pm 
     47                request.params = pm 
    4848            else: 
    4949                request.queryString = urllib.urlencode(params) 
    50                 request.paramMap = params.copy() 
     50                request.params = params.copy() 
    5151         
    5252        Exception.__init__(self, path, params) 
    …… 
    101101        response = cherrypy.response 
    102102        response.status = status = self.status 
    103         response.headerMap['Content-Type'] = "text/html" 
     103        response.headers['Content-Type'] = "text/html" 
    104104         
    105105        if status in (300, 301, 302, 303, 307): 
    106106            # "The ... URI SHOULD be given by the Location field 
    107107            # in the response." 
    108             response.headerMap['Location'] = self.urls[0] 
     108            response.headers['Location'] = self.urls[0] 
    109109             
    110110            # "Unless the request method was HEAD, the entity of the response 
    …… 
    129129            # Use Proxy. 
    130130            # self.urls[0] should be the URI of the proxy. 
    131             response.headerMap['Location'] = self.urls[0] 
     131            response.headers['Location'] = self.urls[0] 
    132132            response.body = None 
    133133        else: 
    …… 
    152152    def set_response(self): 
    153153        import cherrypy 
    154         handler = cherrypy._cputil.getSpecialAttribute("_cpOnHTTPError") 
     154        handler = cherrypy._cputil.get_special_attribute("_cp_on_http_error", "_cpOnHTTPError") 
    155155        handler(self.status, self.message) 
    156156 

  • trunk/cherrypy/_cphttpserver.py

    r851 r856  
    1818     
    1919    def address_string(self): 
    20         """ Try to do a reverse DNS based on server.reverseDNS in the config file """ 
    21         if cherrypy.config.get('server.reverseDNS'): 
     20        """ Try to do a reverse DNS based on server.reverse_dns in the config file """ 
     21        if cherrypy.config.get('server.reverse_dns'): 
    2222            return BaseHTTPRequestHandler.address_string(self) 
    2323        else: 
    …… 
    4242    def parse_request(self): 
    4343        # Extended to provide header and body length limits. 
    44         mhs = int(cherrypy.config.get('server.maxRequestHeaderSize', 
     44        mhs = int(cherrypy.config.get('server.max_request_header_size', 
    4545                                      500 * 1024)) 
    4646        self.rfile = httptools.SizeCheckWrapper(self.rfile, mhs) 
    …… 
    6060                if path == "*": 
    6161                    path = "global" 
    62                 mbs = int(cherrypy.config.get('server.maxRequestBodySize', 
     62                mbs = int(cherrypy.config.get('server.max_request_body_size', 
    6363                                              100 * 1024 * 1024, path=path)) 
    6464                self.rfile.maxlen = mbs 
    …… 
    7979            request = cherrypy.server.request(self.client_address, 
    8080                                              self.address_string(), "http") 
    81             request.multithread = cherrypy.config.get("server.threadPool") > 1 
     81            request.multithread = cherrypy.config.get("server.thread_pool") > 1 
    8282            request.multiprocess = False 
    8383            response = request.run(self.raw_requestline, self._headerlist(), 
    …… 
    9090            tb = _cputil.formatExc() 
    9191            cherrypy.log(tb) 
    92             if not cherrypy.config.get("server.showTracebacks", False): 
     92            if not cherrypy.config.get("server.show_tracebacks", False): 
    9393                tb = "" 
    9494            s, h, b = _cputil.bareError(tb) 
    …… 
    175175         
    176176        # Set protocol_version 
    177         httpproto = cherrypy.config.get('server.protocolVersion') or "HTTP/1.0" 
     177        httpproto = cherrypy.config.get('server.protocol_version') or "HTTP/1.0" 
    178178        self.RequestHandlerClass.protocol_version = httpproto 
    179179         
    180         self.request_queue_size = cherrypy.config.get('server.socketQueueSize') 
     180        self.request_queue_size = cherrypy.config.get('server.socket_queue_size') 
    181181         
    182182        # Select the appropriate server based on config options 
    183         sockFile = cherrypy.config.get('server.socketFile') 
     183        sockFile = cherrypy.config.get('server.socket_file') 
    184184        if sockFile: 
    185185            # AF_UNIX socket 
    …… 
    199199        else: 
    200200            # AF_INET or AF_INET6 socket 
    201             host = cherrypy.config.get('server.socketHost') 
    202             port = cherrypy.config.get('server.socketPort') 
     201            host = cherrypy.config.get('server.socket_host') 
     202            port = cherrypy.config.get('server.socket_port') 
    203203            self.server_address = (host, port) 
    204204             
    …… 
    307307     
    308308    def __init__(self): 
    309         self.numThreads = cherrypy.config.get('server.threadPool') 
     309        self.numThreads = cherrypy.config.get('server.thread_pool') 
    310310        self.ThreadClass = ServerThread 
    311311        self.requestQueue = Queue.Queue() 
    …… 
    392392     
    393393    # Select the appropriate server based on config options 
    394     if cherrypy.config.get('server.threadPool', 1) > 1: 
     394    if cherrypy.config.get('server.thread_pool', 1) > 1: 
    395395        ServerClass = PooledThreadServer 
    396396    else: 

  • trunk/cherrypy/_cphttptools.py

    r851 r856  
    3434            self.closed = True 
    3535            try: 
    36                 applyFilters('onEndRequest') 
     36                applyFilters('on_end_request', 'onEndRequest') 
    3737            except (KeyboardInterrupt, SystemExit): 
    3838                raise 
    …… 
    5858        """ 
    5959        self.requestLine = requestLine.strip() 
    60         self.headers = list(headers) 
     60        self.header_list = list(headers) 
    6161        self.rfile = rfile 
    6262         
    …… 
    7070         
    7171        try: 
    72             self.headerMap = httptools.HeaderMap() 
     72            self.headers = httptools.HeaderMap() 
     73            self.headerMap = self.headers # Backward compatibility 
    7374            self.simpleCookie = Cookie.SimpleCookie() 
    7475             
    …… 
    7980             
    8081            try: 
    81                 applyFilters('onStartResource') 
     82                applyFilters('on_start_resource', 'onStartResource') 
    8283                 
    8384                try: 
    8485                    self.processHeaders() 
    8586                     
    86                     applyFilters('beforeRequestBody') 
     87                    applyFilters('before_request_body', 'beforeRequestBody') 
    8788                    if self.processRequestBody: 
    8889                        self.processBody() 
    8990                     
    90                     applyFilters('beforeMain') 
     91                    applyFilters('before_main', 'beforeMain') 
    9192                    if self.executeMain: 
    9293                        self.main() 
    9394                     
    94                     applyFilters('beforeFinalize') 
     95                    applyFilters('before_finalize', 'beforeFinalize') 
    9596                    cherrypy.response.finalize() 
    9697                except cherrypy.RequestHandled: 
    …… 
    101102                    # we return the redirect or error page immediately 
    102103                    inst.set_response() 
    103                     applyFilters('beforeFinalize') 
     104                    applyFilters('before_finalize', 'before_finalize') 
    104105                    cherrypy.response.finalize() 
    105106            finally: 
    106                 applyFilters('onEndResource') 
     107                applyFilters('on_end_resource', 'onEndResource') 
    107108        except (KeyboardInterrupt, SystemExit): 
    108109            raise 
    …… 
    114115            cherrypy.response.body = [] 
    115116         
    116         _cputil.getSpecialAttribute("_cpLogAccess")() 
     117        _cputil.get_special_attribute("_cp_log_access", "_cpLogAccess")() 
    117118     
    118119    def processRequestLine(self): 
    …… 
    149150        # cherrypy.request.version == request.protocol in a Version instance. 
    150151        self.version = httptools.Version.from_http(self.protocol) 
    151         server_v = cherrypy.config.get("server.protocolVersion", "HTTP/1.0") 
     152        server_v = cherrypy.config.get("server.protocol_version", "HTTP/1.0") 
    152153        server_v = httptools.Version.from_http(server_v) 
    153154         
    …… 
    158159    def processHeaders(self): 
    159160         
    160         self.paramMap = httptools.parseQueryString(self.queryString) 
    161          
    162         # Process the headers into self.headerMap 
    163         for name, value in self.headers: 
     161        self.params = httptools.parseQueryString(self.queryString) 
     162        self.paramMap = self.params # Backward compatibility 
     163         
     164        # Process the headers into self.headers 
     165        for name, value in self.header_list: 
    164166            value = value.strip() 
    165167            # Warning: if there is more than one header entry for cookies (AFAIK, 
    166             # only Konqueror does that), only the last one will remain in headerMap 
     168            # only Konqueror does that), only the last one will remain in headers 
    167169            # (but they will be correctly stored in request.simpleCookie). 
    168             self.headerMap[name] = value 
     170            self.headers[name] = value 
    169171             
    170172            # Handle cookies differently because on Konqueror, multiple 
    …… 
    175177        # Save original values (in case they get modified by filters) 
    176178        # This feature is deprecated in 2.2 and will be removed in 2.3. 
    177         self._originalParamMap = self.paramMap.copy() 
     179        self._original_params = self.params.copy() 
    178180         
    179181        if self.version >= "1.1": 
    …… 
    181183            # (Bad Request) status code to any HTTP/1.1 request message 
    182184            # which lacks a Host header field. 
    183             if not self.headerMap.has_key("Host"): 
     185            if not self.headers.has_key("Host"): 
    184186                msg = "HTTP/1.1 requires a 'Host' request header." 
    185187                raise cherrypy.HTTPError(400, msg) 
    186         self.base = "%s://%s" % (self.scheme, self.headerMap.get('Host', '')) 
    187      
    188     def _get_original_param_map(self): 
     188        self.base = "%s://%s" % (self.scheme, self.headers.get('Host', '')) 
     189     
     190    def _get_original_params(self): 
    189191        # This feature is deprecated in 2.2 and will be removed in 2.3. 
    190         return self._originalParamMap 
    191     originalParamMap = property(_get_original_param_map, 
    192                         doc="Deprecated. A copy of the original paramMap.") 
     192        return self._original_params 
     193    original_params = property(_get_original_params, 
     194                        doc="Deprecated. A copy of the original params.") 
    193195     
    194196    def _get_browserUrl(self): 
    …… 
    201203     
    202204    def processBody(self): 
    203         # Create a copy of headerMap with lowercase keys because 
     205        # Create a copy of headers with lowercase keys because 
    204206        # FieldStorage doesn't work otherwise 
    205207        lowerHeaderMap = {} 
    206         for key, value in self.headerMap.items(): 
     208        for key, value in self.headers.items(): 
    207209            lowerHeaderMap[key.lower()] = value 
    208210         
    …… 
    222224            self.body = forms.file 
    223225        else: 
    224             self.paramMap.update(httptools.paramsFromCGIForm(forms)) 
     226            self.params.update(httptools.paramsFromCGIForm(forms)) 
    225227     
    226228    def main(self, path=None): 
    …… 
    239241                self.objectPath = '/' + '/'.join(object_path[1:]) 
    240242                try: 
    241                     body = page_handler(*virtual_path, **self.paramMap) 
     243                    body = page_handler(*virtual_path, **self.params) 
    242244                except Exception, x: 
    243245                    x.args = x.args + (page_handler,) 
    …… 
    302304            icofile = os.path.join(os.path.dirname(__file__), "favicon.ico") 
    303305            cptools.serveFile(icofile) 
    304             applyFilters('beforeFinalize') 
     306            applyFilters('before_finalize', 'beforeFinalize') 
    305307            cherrypy.response.finalize() 
    306308            raise cherrypy.RequestHandled() 
    …… 
    373375    def __init__(self): 
    374376        self.status = None 
    375         self.headers = None 
     377        self.header_list = None 
    376378        self.body = None 
    377379         
    378         self.headerMap = httptools.HeaderMap() 
    379         self.headerMap.update({ 
     380        self.headers = httptools.HeaderMap() 
     381        self.headerMap = self.headers # Backward compatibility 
     382        self.headers.update({ 
    380383            "Content-Type": "text/html", 
    381384            "Server": "CherryPy/" + cherrypy.__version__, 
    …… 
    392395     
    393396    def finalize(self): 
    394         """Transform headerMap (and cookies) into cherrypy.response.headers.""" 
     397        """Transform headers (and cookies) into cherrypy.response.header_list.""" 
    395398         
    396399        try: 
    …… 
    409412        if stream: 
    410413            try: 
    411                 del self.headerMap['Content-Length'] 
     414                del self.headers['Content-Length'] 
    412415            except KeyError: 
    413416                pass 
    …… 
    415418            # Responses which are not streamed should have a Content-Length, 
    416419            # but allow user code to set Content-Length if desired. 
    417             if self.headerMap.get('Content-Length') is None: 
     420            if self.headers.get('Content-Length') is None: 
    418421                content = self.collapse_body() 
    419                 self.headerMap['Content-Length'] = len(content) 
     422                self.headers['Content-Length'] = len(content) 
    420423         
    421424        # Headers 
    422         headers = [] 
    423         for key, valueList in self.headerMap.iteritems(): 
     425        header_list = [] 
     426        for key, valueList in self.headers.iteritems(): 
    424427            order = _header_order_map.get(key, 3) 
    425428            if not isinstance(valueList, list): 
    426429                valueList = [valueList] 
    427430            for value in valueList: 
    428                 headers.append((order, (key, str(value)))) 
     431                header_list.append((order, (key, str(value)))) 
    429432        # RFC 2616: '... it is "good practice" to send general-header 
    430433        # fields first, followed by request-header or response-header 
    431434        # fields, and ending with the entity-header fields.' 
    432         headers.sort() 
    433         self.headers = [item[1] for item in headers] 
     435        header_list.sort() 
     436        self.header_list = [item[1] for item in header_list] 
    434437         
    435438        cookie = self.simpleCookie.output() 
    …… 
    438441            for line in lines: 
    439442                name, value = line.split(": ", 1) 
    440                 self.headers.append((name, value)) 
     443                self.header_list.append((name, value)) 
    441444     
    442445    dbltrace = "\n===First Error===\n\n%s\n\n===Second Error===\n\n%s\n\n" 
    …… 
    445448        """Set status, headers, and body when an unanticipated error occurs.""" 
    446449        try: 
    447             applyFilters('beforeErrorResponse') 
     450            applyFilters('before_error_response', 'beforeErrorResponse') 
    448451            
    449             # _cpOnError will probably change self.body. 
    450             # It may also change the headerMap, etc. 
    451             _cputil.getSpecialAttribute('_cpOnError')() 
     452            # _cp_on_error will probably change self.body. 
     453            # It may also change the headers, etc. 
     454            _cputil.get_special_attribute('_cp_on_error', '_cpOnError')() 
    452455             
    453456            self.finalize() 
    454457             
    455             applyFilters('afterErrorResponse') 
     458            applyFilters('after_error_response', 'afterErrorResponse') 
    456459            return 
    457460        except cherrypy.HTTPRedirect, inst: 
    …… 
    471474            pass 
    472475         
    473         # Failure in _cpOnError, error filter, or finalize. 
     476        # Failure in _cp_on_error, error filter, or finalize. 
    474477        # Bypass them all. 
    475         if cherrypy.config.get('server.showTracebacks', False): 
     478        if cherrypy.config.get('server.show_tracebacks', False): 
    476479            body = self.dbltrace % (_cputil.formatExc(exc), 
    477480                                    _cputil.formatExc()) 
    …… 
    481484     
    482485    def setBareError(self, body=None): 
    483         self.status, self.headers, self.body = _cputil.bareError(body) 
    484  
     486        self.status, self.header_list, self.body = _cputil.bareError(body) 
     487 

  • trunk/cherrypy/_cpserver.py

    r844 r856  
    3030         
    3131        # Set some special attributes for adding hooks 
    32         self.onStartServerList = [] 
    33         self.onStartThreadList = [] 
    34         self.onStopServerList = [] 
    35         self.onStopThreadList = [] 
     32        self.on_start_server_list = [] 
     33        self.on_start_thread_list = [] 
     34        self.on_stop_server_list = [] 
     35        self.on_stop_thread_list = [] 
     36 
     37        # Backward compatibility: 
     38        self.onStopServerList = self.on_stop_server_list 
     39        self.onStartThreadList = self.on_start_thread_list 
     40        self.onStartServerList = self.on_start_server_list 
     41        self.onStopThreadList = self.on_stop_thread_list 
    3642     
    3743    def start(self, initOnly=False, serverClass=_missing): 
    …… 
    8288    def _start(self): 
    8389        # Output config options to log 
    84         if cherrypy.config.get("server.logConfigOptions", True): 
     90        if cherrypy.config.get("server.log_config_options", True): 
    8591            cherrypy.config.outputConfigMap() 
    8692         
    …… 
    8894            configure() 
    8995             
    90             for func in cherrypy.server.onStartServerList: 
     96            for func in cherrypy.server.on_start_server_list: 
    9197                func() 
    9298            self.start_http_server() 
    …… 
    117123            return 
    118124         
    119         if cherrypy.config.get('server.socketPort'): 
    120             host = cherrypy.config.get('server.socketHost') 
    121             port = cherrypy.config.get('server.socketPort') 
     125        if cherrypy.config.get('server.socket_port'): 
     126            host = cherrypy.config.get('server.socket_host') 
     127            port = cherrypy.config.get('server.socket_port') 
    122128             
    123129            wait_for_free_port(host, port) 
    …… 
    125131            if not host: 
    126132                host = 'localhost' 
    127             onWhat = "http://%s:%s/" % (host, port) 
     133            on_what = "http://%s:%s/" % (host, port) 
    128134        else: 
    129             onWhat = "socket file: %s" % cherrypy.config.get('server.socketFile') 
     135            on_what = "socket file: %s" % cherrypy.config.get('server.socket_file') 
    130136         
    131137        # Instantiate the server. 
    …… 
    146152            self.wait_for_http_ready() 
    147153         
    148         cherrypy.log("Serving HTTP on %s" % onWhat, 'HTTP') 
     154        cherrypy.log("Serving HTTP on %s" % on_what, 'HTTP') 
    149155     
    150156    def wait_for_http_ready(self): 
    …… 
    154160             
    155161            # Wait for port to be occupied 
    156             if cherrypy.config.get('server.socketPort'): 
    157                 host = cherrypy.config.get('server.socketHost') 
    158                 port = cherrypy.config.get('server.socketPort') 
     162            if cherrypy.config.get('server.socket_port'): 
     163                host = cherrypy.config.get('server.socket_host') 
     164                port = cherrypy.config.get('server.socket_port') 
    159165                wait_for_occupied_port(host, port) 
    160166     
    …… 
    181187            seen_threads[threadID] = i 
    182188             
    183             for func in self.onStartThreadList: 
     189            for func in self.on_start_thread_list: 
    184190                func(i) 
    185191         
    …… 
    195201         
    196202        for thread_ident, i in seen_threads.iteritems(): 
    197             for func in self.onStopThreadList: 
     203            for func in self.on_stop_thread_list: 
    198204                func(i) 
    199205        seen_threads.clear() 
    200206         
    201         for func in self.onStopServerList: 
     207        for func in self.on_stop_server_list: 
    202208            func() 
    203209         
    …… 
    221227        """Restart, including any HTTP servers.""" 
    222228        self.stop() 
    223         for func in self.onStartServerList: 
     229        for func in self.on_start_server_list: 
    224230            func() 
    225231        self.start_http_server() 
    …… 
    263269    # If sessions are stored in files and we 
    264270    # use threading, we need a lock on the file 
    265     if (conf('server.threadPool') > 1 
    266         and conf('session.storageType') == 'file'): 
     271    if (conf('server.thread_pool') > 1 
     272        and conf('session.storage_type') == 'file'): 
    267273        cherrypy._sessionFileLock = threading.RLock() 
    268274     
    269275    # set cgi.maxlen which will limit the size of POST request bodies 
    270     cgi.maxlen = conf('server.maxRequestSize') 
     276    cgi.maxlen = conf('server.max_request_size') 
    271277     
    272278    # Set up the profiler if requested. 
    …… 
    283289def check_port(host, port): 
    284290    """Raise an error if the given port is not free on the given host.""" 
    285     sockFile = cherrypy.config.get('server.socketFile') 
    286     if sockFile: 
     291    sock_file = cherrypy.config.get('server.socket_file') 
     292    if sock_file: 
    287293        return 
    288294     

  • trunk/cherrypy/_cputil.py

    r837 r856  
    5555    return objectTrail 
    5656 
    57 def getSpecialAttribute(name): 
     57def get_special_attribute(name, alternate_name = None): 
    5858    """Return the special attribute. A special attribute is one that 
    5959    applies to all of the children from where it is defined, such as 
    60     _cpFilterList.""" 
     60    _cp_filters.""" 
    6161     
    6262    # First, we look in the right-most object to see if this special 
    …… 
    7474        return globals()[name] 
    7575    except KeyError: 
     76        if alternate_name: 
     77            return get_special_attribute(alternate_name) 
    7678        msg = "Special attribute %s could not be found" % repr(name) 
    7779        raise cherrypy.HTTPError(500, msg) 
    …… 
    8082    """Default handler for a Request-URI of '*'.""" 
    8183    response = cherrypy.response 
    82     response.headerMap['Content-Type'] = 'text/plain' 
     84    response.headers['Content-Type'] = 'text/plain' 
    8385     
    8486    # OPTIONS is defined in HTTP 1.1 and greater 
    8587    request = cherrypy.request 
    8688    if request.method == 'OPTIONS' and request.version >= 1.1: 
    87         response.headerMap['Allow'] = 'HEAD, GET, POST, PUT, OPTIONS' 
     89        response.headers['Allow'] = 'HEAD, GET, POST, PUT, OPTIONS' 
    8890    else: 
    89         response.headerMap['Allow'] = 'HEAD, GET, POST' 
     91        response.headers['Allow'] = 'HEAD, GET, POST' 
    9092    return "" 
    9193_cpGlobalHandler.exposed = True 
    …… 
    9799        now.day, month, now.year, now.hour, now.minute, now.second) 
    98100 
    99 def _cpLogAccess(): 
     101def _cp_log_access(): 
    100102    """ Default method for logging access """ 
    101103     
    …… 
    107109                'r': cherrypy.request.requestLine, 
    108110                's': cherrypy.response.status.split(" ", 1)[0], 
    109                 'b': cherrypy.response.headerMap.get('Content-Length', '') or "-", 
     111                'b': cherrypy.response.headers.get('Content-Length', '') or "-", 
    110112                } 
    111113     
    112     if cherrypy.config.get('server.logToScreen', True): 
     114    if cherrypy.config.get('server.log_to_screen', True): 
    113115        print s 
    114116     
    115     fname = cherrypy.config.get('server.logAccessFile', '') 
     117    fname = cherrypy.config.get('server.log_access_file', '') 
    116118    if fname: 
    117119        f = open(fname, 'ab') 
    …… 
    122124_log_severity_levels = {0: "INFO", 1: "WARNING", 2: "ERROR"} 
    123125 
    124 def _cpLogMessage(msg, context = '', severity = 0): 
     126def _cp_log_message(msg, context = '', severity = 0): 
    125127    """Default method for logging messages (error log). 
    126128     
    …… 
    133135    s = ' '.join((logtime(), context, level, msg)) 
    134136     
    135     if cherrypy.config.get('server.logToScreen', True): 
     137    if cherrypy.config.get('server.log_to_screen', True): 
    136138        print s 
    137139     
    138     fname = cherrypy.config.get('server.logFile', '') 
     140    fname = cherrypy.config.get('server.log_file', '') 
    139141    #logdir = os.path.dirname(fname) 
    140142    #if logdir and not os.path.exists(logdir): 
    …… 
    204206     
    205207    template = _HTTPErrorTemplate 
    206     errorPageFile = cherrypy.config.get('errorPage.%s' % code, '') 
    207     if errorPageFile: 
     208    error_page_file = cherrypy.config.get('error_page.%s' % code, '') 
     209    if error_page_file: 
    208210        try: 
    209             template = file(errorPageFile, 'rb').read() 
     211            template = file(error_page_file, 'rb').read() 
    210212        except: 
    211213            m = kwargs['message'] 
    …… 
    219221 
    220222 
    221 def _cpOnHTTPError(status, message): 
    222     """ Default _cpOnHTTPError method. 
     223def _cp_on_http_error(status, message): 
     224    """ Default _cp_on_http_error method. 
    223225     
    224226    status should be an int. 
    …… 
    227229    logmsg = "" 
    228230     
    229     if cherrypy.config.get('server.logTracebacks', True): 
     231    if cherrypy.config.get('server.log_tracebacks', True): 
    230232        logmsg = tb 
    231     if cherrypy.config.get('server.logRequestHeaders', True): 
    232         h = ["  %s: %s" % (k, v) for k, v in cherrypy.request.headers] 
     233    if cherrypy.config.get('server.log_request_headers', True): 
     234        h = ["  %s: %s" % (k, v) for k, v in cherrypy.request.header_list] 
    233235        logmsg += 'Request Headers:\n' + '\n'.join(h) 
    234236    if logmsg: 
    235237        cherrypy.log(logmsg, "HTTP") 
    236238     
    237     if not cherrypy.config.get('server.showTracebacks', False): 
     239    if not cherrypy.config.get('server.show_tracebacks', False): 
    238240        tb = None 
    239241     
    …… 
    245247                "Vary", "Content-Encoding", "Content-Length", "Expires", 
    246248                "Content-Location", "Content-MD5", "Last-Modified"]: 
    247         if response.headerMap.has_key(key): 
    248             del response.headerMap[key] 
     249        if response.headers.has_key(key): 
     250            del response.headers[key] 
    249251     
    250252    if status != 416: 
    …… 
    255257        # A response with status code 206 (Partial Content) MUST NOT 
    256258        # include a Content-Range field with a byte-range- resp-spec of "*". 
    257         if response.headerMap.has_key("Content-Range"): 
    258             del response.headerMap["Content-Range"] 
     259        if response.headers.has_key("Content-Range"): 
     260            del response.headers["Content-Range"] 
    259261     
    260262    # In all cases, finalize will be called after this method, 
    …… 
    263265    content = getErrorPage(status, traceback=tb, message=message) 
    264266    response.body = content 
    265     response.headerMap['Content-Length'] = len(content) 
    266     response.headerMap['Content-Type'] = "text/html" 
     267    response.headers['Content-Length'] = len(content) 
     268    response.headers['Content-Type'] = "text/html" 
    267269     
    268270    be_ie_unfriendly(status) 
    …… 
    297299            content = content + (" " * (s - l)) 
    298300        response.body = content 
    299         response.headerMap['Content-Length'] = len(content) 
     301        response.headers['Content-Length'] = len(content) 
     302 
     303def lower_to_camel(s): 
     304    """Turns lowercase_with_underscore into camelCase.""" 
     305    sp = s.split('_') 
     306    new_sp = [] 
     307    for i, s in enumerate(sp): 
     308        if i != 0: 
     309            s = s[0].upper() + s[1:] 
     310        new_sp.append(s) 
     311    return ''.join(new_sp) 
    300312 
    301313def formatExc(exc=None): 
    …… 
    334346            [body]) 
    335347 
    336 def _cpOnError(): 
    337     """ Default _cpOnError method """ 
     348def _cp_on_error(): 
     349    """ Default _cp_on_error method """ 
    338350    # Allow logging of only *unexpected* HTTPError's. 
    339     if (not cherrypy.config.get('server.logTracebacks', True) 
    340         and cherrypy.config.get('server.logUnhandledTracebacks', True)): 
     351    if (not cherrypy.config.get('server.log_tracebacks', True) 
     352        and cherrypy.config.get('server.log_unhandled_tracebacks', True)): 
    341353        cherrypy.log(formatExc()) 
    342354     
    …… 
    344356 
    345357 
    346 _cpFilterList = [] 
    347  
     358_cp_filters = [] 
     359 

  • trunk/cherrypy/_cpwsgi.py

    r851 r856  
    5555     
    5656    # Trap screen output from BaseHTTPRequestHandler.log_message() 
    57     if not cherrypy.config.get('server.logToScreen'): 
     57    if not cherrypy.config.get('server.log_to_screen'): 
    5858        sys.stderr = NullWriter() 
    5959     
    …… 
    7373                               translate_headers(environ), 
    7474                               environ['wsgi.input']) 
    75         s, h, b = response.status, response.headers, response.body 
     75        s, h, b = response.status, response.header_list, response.body 
    7676        exc = None 
    7777    except (KeyboardInterrupt, SystemExit): 
    …… 
    8080        tb = _cputil.formatExc() 
    8181        cherrypy.log(tb) 
    82         if not cherrypy.config.get("server.showTracebacks", False): 
     82        if not cherrypy.config.get("server.show_tracebacks", False): 
    8383            tb = "" 
    8484        s, h, b = _cputil.bareError(tb) 
    …… 
    125125    def __init__(self, socket, addr, server): 
    126126        _cpwsgiserver.HTTPRequest.__init__(self, socket, addr, server) 
    127         mhs = int(cherrypy.config.get('server.maxRequestHeaderSize', 
     127        mhs = int(cherrypy.config.get('server.max_request_header_size', 
    128128                                      500 * 1024)) 
    129129  &