Commit 33f68ca0c8555de8f550b93de772b9645bcb6238 - cherrypy3

Imported Upstream version 3.3.0 SVN-Git Migration 8 years ago

116 changed file(s) with 8746 addition(s) and 5372 deletion(s). Raw diff Collapse all Expand all

+37

-26

CherryPy.egg-info/PKG-INFO less more

0		Metadata-Version: 1.0
1		Name: CherryPy
2		Version: 3.2.2
3		Summary: Object-Oriented HTTP framework
4		Home-page: http://www.cherrypy.org
5		Author: CherryPy Team
6		Author-email: team@cherrypy.org
7		License: BSD
8		Download-URL: http://download.cherrypy.org/cherrypy/3.2.2/
9		Description: CherryPy is a pythonic, object-oriented HTTP framework
10		Platform: UNKNOWN
11		Classifier: Development Status :: 5 - Production/Stable
12		Classifier: Environment :: Web Environment
13		Classifier: Intended Audience :: Developers
14		Classifier: License :: Freely Distributable
15		Classifier: Operating System :: OS Independent
16		Classifier: Programming Language :: Python
17		Classifier: Programming Language :: Python :: 2
18		Classifier: Programming Language :: Python :: 3
19		Classifier: Topic :: Internet :: WWW/HTTP
20		Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
21		Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
22		Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
23		Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
24		Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
25		Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
	0	Metadata-Version: 1.1
	1	Name: CherryPy
	2	Version: 3.3.0
	3	Summary: Object-Oriented HTTP framework
	4	Home-page: http://www.cherrypy.org
	5	Author: CherryPy Team
	6	Author-email: team@cherrypy.org
	7	License: BSD
	8	Description: CherryPy is a pythonic, object-oriented HTTP framework
	9	Platform: UNKNOWN
	10	Classifier: Development Status :: 5 - Production/Stable
	11	Classifier: Environment :: Web Environment
	12	Classifier: Intended Audience :: Developers
	13	Classifier: License :: Freely Distributable
	14	Classifier: Operating System :: OS Independent
	15	Classifier: Framework :: CherryPy
	16	Classifier: License :: OSI Approved :: BSD License
	17	Classifier: Programming Language :: Python
	18	Classifier: Programming Language :: Python :: 2
	19	Classifier: Programming Language :: Python :: 2.3
	20	Classifier: Programming Language :: Python :: 2.4
	21	Classifier: Programming Language :: Python :: 2.5
	22	Classifier: Programming Language :: Python :: 2.6
	23	Classifier: Programming Language :: Python :: 2.7
	24	Classifier: Programming Language :: Python :: 3
	25	Classifier: Programming Language :: Python :: 3.3
	26	Classifier: Programming Language :: Python :: Implementation
	27	Classifier: Programming Language :: Python :: Implementation :: CPython
	28	Classifier: Programming Language :: Python :: Implementation :: Jython
	29	Classifier: Programming Language :: Python :: Implementation :: PyPy
	30	Classifier: Topic :: Internet :: WWW/HTTP
	31	Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
	32	Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
	33	Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
	34	Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
	35	Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
	36	Classifier: Topic :: Software Development :: Libraries :: Application Frameworks

-2

CherryPy.egg-info/SOURCES.txt less more

0	0	MANIFEST.in
1	1	README.txt
	2	setup.cfg
2	3	setup.py
3	4	CherryPy.egg-info/PKG-INFO
4	5	CherryPy.egg-info/SOURCES.txt

8	9	cherrypy/__init__.py
9	10	cherrypy/_cpchecker.py
10	11	cherrypy/_cpcompat.py
	12	cherrypy/_cpcompat_subprocess.py
11	13	cherrypy/_cpconfig.py
12	14	cherrypy/_cpdispatch.py
13	15	cherrypy/_cperror.py

38	40	cherrypy/lib/httpauth.py
39	41	cherrypy/lib/httputil.py
40	42	cherrypy/lib/jsontools.py
	43	cherrypy/lib/lockfile.py
	44	cherrypy/lib/locking.py
41	45	cherrypy/lib/profiler.py
42	46	cherrypy/lib/reprconf.py
43	47	cherrypy/lib/sessions.py

71	75	cherrypy/test/test_auth_digest.py
72	76	cherrypy/test/test_bus.py
73	77	cherrypy/test/test_caching.py
	78	cherrypy/test/test_compat.py
74	79	cherrypy/test/test_config.py
75	80	cherrypy/test/test_config_server.py
76	81	cherrypy/test/test_conn.py

102	107	cherrypy/test/test_wsgiapps.py
103	108	cherrypy/test/test_xmlrpc.py
104	109	cherrypy/test/webtest.py
	110	cherrypy/test/static/404.html
105	111	cherrypy/test/static/dirback.jpg
106		cherrypy/test/static/has space.html
107	112	cherrypy/test/static/index.html
108	113	cherrypy/tutorial/README.txt
109	114	cherrypy/tutorial/__init__.py
110		cherrypy/tutorial/bonus-sqlobject.py
111	115	cherrypy/tutorial/custom_error.html
112	116	cherrypy/tutorial/pdf_file.pdf
113	117	cherrypy/tutorial/tut01_helloworld.py

+37

-26

PKG-INFO less more

0		Metadata-Version: 1.0
1		Name: CherryPy
2		Version: 3.2.2
3		Summary: Object-Oriented HTTP framework
4		Home-page: http://www.cherrypy.org
5		Author: CherryPy Team
6		Author-email: team@cherrypy.org
7		License: BSD
8		Download-URL: http://download.cherrypy.org/cherrypy/3.2.2/
9		Description: CherryPy is a pythonic, object-oriented HTTP framework
10		Platform: UNKNOWN
11		Classifier: Development Status :: 5 - Production/Stable
12		Classifier: Environment :: Web Environment
13		Classifier: Intended Audience :: Developers
14		Classifier: License :: Freely Distributable
15		Classifier: Operating System :: OS Independent
16		Classifier: Programming Language :: Python
17		Classifier: Programming Language :: Python :: 2
18		Classifier: Programming Language :: Python :: 3
19		Classifier: Topic :: Internet :: WWW/HTTP
20		Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
21		Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
22		Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
23		Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
24		Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
25		Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
	0	Metadata-Version: 1.1
	1	Name: CherryPy
	2	Version: 3.3.0
	3	Summary: Object-Oriented HTTP framework
	4	Home-page: http://www.cherrypy.org
	5	Author: CherryPy Team
	6	Author-email: team@cherrypy.org
	7	License: BSD
	8	Description: CherryPy is a pythonic, object-oriented HTTP framework
	9	Platform: UNKNOWN
	10	Classifier: Development Status :: 5 - Production/Stable
	11	Classifier: Environment :: Web Environment
	12	Classifier: Intended Audience :: Developers
	13	Classifier: License :: Freely Distributable
	14	Classifier: Operating System :: OS Independent
	15	Classifier: Framework :: CherryPy
	16	Classifier: License :: OSI Approved :: BSD License
	17	Classifier: Programming Language :: Python
	18	Classifier: Programming Language :: Python :: 2
	19	Classifier: Programming Language :: Python :: 2.3
	20	Classifier: Programming Language :: Python :: 2.4
	21	Classifier: Programming Language :: Python :: 2.5
	22	Classifier: Programming Language :: Python :: 2.6
	23	Classifier: Programming Language :: Python :: 2.7
	24	Classifier: Programming Language :: Python :: 3
	25	Classifier: Programming Language :: Python :: 3.3
	26	Classifier: Programming Language :: Python :: Implementation
	27	Classifier: Programming Language :: Python :: Implementation :: CPython
	28	Classifier: Programming Language :: Python :: Implementation :: Jython
	29	Classifier: Programming Language :: Python :: Implementation :: PyPy
	30	Classifier: Topic :: Internet :: WWW/HTTP
	31	Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
	32	Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
	33	Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
	34	Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
	35	Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Server
	36	Classifier: Topic :: Software Development :: Libraries :: Application Frameworks

+121

-93

cherrypy/__init__.py less more

52	52	* Server API
53	53	* WSGI API
54	54
55		These API's are described in the CherryPy specification:
56		http://www.cherrypy.org/wiki/CherryPySpec
	55	These API's are described in the `CherryPy specification <https://bitbucket.org/cherrypy/cherrypy/wiki/CherryPySpec>`_.
57	56	"""
58	57
59		__version__ = "3.2.2"
	58	__version__ = "3.3.0"
60	59
61	60	from cherrypy._cpcompat import urljoin as _urljoin, urlencode as _urlencode
62	61	from cherrypy._cpcompat import basestring, unicodestr, set

93	92	engine.listeners['before_request'] = set()
94	93	engine.listeners['after_request'] = set()
95	94
	95
96	96	class _TimeoutMonitor(process.plugins.Monitor):
97
	97
98	98	def __init__(self, bus):
99	99	self.servings = []
100	100	process.plugins.Monitor.__init__(self, bus, self.run)
101
	101
102	102	def before_request(self):
103	103	self.servings.append((serving.request, serving.response))
104
	104
105	105	def after_request(self):
106	106	try:
107	107	self.servings.remove((serving.request, serving.response))
108	108	except ValueError:
109	109	pass
110
	110
111	111	def run(self):
112	112	"""Check timeout on all responses. (Internal)"""
113	113	for req, resp in self.servings:

124	124	engine.signal_handler = process.plugins.SignalHandler(engine)
125	125
126	126
	127	class _HandleSignalsPlugin(object):
	128
	129	"""Handle signals from other processes based on the configured
	130	platform handlers above."""
	131
	132	def __init__(self, bus):
	133	self.bus = bus
	134
	135	def subscribe(self):
	136	"""Add the handlers based on the platform"""
	137	if hasattr(self.bus, "signal_handler"):
	138	self.bus.signal_handler.subscribe()
	139	if hasattr(self.bus, "console_control_handler"):
	140	self.bus.console_control_handler.subscribe()
	141
	142	engine.signals = _HandleSignalsPlugin(engine)
	143
	144
127	145	from cherrypy import _cpserver
128	146	server = _cpserver.Server()
129	147	server.subscribe()

131	149
132	150	def quickstart(root=None, script_name="", config=None):
133	151	"""Mount the given root, start the builtin server (and engine), then block.
134
	152
135	153	root: an instance of a "controller class" (a collection of page handler
136	154	methods) which represents the root of the application.
137	155	script_name: a string containing the "mount point" of the application.

139	157	at which to mount the given root. For example, if root.index() will
140	158	handle requests to "http://www.example.com:8080/dept/app1/", then
141	159	the script_name argument would be "/dept/app1".
142
	160
143	161	It MUST NOT end in a slash. If the script_name refers to the root
144	162	of the URI, it MUST be an empty string (not "/").
145	163	config: a file or dict containing application config. If this contains

148	166	"""
149	167	if config:
150	168	_global_conf_alias.update(config)
151
	169
152	170	tree.mount(root, script_name, config)
153
154		if hasattr(engine, "signal_handler"):
155		engine.signal_handler.subscribe()
156		if hasattr(engine, "console_control_handler"):
157		engine.console_control_handler.subscribe()
158
	171
	172	engine.signals.subscribe()
159	173	engine.start()
160	174	engine.block()
161	175
162	176
163	177	from cherrypy._cpcompat import threadlocal as _local
164	178
	179
165	180	class _Serving(_local):
	181
166	182	"""An interface for registering request and response objects.
167
	183
168	184	Rather than have a separate "thread local" object for the request and
169	185	the response, this class works as a single threadlocal container for
170	186	both objects (and any others which developers wish to define). In this

172	188	conversation, yet still refer to them as module-level globals in a
173	189	thread-safe way.
174	190	"""
175
	191
176	192	request = _cprequest.Request(_httputil.Host("127.0.0.1", 80),
177	193	_httputil.Host("127.0.0.1", 1111))
178	194	"""
179	195	The request object for the current thread. In the main thread,
180	196	and any threads which are not receiving HTTP requests, this is None."""
181
	197
182	198	response = _cprequest.Response()
183	199	"""
184	200	The response object for the current thread. In the main thread,
185	201	and any threads which are not receiving HTTP requests, this is None."""
186
	202
187	203	def load(self, request, response):
188	204	self.request = request
189	205	self.response = response
190
	206
191	207	def clear(self):
192	208	"""Remove all attributes of self."""
193	209	self.__dict__.clear()

196	212
197	213
198	214	class _ThreadLocalProxy(object):
199
	215
200	216	__slots__ = ['__attrname__', '__dict__']
201
	217
202	218	def __init__(self, attrname):
203	219	self.__attrname__ = attrname
204
	220
205	221	def __getattr__(self, name):
206	222	child = getattr(serving, self.__attrname__)
207	223	return getattr(child, name)
208
	224
209	225	def __setattr__(self, name, value):
210	226	if name in ("__attrname__", ):
211	227	object.__setattr__(self, name, value)
212	228	else:
213	229	child = getattr(serving, self.__attrname__)
214	230	setattr(child, name, value)
215
	231
216	232	def __delattr__(self, name):
217	233	child = getattr(serving, self.__attrname__)
218	234	delattr(child, name)
219
	235
220	236	def _get_dict(self):
221	237	child = getattr(serving, self.__attrname__)
222	238	d = child.__class__.__dict__.copy()
223	239	d.update(child.__dict__)
224	240	return d
225	241	__dict__ = property(_get_dict)
226
	242
227	243	def __getitem__(self, key):
228	244	child = getattr(serving, self.__attrname__)
229	245	return child[key]
230
	246
231	247	def __setitem__(self, key, value):
232	248	child = getattr(serving, self.__attrname__)
233	249	child[key] = value
234
	250
235	251	def __delitem__(self, key):
236	252	child = getattr(serving, self.__attrname__)
237	253	del child[key]
238
	254
239	255	def __contains__(self, key):
240	256	child = getattr(serving, self.__attrname__)
241	257	return key in child
242
	258
243	259	def __len__(self):
244	260	child = getattr(serving, self.__attrname__)
245	261	return len(child)
246
	262
247	263	def __nonzero__(self):
248	264	child = getattr(serving, self.__attrname__)
249	265	return bool(child)

257	273	response = _ThreadLocalProxy('response')
258	274
259	275	# Create thread_data object as a thread-specific all-purpose storage
	276
	277
260	278	class _ThreadData(_local):
	279
261	280	"""A container for thread-specific data."""
262	281	thread_data = _ThreadData()
263	282

282	301
283	302	from cherrypy import _cplogging
284	303
	304
285	305	class _GlobalLogManager(_cplogging.LogManager):
	306
286	307	"""A site-wide LogManager; routes to app.log or global log as appropriate.
287
	308
288	309	This :class:`LogManager<cherrypy._cplogging.LogManager>` implements
289	310	cherrypy.log() and cherrypy.log.access(). If either
290	311	function is called during a request, the message will be sent to the
291	312	logger for the current Application. If they are called outside of a
292	313	request, the message will be sent to the site-wide logger.
293	314	"""
294
	315
295	316	def __call__(self, args, *kwargs):
296		"""Log the given message to the app.log or global log as appropriate."""
297		# Do NOT use try/except here. See http://www.cherrypy.org/ticket/945
	317	"""Log the given message to the app.log or global log as appropriate.
	318	"""
	319	# Do NOT use try/except here. See
	320	# https://bitbucket.org/cherrypy/cherrypy/issue/945
298	321	if hasattr(request, 'app') and hasattr(request.app, 'log'):
299	322	log = request.app.log
300	323	else:
301	324	log = self
302	325	return log.error(args, *kwargs)
303
	326
304	327	def access(self):
305		"""Log an access message to the app.log or global log as appropriate."""
	328	"""Log an access message to the app.log or global log as appropriate.
	329	"""
306	330	try:
307	331	return request.app.log.access()
308	332	except AttributeError:

315	339	log.error_file = ''
316	340	# Using an access file makes CP about 10% slower. Leave off by default.
317	341	log.access_file = ''
	342
318	343
319	344	def _buslog(msg, level):
320	345	log.error(msg, 'ENGINE', severity=level)

334	359	for a in alias:
335	360	parents[a.replace(".", "_")] = func
336	361	return func
337
338		import sys, types
	362
	363	import sys
	364	import types
339	365	if isinstance(func, (types.FunctionType, types.MethodType)):
340	366	if alias is None:
341	367	# @expose

362	388	alias = func
363	389	return expose_
364	390
	391
365	392	def popargs(args, *kwargs):
366		"""A decorator for _cp_dispatch
	393	"""A decorator for _cp_dispatch
367	394	(cherrypy.dispatch.Dispatcher.dispatch_method_name).
368	395
369	396	Optional keyword argument: handler=(Object or Function)
370
371		Provides a _cp_dispatch function that pops off path segments into
	397
	398	Provides a _cp_dispatch function that pops off path segments into
372	399	cherrypy.request.params under the names specified. The dispatch
373	400	is then forwarded on to the next vpath element.
374
	401
375	402	Note that any existing (and exposed) member function of the class that
376	403	popargs is applied to will override that value of the argument. For
377	404	instance, if you have a method named "list" on the class decorated with
378	405	popargs, then accessing "/list" will call that function instead of popping
379		it off as the requested parameter. This restriction applies to all
	406	it off as the requested parameter. This restriction applies to all
380	407	_cp_dispatch functions. The only way around this restriction is to create
381	408	a "blank class" whose only function is to provide _cp_dispatch.
382
	409
383	410	If there are path elements after the arguments, or more arguments
384	411	are requested than are available in the vpath, then the 'handler'
385	412	keyword argument specifies the next object to handle the parameterized

388	415	will be called with the args specified and the return value from that
389	416	function used as the next object INSTEAD of adding the parameters to
390	417	cherrypy.request.args.
391
	418
392	419	This decorator may be used in one of two ways:
393
	420
394	421	As a class decorator:
395	422	@cherrypy.popargs('year', 'month', 'day')
396	423	class Blog:

398	425	#Process the parameters here; any url like
399	426	#/, /2009, /2009/12, or /2009/12/31
400	427	#will fill in the appropriate parameters.
401
	428
402	429	def create(self):
403	430	#This link will still be available at /create. Defined functions
404	431	#take precedence over arguments.
405
	432
406	433	Or as a member of a class:
407	434	class Blog:
408	435	_cp_dispatch = cherrypy.popargs('year', 'month', 'day')
409	436	#...
410
	437
411	438	The handler argument may be used to mix arguments with built in functions.
412	439	For instance, the following setup allows different activities at the
413	440	day, month, and year level:
414
	441
415	442	class DayHandler:
416	443	def index(self, year, month, day):
417	444	#Do something with this day; probably list entries
418
	445
419	446	def delete(self, year, month, day):
420	447	#Delete all entries for this day
421
	448
422	449	@cherrypy.popargs('day', handler=DayHandler())
423	450	class MonthHandler:
424	451	def index(self, year, month):
425	452	#Do something with this month; probably list entries
426
	453
427	454	def delete(self, year, month):
428	455	#Delete all entries for this month
429
	456
430	457	@cherrypy.popargs('month', handler=MonthHandler())
431	458	class YearHandler:
432	459	def index(self, year):
433	460	#Do something with this year
434
	461
435	462	#...
436
	463
437	464	@cherrypy.popargs('year', handler=YearHandler())
438	465	class Root:
439	466	def index(self):
440	467	#...
441
	468
442	469	"""
443	470
444		#Since keyword arg comes after *args, we have to process it ourselves
445		#for lower versions of python.
	471	# Since keyword arg comes after *args, we have to process it ourselves
	472	# for lower versions of python.
446	473
447	474	handler = None
448	475	handler_call = False
449		for k,v in kwargs.items():
	476	for k, v in kwargs.items():
450	477	if k == 'handler':
451	478	handler = v
452	479	else:
453	480	raise TypeError(
454		"cherrypy.popargs() got an unexpected keyword argument '{0}'" \
	481	"cherrypy.popargs() got an unexpected keyword argument '{0}'"
455	482	.format(k)
456		)
	483	)
457	484
458	485	import inspect
459	486
460	487	if handler is not None \
461		and (hasattr(handler, '__call__') or inspect.isclass(handler)):
	488	and (hasattr(handler, '__call__') or inspect.isclass(handler)):
462	489	handler_call = True
463
	490
464	491	def decorated(cls_or_self=None, vpath=None):
465	492	if inspect.isclass(cls_or_self):
466		#cherrypy.popargs is a class decorator
	493	# cherrypy.popargs is a class decorator
467	494	cls = cls_or_self
468	495	setattr(cls, dispatch.Dispatcher.dispatch_method_name, decorated)
469	496	return cls
470
471		#We're in the actual function
	497
	498	# We're in the actual function
472	499	self = cls_or_self
473	500	parms = {}
474	501	for arg in args:
475	502	if not vpath:
476	503	break
477	504	parms[arg] = vpath.pop(0)
478
	505
479	506	if handler is not None:
480	507	if handler_call:
481	508	return handler(**parms)
482	509	else:
483	510	request.params.update(parms)
484	511	return handler
485
	512
486	513	request.params.update(parms)
487
488		#If we are the ultimate handler, then to prevent our _cp_dispatch
489		#from being called again, we will resolve remaining elements through
490		#getattr() directly.
	514
	515	# If we are the ultimate handler, then to prevent our _cp_dispatch
	516	# from being called again, we will resolve remaining elements through
	517	# getattr() directly.
491	518	if vpath:
492	519	return getattr(self, vpath.pop(0), None)
493	520	else:
494	521	return self
495
	522
496	523	return decorated
	524
497	525
498	526	def url(path="", qs="", script_name=None, base=None, relative=None):
499	527	"""Create an absolute URL for the given path.
500
	528
501	529	If 'path' starts with a slash ('/'), this will return
502	530	(base + script_name + path + qs).
503	531	If it does not start with a slash, this returns
504	532	(base + script_name [+ request.path_info] + path + qs).
505
	533
506	534	If script_name is None, cherrypy.request will be used
507	535	to find a script_name, if available.
508
	536
509	537	If base is None, cherrypy.request.base will be used (if available).
510	538	Note that you can use cherrypy.tools.proxy to change this.
511
	539
512	540	Finally, note that this function can be used to obtain an absolute URL
513	541	for the current request path (minus the querystring) by passing no args.
514	542	If you call url(qs=cherrypy.request.query_string), you should get the
515	543	original browser URL (assuming no internal redirections).
516
	544
517	545	If relative is None or not provided, request.app.relative_urls will
518	546	be used (if available, else False). If False, the output will be an
519	547	absolute URL (including the scheme, host, vhost, and script_name).

526	554	qs = _urlencode(qs)
527	555	if qs:
528	556	qs = '?' + qs
529
	557
530	558	if request.app:
531	559	if not path.startswith("/"):
532	560	# Append/remove trailing slash from path_info as needed

539	567	elif request.is_index is False:
540	568	if pi.endswith('/') and pi != '/':
541	569	pi = pi[:-1]
542
	570
543	571	if path == "":
544	572	path = pi
545	573	else:
546	574	path = _urljoin(pi, path)
547
	575
548	576	if script_name is None:
549	577	script_name = request.script_name
550	578	if base is None:
551	579	base = request.base
552
	580
553	581	newurl = base + script_name + path + qs
554	582	else:
555	583	# No request.app (we're being called outside a request).

558	586	# if you're using vhosts or tools.proxy.
559	587	if base is None:
560	588	base = server.base()
561
	589
562	590	path = (script_name or "") + path
563	591	newurl = base + path + qs
564
	592
565	593	if './' in newurl:
566	594	# Normalize the URL by removing ./ and ../
567	595	atoms = []

573	601	else:
574	602	atoms.append(atom)
575	603	newurl = '/'.join(atoms)
576
	604
577	605	# At this point, we should have a fully-qualified absolute URL.
578
	606
579	607	if relative is None:
580	608	relative = getattr(request.app, "relative_urls", False)
581
	609
582	610	# See http://www.ietf.org/rfc/rfc2396.txt
583	611	if relative == 'server':
584	612	# "A relative reference beginning with a single slash character is

598	626	new.pop(0)
599	627	new = (['..'] * len(old)) + new
600	628	newurl = '/'.join(new)
601
	629
602	630	return newurl
603	631
604	632

612	640	'tools.log_headers.on': True,
613	641	'tools.trailing_slash.on': True,
614	642	'tools.encode.on': True
615		}
	643	}
616	644	config.namespaces["log"] = lambda k, v: setattr(log, k, v)
617	645	config.namespaces["checker"] = lambda k, v: setattr(checker, k, v)
618	646	# Must reset to get our defaults applied.

+77

-72

cherrypy/_cpchecker.py less more

5	5
6	6
7	7	class Checker(object):
	8
8	9	"""A checker for CherryPy sites and their mounted applications.
9
	10
10	11	When this object is called at engine startup, it executes each
11	12	of its own methods whose names start with ``check_``. If you wish
12	13	to disable selected checks, simply add a line in your global
13	14	config which sets the appropriate method to False::
14
	15
15	16	[global]
16	17	checker.check_skipped_app_config = False
17
	18
18	19	You may also dynamically add or replace ``check_*`` methods in this way.
19	20	"""
20
	21
21	22	on = True
22	23	"""If True (the default), run all checks; if False, turn off all checks."""
23
24
	24
25	25	def __init__(self):
26	26	self._populate_known_types()
27
	27
28	28	def __call__(self):
29	29	"""Run all check_* methods."""
30	30	if self.on:

38	38	method()
39	39	finally:
40	40	warnings.formatwarning = oldformatwarning
41
	41
42	42	def formatwarning(self, message, category, filename, lineno, line=None):
43	43	"""Function to format a warning."""
44	44	return "CherryPy Checker:\n%s\n\n" % message
45
	45
46	46	# This value should be set inside _cpconfig.
47	47	global_config_contained_paths = False
48
	48
49	49	def check_app_config_entries_dont_start_with_script_name(self):
50		"""Check for Application config with sections that repeat script_name."""
	50	"""Check for Application config with sections that repeat script_name.
	51	"""
51	52	for sn, app in cherrypy.tree.apps.items():
52	53	if not isinstance(app, cherrypy.Application):
53	54	continue

60	61	key_atoms = key.strip("/").split("/")
61	62	if key_atoms[:len(sn_atoms)] == sn_atoms:
62	63	warnings.warn(
63		"The application mounted at %r has config " \
64		"entries that start with its script name: %r" % (sn, key))
65
	64	"The application mounted at %r has config "
	65	"entries that start with its script name: %r" % (sn,
	66	key))
	67
66	68	def check_site_config_entries_in_app_config(self):
67	69	"""Check for mounted Applications that have site-scoped config."""
68	70	for sn, app in iteritems(cherrypy.tree.apps):
69	71	if not isinstance(app, cherrypy.Application):
70	72	continue
71
	73
72	74	msg = []
73	75	for section, entries in iteritems(app.config):
74	76	if section.startswith('/'):
75	77	for key, value in iteritems(entries):
76	78	for n in ("engine.", "server.", "tree.", "checker."):
77	79	if key.startswith(n):
78		msg.append("[%s] %s = %s" % (section, key, value))
	80	msg.append("[%s] %s = %s" %
	81	(section, key, value))
79	82	if msg:
80	83	msg.insert(0,
81		"The application mounted at %r contains the following "
82		"config entries, which are only allowed in site-wide "
83		"config. Move them to a [global] section and pass them "
84		"to cherrypy.config.update() instead of tree.mount()." % sn)
	84	"The application mounted at %r contains the "
	85	"following config entries, which are only allowed "
	86	"in site-wide config. Move them to a [global] "
	87	"section and pass them to cherrypy.config.update() "
	88	"instead of tree.mount()." % sn)
85	89	warnings.warn(os.linesep.join(msg))
86
	90
87	91	def check_skipped_app_config(self):
88	92	"""Check for mounted Applications that have no config."""
89	93	for sn, app in cherrypy.tree.apps.items():

99	103	"cherrypy.tree.mount(..., config=app_config)")
100	104	warnings.warn(msg)
101	105	return
102
	106
103	107	def check_app_config_brackets(self):
104		"""Check for Application config with extraneous brackets in section names."""
	108	"""Check for Application config with extraneous brackets in section
	109	names.
	110	"""
105	111	for sn, app in cherrypy.tree.apps.items():
106	112	if not isinstance(app, cherrypy.Application):
107	113	continue

110	116	for key in app.config.keys():
111	117	if key.startswith("[") or key.endswith("]"):
112	118	warnings.warn(
113		"The application mounted at %r has config " \
	119	"The application mounted at %r has config "
114	120	"section names with extraneous brackets: %r. "
115	121	"Config files need brackets; config dicts "
116	122	"(e.g. passed to tree.mount) do not." % (sn, key))
117
	123
118	124	def check_static_paths(self):
119	125	"""Check Application config for incorrect static paths."""
120	126	# Use the dummy Request object in the main thread.

127	133	# get_resource will populate request.config
128	134	request.get_resource(section + "/dummy.html")
129	135	conf = request.config.get
130
	136
131	137	if conf("tools.staticdir.on", False):
132	138	msg = ""
133	139	root = conf("tools.staticdir.root")

143	149	"though a root is provided.")
144	150	testdir = os.path.join(root, dir[1:])
145	151	if os.path.exists(testdir):
146		msg += ("\nIf you meant to serve the "
147		"filesystem folder at %r, remove "
148		"the leading slash from dir." % testdir)
	152	msg += (
	153	"\nIf you meant to serve the "
	154	"filesystem folder at %r, remove the "
	155	"leading slash from dir." % (testdir,))
149	156	else:
150	157	if not root:
151		msg = "dir is a relative path and no root provided."
	158	msg = (
	159	"dir is a relative path and "
	160	"no root provided.")
152	161	else:
153	162	fulldir = os.path.join(root, dir)
154	163	if not os.path.isabs(fulldir):
155		msg = "%r is not an absolute path." % fulldir
156
	164	msg = ("%r is not an absolute path." % (
	165	fulldir,))
	166
157	167	if fulldir and not os.path.exists(fulldir):
158	168	if msg:
159	169	msg += "\n"
160	170	msg += ("%r (root + dir) is not an existing "
161	171	"filesystem path." % fulldir)
162
	172
163	173	if msg:
164	174	warnings.warn("%s\nsection: [%s]\nroot: %r\ndir: %r"
165	175	% (msg, section, root, dir))
166
167
	176
168	177	# -------------------------- Compatibility -------------------------- #
169
170	178	obsolete = {
171	179	'server.default_content_type': 'tools.response_headers.headers',
172	180	'log_access_file': 'log.access_file',

179	187	'throw_errors': 'request.throw_errors',
180	188	'profiler.on': ('cherrypy.tree.mount(profiler.make_app('
181	189	'cherrypy.Application(Root())))'),
182		}
183
	190	}
	191
184	192	deprecated = {}
185
	193
186	194	def _compat(self, config):
187	195	"""Process config and warn on each obsolete or deprecated entry."""
188	196	for section, conf in config.items():

203	211	elif section in self.deprecated:
204	212	warnings.warn("%r is deprecated. Use %r instead."
205	213	% (section, self.deprecated[section]))
206
	214
207	215	def check_compatibility(self):
208	216	"""Process config and warn on each obsolete or deprecated entry."""
209	217	self._compat(cherrypy.config)

211	219	if not isinstance(app, cherrypy.Application):
212	220	continue
213	221	self._compat(app.config)
214
215
	222
216	223	# ------------------------ Known Namespaces ------------------------ #
217
218	224	extra_config_namespaces = []
219
	225
220	226	def _known_ns(self, app):
221	227	ns = ["wsgi"]
222	228	ns.extend(copykeys(app.toolboxes))

224	230	ns.extend(copykeys(app.request_class.namespaces))
225	231	ns.extend(copykeys(cherrypy.config.namespaces))
226	232	ns += self.extra_config_namespaces
227
	233
228	234	for section, conf in app.config.items():
229	235	is_path_section = section.startswith("/")
230	236	if is_path_section and isinstance(conf, dict):

234	240	if atoms[0] not in ns:
235	241	# Spit out a special warning if a known
236	242	# namespace is preceded by "cherrypy."
237		if (atoms[0] == "cherrypy" and atoms[1] in ns):
238		msg = ("The config entry %r is invalid; "
239		"try %r instead.\nsection: [%s]"
240		% (k, ".".join(atoms[1:]), section))
	243	if atoms[0] == "cherrypy" and atoms[1] in ns:
	244	msg = (
	245	"The config entry %r is invalid; "
	246	"try %r instead.\nsection: [%s]"
	247	% (k, ".".join(atoms[1:]), section))
241	248	else:
242		msg = ("The config entry %r is invalid, because "
243		"the %r config namespace is unknown.\n"
244		"section: [%s]" % (k, atoms[0], section))
	249	msg = (
	250	"The config entry %r is invalid, "
	251	"because the %r config namespace "
	252	"is unknown.\n"
	253	"section: [%s]" % (k, atoms[0], section))
245	254	warnings.warn(msg)
246	255	elif atoms[0] == "tools":
247	256	if atoms[1] not in dir(cherrypy.tools):
248		msg = ("The config entry %r may be invalid, "
249		"because the %r tool was not found.\n"
250		"section: [%s]" % (k, atoms[1], section))
	257	msg = (
	258	"The config entry %r may be invalid, "
	259	"because the %r tool was not found.\n"
	260	"section: [%s]" % (k, atoms[1], section))
251	261	warnings.warn(msg)
252
	262
253	263	def check_config_namespaces(self):
254	264	"""Process config and warn on each unknown config namespace."""
255	265	for sn, app in cherrypy.tree.apps.items():

257	267	continue
258	268	self._known_ns(app)
259	269
260
261
262
263	270	# -------------------------- Config Types -------------------------- #
264
265	271	known_config_types = {}
266
	272
267	273	def _populate_known_types(self):
268	274	b = [x for x in vars(builtins).values()
269	275	if type(x) is type(str)]
270
	276
271	277	def traverse(obj, namespace):
272	278	for name in dir(obj):
273	279	# Hack for 3.2's warning about body_params

276	282	vtype = type(getattr(obj, name, None))
277	283	if vtype in b:
278	284	self.known_config_types[namespace + "." + name] = vtype
279
	285
280	286	traverse(cherrypy.request, "request")
281	287	traverse(cherrypy.response, "response")
282	288	traverse(cherrypy.server, "server")
283	289	traverse(cherrypy.engine, "engine")
284	290	traverse(cherrypy.log, "log")
285
	291
286	292	def _known_types(self, config):
287	293	msg = ("The config entry %r in section %r is of type %r, "
288	294	"which does not match the expected type %r.")
289
	295
290	296	for section, conf in config.items():
291	297	if isinstance(conf, dict):
292	298	for k, v in conf.items():

304	310	if expected_type and vtype != expected_type:
305	311	warnings.warn(msg % (k, section, vtype.__name__,
306	312	expected_type.__name__))
307
	313
308	314	def check_config_types(self):
309	315	"""Assert that config values are of the same type as default values."""
310	316	self._known_types(cherrypy.config)

312	318	if not isinstance(app, cherrypy.Application):
313	319	continue
314	320	self._known_types(app.config)
315
316
	321
317	322	# -------------------- Specific config warnings -------------------- #
318
319	323	def check_localhost(self):
320	324	"""Warn if any socket_host is 'localhost'. See #711."""
321	325	for k, v in cherrypy.config.items():
322	326	if k == 'server.socket_host' and v == 'localhost':
323	327	warnings.warn("The use of 'localhost' as a socket host can "
324		"cause problems on newer systems, since 'localhost' can "
325		"map to either an IPv4 or an IPv6 address. You should "
326		"use '127.0.0.1' or '[::1]' instead.")
	328	"cause problems on newer systems, since "
	329	"'localhost' can map to either an IPv4 or an "
	330	"IPv6 address. You should use '127.0.0.1' "
	331	"or '[::1]' instead.")

+101

-36

cherrypy/_cpcompat.py less more

17	17	import os
18	18	import re
19	19	import sys
	20	import threading
20	21
21	22	if sys.version_info >= (3, 0):
22	23	py3k = True

24	25	unicodestr = str
25	26	nativestr = unicodestr
26	27	basestring = (bytes, str)
	28
27	29	def ntob(n, encoding='ISO-8859-1'):
28		"""Return the given native string as a byte string in the given encoding."""
	30	"""Return the given native string as a byte string in the given
	31	encoding.
	32	"""
	33	assert_native(n)
29	34	# In Python 3, the native string type is unicode
30	35	return n.encode(encoding)
	36
31	37	def ntou(n, encoding='ISO-8859-1'):
32		"""Return the given native string as a unicode string with the given encoding."""
	38	"""Return the given native string as a unicode string with the given
	39	encoding.
	40	"""
	41	assert_native(n)
33	42	# In Python 3, the native string type is unicode
34	43	return n
	44
35	45	def tonative(n, encoding='ISO-8859-1'):
36	46	"""Return the given string as a native string in the given encoding."""
37	47	# In Python 3, the native string type is unicode

49	59	unicodestr = unicode
50	60	nativestr = bytestr
51	61	basestring = basestring
	62
52	63	def ntob(n, encoding='ISO-8859-1'):
53		"""Return the given native string as a byte string in the given encoding."""
	64	"""Return the given native string as a byte string in the given
	65	encoding.
	66	"""
	67	assert_native(n)
54	68	# In Python 2, the native string type is bytes. Assume it's already
55	69	# in the given encoding, which for ISO-8859-1 is almost always what
56	70	# was intended.
57	71	return n
	72
58	73	def ntou(n, encoding='ISO-8859-1'):
59		"""Return the given native string as a unicode string with the given encoding."""
	74	"""Return the given native string as a unicode string with the given
	75	encoding.
	76	"""
	77	assert_native(n)
60	78	# In Python 2, the native string type is bytes.
61		# First, check for the special encoding 'escape'. The test suite uses this
62		# to signal that it wants to pass a string with embedded \uXXXX escapes,
63		# but without having to prefix it with u'' for Python 2, but no prefix
64		# for Python 3.
	79	# First, check for the special encoding 'escape'. The test suite uses
	80	# this to signal that it wants to pass a string with embedded \uXXXX
	81	# escapes, but without having to prefix it with u'' for Python 2,
	82	# but no prefix for Python 3.
65	83	if encoding == 'escape':
66	84	return unicode(
67	85	re.sub(r'\\u([0-9a-zA-Z]{4})',
68	86	lambda m: unichr(int(m.group(1), 16)),
69	87	n.decode('ISO-8859-1')))
70		# Assume it's already in the given encoding, which for ISO-8859-1 is almost
71		# always what was intended.
	88	# Assume it's already in the given encoding, which for ISO-8859-1
	89	# is almost always what was intended.
72	90	return n.decode(encoding)
	91
73	92	def tonative(n, encoding='ISO-8859-1'):
74	93	"""Return the given string as a native string in the given encoding."""
75	94	# In Python 2, the native string type is bytes.

85	104	# bytes:
86	105	BytesIO = StringIO
87	106
	107
	108	def assert_native(n):
	109	if not isinstance(n, nativestr):
	110	raise TypeError("n must be a native str (got %s)" % type(n).__name__)
	111
88	112	try:
89	113	set = set
90	114	except NameError:

98	122	# since CherryPy claims compability with Python 2.3, we must use
99	123	# the legacy API of base64
100	124	from base64 import decodestring as _base64_decodebytes
	125
101	126
102	127	def base64_decode(n, encoding='ISO-8859-1'):
103	128	"""Return the native string base64-decoded (as a native string)."""

197	222	import __builtin__ as builtins
198	223
199	224	try:
200		# Python 2. We have to do it in this order so Python 2 builds
	225	# Python 2. We try Python 2 first clients on Python 2
201	226	# don't try to import the 'http' module from cherrypy.lib
202	227	from Cookie import SimpleCookie, CookieError
203		from httplib import BadStatusLine, HTTPConnection, HTTPSConnection, IncompleteRead, NotConnected
	228	from httplib import BadStatusLine, HTTPConnection, IncompleteRead
	229	from httplib import NotConnected
204	230	from BaseHTTPServer import BaseHTTPRequestHandler
205	231	except ImportError:
206	232	# Python 3
207	233	from http.cookies import SimpleCookie, CookieError
208		from http.client import BadStatusLine, HTTPConnection, HTTPSConnection, IncompleteRead, NotConnected
	234	from http.client import BadStatusLine, HTTPConnection, IncompleteRead
	235	from http.client import NotConnected
209	236	from http.server import BaseHTTPRequestHandler
210	237
211		try:
212		# Python 2. We have to do it in this order so Python 2 builds
213		# don't try to import the 'http' module from cherrypy.lib
214		from httplib import HTTPSConnection
215		except ImportError:
	238	# Some platforms don't expose HTTPSConnection, so handle it separately
	239	if py3k:
216	240	try:
217		# Python 3
218	241	from http.client import HTTPSConnection
219	242	except ImportError:
220	243	# Some platforms which don't have SSL don't expose HTTPSConnection
	244	HTTPSConnection = None
	245	else:
	246	try:
	247	from httplib import HTTPSConnection
	248	except ImportError:
221	249	HTTPSConnection = None
222	250
223	251	try:

232	260	# Python 2.6+
233	261	def get_daemon(t):
234	262	return t.daemon
	263
235	264	def set_daemon(t, val):
236	265	t.daemon = val
237	266	else:
238	267	def get_daemon(t):
239	268	return t.isDaemon()
	269
240	270	def set_daemon(t, val):
241	271	t.setDaemon(val)
242	272
243	273	try:
244	274	from email.utils import formatdate
	275
245	276	def HTTPDate(timeval=None):
246	277	return formatdate(timeval, usegmt=True)
247	278	except ImportError:

250	281	try:
251	282	# Python 3
252	283	from urllib.parse import unquote as parse_unquote
	284
253	285	def unquote_qs(atom, encoding, errors='strict'):
254		return parse_unquote(atom.replace('+', ' '), encoding=encoding, errors=errors)
	286	return parse_unquote(
	287	atom.replace('+', ' '),
	288	encoding=encoding,
	289	errors=errors)
255	290	except ImportError:
256	291	# Python 2
257	292	from urllib import unquote as parse_unquote
	293
258	294	def unquote_qs(atom, encoding, errors='strict'):
259	295	return parse_unquote(atom.replace('+', ' ')).decode(encoding, errors)
260	296
261	297	try:
262		# Prefer simplejson, which is usually more advanced than the builtin module.
	298	# Prefer simplejson, which is usually more advanced than the builtin
	299	# module.
263	300	import simplejson as json
264	301	json_decode = json.JSONDecoder().decode
265		json_encode = json.JSONEncoder().iterencode
266		except ImportError:
267		if py3k:
268		# Python 3.0: json is part of the standard library,
269		# but outputs unicode. We need bytes.
	302	_json_encode = json.JSONEncoder().iterencode
	303	except ImportError:
	304	if sys.version_info >= (2, 6):
	305	# Python >=2.6 : json is part of the standard library
270	306	import json
271	307	json_decode = json.JSONDecoder().decode
272	308	_json_encode = json.JSONEncoder().iterencode
	309	else:
	310	json = None
	311
	312	def json_decode(s):
	313	raise ValueError('No JSON library is available')
	314
	315	def _json_encode(s):
	316	raise ValueError('No JSON library is available')
	317	finally:
	318	if json and py3k:
	319	# The two Python 3 implementations (simplejson/json)
	320	# outputs str. We need bytes.
273	321	def json_encode(value):
274	322	for chunk in _json_encode(value):
275	323	yield chunk.encode('utf8')
276		elif sys.version_info >= (2, 6):
277		# Python 2.6: json is part of the standard library
278		import json
279		json_decode = json.JSONDecoder().decode
280		json_encode = json.JSONEncoder().iterencode
281	324	else:
282		json = None
283		def json_decode(s):
284		raise ValueError('No JSON library is available')
285		def json_encode(s):
286		raise ValueError('No JSON library is available')
	325	json_encode = _json_encode
	326
287	327
288	328	try:
289	329	import cPickle as pickle

295	335	try:
296	336	os.urandom(20)
297	337	import binascii
	338
298	339	def random20():
299	340	return binascii.hexlify(os.urandom(20)).decode('ascii')
300	341	except (AttributeError, NotImplementedError):
301	342	import random
302	343	# os.urandom not available until Python 2.4. Fall back to random.random.
	344
303	345	def random20():
304	346	return sha('%s' % random.random()).hexdigest()
305	347

315	357	# Python 2
316	358	def next(i):
317	359	return i.next()
	360
	361	if sys.version_info >= (3, 3):
	362	Timer = threading.Timer
	363	Event = threading.Event
	364	else:
	365	# Python 3.2 and earlier
	366	Timer = threading._Timer
	367	Event = threading._Event
	368
	369	# Prior to Python 2.6, the Thread class did not have a .daemon property.
	370	# This mix-in adds that property.
	371
	372
	373	class SetDaemonProperty:
	374
	375	def __get_daemon(self):
	376	return self.isDaemon()
	377
	378	def __set_daemon(self, daemon):
	379	self.setDaemon(daemon)
	380
	381	if sys.version_info < (2, 6):
	382	daemon = property(__get_daemon, __set_daemon)

+1544

-0

cherrypy/_cpcompat_subprocess.py less more

	0	# subprocess - Subprocesses with accessible I/O streams
	1	#
	2	# For more information about this module, see PEP 324.
	3	#
	4	# This module should remain compatible with Python 2.2, see PEP 291.
	5	#
	6	# Copyright (c) 2003-2005 by Peter Astrand <astrand@lysator.liu.se>
	7	#
	8	# Licensed to PSF under a Contributor Agreement.
	9	# See http://www.python.org/2.4/license for licensing details.
	10
	11	r"""subprocess - Subprocesses with accessible I/O streams
	12
	13	This module allows you to spawn processes, connect to their
	14	input/output/error pipes, and obtain their return codes. This module
	15	intends to replace several other, older modules and functions, like:
	16
	17	os.system
	18	os.spawn*
	19	os.popen*
	20	popen2.*
	21	commands.*
	22
	23	Information about how the subprocess module can be used to replace these
	24	modules and functions can be found below.
	25
	26
	27
	28	Using the subprocess module
	29	===========================
	30	This module defines one class called Popen:
	31
	32	class Popen(args, bufsize=0, executable=None,
	33	stdin=None, stdout=None, stderr=None,
	34	preexec_fn=None, close_fds=False, shell=False,
	35	cwd=None, env=None, universal_newlines=False,
	36	startupinfo=None, creationflags=0):
	37
	38
	39	Arguments are:
	40
	41	args should be a string, or a sequence of program arguments. The
	42	program to execute is normally the first item in the args sequence or
	43	string, but can be explicitly set by using the executable argument.
	44
	45	On UNIX, with shell=False (default): In this case, the Popen class
	46	uses os.execvp() to execute the child program. args should normally
	47	be a sequence. A string will be treated as a sequence with the string
	48	as the only item (the program to execute).
	49
	50	On UNIX, with shell=True: If args is a string, it specifies the
	51	command string to execute through the shell. If args is a sequence,
	52	the first item specifies the command string, and any additional items
	53	will be treated as additional shell arguments.
	54
	55	On Windows: the Popen class uses CreateProcess() to execute the child
	56	program, which operates on strings. If args is a sequence, it will be
	57	converted to a string using the list2cmdline method. Please note that
	58	not all MS Windows applications interpret the command line the same
	59	way: The list2cmdline is designed for applications using the same
	60	rules as the MS C runtime.
	61
	62	bufsize, if given, has the same meaning as the corresponding argument
	63	to the built-in open() function: 0 means unbuffered, 1 means line
	64	buffered, any other positive value means use a buffer of
	65	(approximately) that size. A negative bufsize means to use the system
	66	default, which usually means fully buffered. The default value for
	67	bufsize is 0 (unbuffered).
	68
	69	stdin, stdout and stderr specify the executed programs' standard
	70	input, standard output and standard error file handles, respectively.
	71	Valid values are PIPE, an existing file descriptor (a positive
	72	integer), an existing file object, and None. PIPE indicates that a
	73	new pipe to the child should be created. With None, no redirection
	74	will occur; the child's file handles will be inherited from the
	75	parent. Additionally, stderr can be STDOUT, which indicates that the
	76	stderr data from the applications should be captured into the same
	77	file handle as for stdout.
	78
	79	If preexec_fn is set to a callable object, this object will be called
	80	in the child process just before the child is executed.
	81
	82	If close_fds is true, all file descriptors except 0, 1 and 2 will be
	83	closed before the child process is executed.
	84
	85	if shell is true, the specified command will be executed through the
	86	shell.
	87
	88	If cwd is not None, the current directory will be changed to cwd
	89	before the child is executed.
	90
	91	If env is not None, it defines the environment variables for the new
	92	process.
	93
	94	If universal_newlines is true, the file objects stdout and stderr are
	95	opened as a text files, but lines may be terminated by any of '\n',
	96	the Unix end-of-line convention, '\r', the Macintosh convention or
	97	'\r\n', the Windows convention. All of these external representations
	98	are seen as '\n' by the Python program. Note: This feature is only
	99	available if Python is built with universal newline support (the
	100	default). Also, the newlines attribute of the file objects stdout,
	101	stdin and stderr are not updated by the communicate() method.
	102
	103	The startupinfo and creationflags, if given, will be passed to the
	104	underlying CreateProcess() function. They can specify things such as
	105	appearance of the main window and priority for the new process.
	106	(Windows only)
	107
	108
	109	This module also defines some shortcut functions:
	110
	111	call(popenargs, *kwargs):
	112	Run command with arguments. Wait for command to complete, then
	113	return the returncode attribute.
	114
	115	The arguments are the same as for the Popen constructor. Example:
	116
	117	retcode = call(["ls", "-l"])
	118
	119	check_call(popenargs, *kwargs):
	120	Run command with arguments. Wait for command to complete. If the
	121	exit code was zero then return, otherwise raise
	122	CalledProcessError. The CalledProcessError object will have the
	123	return code in the returncode attribute.
	124
	125	The arguments are the same as for the Popen constructor. Example:
	126
	127	check_call(["ls", "-l"])
	128
	129	check_output(popenargs, *kwargs):
	130	Run command with arguments and return its output as a byte string.
	131
	132	If the exit code was non-zero it raises a CalledProcessError. The
	133	CalledProcessError object will have the return code in the returncode
	134	attribute and output in the output attribute.
	135
	136	The arguments are the same as for the Popen constructor. Example:
	137
	138	output = check_output(["ls", "-l", "/dev/null"])
	139
	140
	141	Exceptions
	142	----------
	143	Exceptions raised in the child process, before the new program has
	144	started to execute, will be re-raised in the parent. Additionally,
	145	the exception object will have one extra attribute called
	146	'child_traceback', which is a string containing traceback information
	147	from the childs point of view.
	148
	149	The most common exception raised is OSError. This occurs, for
	150	example, when trying to execute a non-existent file. Applications
	151	should prepare for OSErrors.
	152
	153	A ValueError will be raised if Popen is called with invalid arguments.
	154
	155	check_call() and check_output() will raise CalledProcessError, if the
	156	called process returns a non-zero return code.
	157
	158
	159	Security
	160	--------
	161	Unlike some other popen functions, this implementation will never call
	162	/bin/sh implicitly. This means that all characters, including shell
	163	metacharacters, can safely be passed to child processes.
	164
	165
	166	Popen objects
	167	=============
	168	Instances of the Popen class have the following methods:
	169
	170	poll()
	171	Check if child process has terminated. Returns returncode
	172	attribute.
	173
	174	wait()
	175	Wait for child process to terminate. Returns returncode attribute.
	176
	177	communicate(input=None)
	178	Interact with process: Send data to stdin. Read data from stdout
	179	and stderr, until end-of-file is reached. Wait for process to
	180	terminate. The optional input argument should be a string to be
	181	sent to the child process, or None, if no data should be sent to
	182	the child.
	183
	184	communicate() returns a tuple (stdout, stderr).
	185
	186	Note: The data read is buffered in memory, so do not use this
	187	method if the data size is large or unlimited.
	188
	189	The following attributes are also available:
	190
	191	stdin
	192	If the stdin argument is PIPE, this attribute is a file object
	193	that provides input to the child process. Otherwise, it is None.
	194
	195	stdout
	196	If the stdout argument is PIPE, this attribute is a file object
	197	that provides output from the child process. Otherwise, it is
	198	None.
	199
	200	stderr
	201	If the stderr argument is PIPE, this attribute is file object that
	202	provides error output from the child process. Otherwise, it is
	203	None.
	204
	205	pid
	206	The process ID of the child process.
	207
	208	returncode
	209	The child return code. A None value indicates that the process
	210	hasn't terminated yet. A negative value -N indicates that the
	211	child was terminated by signal N (UNIX only).
	212
	213
	214	Replacing older functions with the subprocess module
	215	====================================================
	216	In this section, "a ==> b" means that b can be used as a replacement
	217	for a.
	218
	219	Note: All functions in this section fail (more or less) silently if
	220	the executed program cannot be found; this module raises an OSError
	221	exception.
	222
	223	In the following examples, we assume that the subprocess module is
	224	imported with "from subprocess import *".
	225
	226
	227	Replacing /bin/sh shell backquote
	228	---------------------------------
	229	output=`mycmd myarg`
	230	==>
	231	output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
	232
	233
	234	Replacing shell pipe line
	235	-------------------------
	236	output=`dmesg \| grep hda`
	237	==>
	238	p1 = Popen(["dmesg"], stdout=PIPE)
	239	p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
	240	output = p2.communicate()[0]
	241
	242
	243	Replacing os.system()
	244	---------------------
	245	sts = os.system("mycmd" + " myarg")
	246	==>
	247	p = Popen("mycmd" + " myarg", shell=True)
	248	pid, sts = os.waitpid(p.pid, 0)
	249
	250	Note:
	251
	252	* Calling the program through the shell is usually not required.
	253
	254	* It's easier to look at the returncode attribute than the
	255	exitstatus.
	256
	257	A more real-world example would look like this:
	258
	259	try:
	260	retcode = call("mycmd" + " myarg", shell=True)
	261	if retcode < 0:
	262	print >>sys.stderr, "Child was terminated by signal", -retcode
	263	else:
	264	print >>sys.stderr, "Child returned", retcode
	265	except OSError, e:
	266	print >>sys.stderr, "Execution failed:", e
	267
	268
	269	Replacing os.spawn*
	270	-------------------
	271	P_NOWAIT example:
	272
	273	pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
	274	==>
	275	pid = Popen(["/bin/mycmd", "myarg"]).pid
	276
	277
	278	P_WAIT example:
	279
	280	retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
	281	==>
	282	retcode = call(["/bin/mycmd", "myarg"])
	283
	284
	285	Vector example:
	286
	287	os.spawnvp(os.P_NOWAIT, path, args)
	288	==>
	289	Popen([path] + args[1:])
	290
	291
	292	Environment example:
	293
	294	os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
	295	==>
	296	Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
	297
	298
	299	Replacing os.popen*
	300	-------------------
	301	pipe = os.popen("cmd", mode='r', bufsize)
	302	==>
	303	pipe = Popen("cmd", shell=True, bufsize=bufsize, stdout=PIPE).stdout
	304
	305	pipe = os.popen("cmd", mode='w', bufsize)
	306	==>
	307	pipe = Popen("cmd", shell=True, bufsize=bufsize, stdin=PIPE).stdin
	308
	309
	310	(child_stdin, child_stdout) = os.popen2("cmd", mode, bufsize)
	311	==>
	312	p = Popen("cmd", shell=True, bufsize=bufsize,
	313	stdin=PIPE, stdout=PIPE, close_fds=True)
	314	(child_stdin, child_stdout) = (p.stdin, p.stdout)
	315
	316
	317	(child_stdin,
	318	child_stdout,
	319	child_stderr) = os.popen3("cmd", mode, bufsize)
	320	==>
	321	p = Popen("cmd", shell=True, bufsize=bufsize,
	322	stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
	323	(child_stdin,
	324	child_stdout,
	325	child_stderr) = (p.stdin, p.stdout, p.stderr)
	326
	327
	328	(child_stdin, child_stdout_and_stderr) = os.popen4("cmd", mode,
	329	bufsize)
	330	==>
	331	p = Popen("cmd", shell=True, bufsize=bufsize,
	332	stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
	333	(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
	334
	335	On Unix, os.popen2, os.popen3 and os.popen4 also accept a sequence as
	336	the command to execute, in which case arguments will be passed
	337	directly to the program without shell intervention. This usage can be
	338	replaced as follows:
	339
	340	(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
	341	bufsize)
	342	==>
	343	p = Popen(["/bin/ls", "-l"], bufsize=bufsize, stdin=PIPE, stdout=PIPE)
	344	(child_stdin, child_stdout) = (p.stdin, p.stdout)
	345
	346	Return code handling translates as follows:
	347
	348	pipe = os.popen("cmd", 'w')
	349	...
	350	rc = pipe.close()
	351	if rc is not None and rc % 256:
	352	print "There were some errors"
	353	==>
	354	process = Popen("cmd", 'w', shell=True, stdin=PIPE)
	355	...
	356	process.stdin.close()
	357	if process.wait() != 0:
	358	print "There were some errors"
	359
	360
	361	Replacing popen2.*
	362	------------------
	363	(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
	364	==>
	365	p = Popen(["somestring"], shell=True, bufsize=bufsize
	366	stdin=PIPE, stdout=PIPE, close_fds=True)
	367	(child_stdout, child_stdin) = (p.stdout, p.stdin)
	368
	369	On Unix, popen2 also accepts a sequence as the command to execute, in
	370	which case arguments will be passed directly to the program without
	371	shell intervention. This usage can be replaced as follows:
	372
	373	(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize,
	374	mode)
	375	==>
	376	p = Popen(["mycmd", "myarg"], bufsize=bufsize,
	377	stdin=PIPE, stdout=PIPE, close_fds=True)
	378	(child_stdout, child_stdin) = (p.stdout, p.stdin)
	379
	380	The popen2.Popen3 and popen2.Popen4 basically works as subprocess.Popen,
	381	except that:
	382
	383	* subprocess.Popen raises an exception if the execution fails
	384	* the capturestderr argument is replaced with the stderr argument.
	385	* stdin=PIPE and stdout=PIPE must be specified.
	386	* popen2 closes all filedescriptors by default, but you have to specify
	387	close_fds=True with subprocess.Popen.
	388	"""
	389
	390	import sys
	391	mswindows = (sys.platform == "win32")
	392
	393	import os
	394	import types
	395	import traceback
	396	import gc
	397	import signal
	398	import errno
	399
	400	try:
	401	set
	402	except NameError:
	403	from sets import Set as set
	404
	405	# Exception classes used by this module.
	406
	407
	408	class CalledProcessError(Exception):
	409
	410	"""This exception is raised when a process run by check_call() or
	411	check_output() returns a non-zero exit status.
	412	The exit status will be stored in the returncode attribute;
	413	check_output() will also store the output in the output attribute.
	414	"""
	415
	416	def __init__(self, returncode, cmd, output=None):
	417	self.returncode = returncode
	418	self.cmd = cmd
	419	self.output = output
	420
	421	def __str__(self):
	422	return "Command '%s' returned non-zero exit status %d" % (
	423	self.cmd, self.returncode)
	424
	425
	426	if mswindows:
	427	import threading
	428	import msvcrt
	429	import _subprocess
	430
	431	class STARTUPINFO:
	432	dwFlags = 0
	433	hStdInput = None
	434	hStdOutput = None
	435	hStdError = None
	436	wShowWindow = 0
	437
	438	class pywintypes:
	439	error = IOError
	440	else:
	441	import select
	442	_has_poll = hasattr(select, 'poll')
	443	import fcntl
	444	import pickle
	445
	446	# When select or poll has indicated that the file is writable,
	447	# we can write up to _PIPE_BUF bytes without risk of blocking.
	448	# POSIX defines PIPE_BUF as >= 512.
	449	_PIPE_BUF = getattr(select, 'PIPE_BUF', 512)
	450
	451
	452	__all__ = ["Popen", "PIPE", "STDOUT", "call", "check_call",
	453	"check_output", "CalledProcessError"]
	454
	455	if mswindows:
	456	from _subprocess import CREATE_NEW_CONSOLE, CREATE_NEW_PROCESS_GROUP, \
	457	STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, \
	458	STD_ERROR_HANDLE, SW_HIDE, \
	459	STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW
	460
	461	__all__.extend(["CREATE_NEW_CONSOLE", "CREATE_NEW_PROCESS_GROUP",
	462	"STD_INPUT_HANDLE", "STD_OUTPUT_HANDLE",
	463	"STD_ERROR_HANDLE", "SW_HIDE",
	464	"STARTF_USESTDHANDLES", "STARTF_USESHOWWINDOW"])
	465	try:
	466	MAXFD = os.sysconf("SC_OPEN_MAX")
	467	except:
	468	MAXFD = 256
	469
	470	_active = []
	471
	472
	473	def _cleanup():
	474	for inst in _active[:]:
	475	res = inst._internal_poll(_deadstate=sys.maxint)
	476	if res is not None:
	477	try:
	478	_active.remove(inst)
	479	except ValueError:
	480	# This can happen if two threads create a new Popen instance.
	481	# It's harmless that it was already removed, so ignore.
	482	pass
	483
	484	PIPE = -1
	485	STDOUT = -2
	486
	487
	488	def _eintr_retry_call(func, *args):
	489	while True:
	490	try:
	491	return func(*args)
	492	except (OSError, IOError), e:
	493	if e.errno == errno.EINTR:
	494	continue
	495	raise
	496
	497
	498	def call(popenargs, *kwargs):
	499	"""Run command with arguments. Wait for command to complete, then
	500	return the returncode attribute.
	501
	502	The arguments are the same as for the Popen constructor. Example:
	503
	504	retcode = call(["ls", "-l"])
	505	"""
	506	return Popen(popenargs, *kwargs).wait()
	507
	508
	509	def check_call(popenargs, *kwargs):
	510	"""Run command with arguments. Wait for command to complete. If
	511	the exit code was zero then return, otherwise raise
	512	CalledProcessError. The CalledProcessError object will have the
	513	return code in the returncode attribute.
	514
	515	The arguments are the same as for the Popen constructor. Example:
	516
	517	check_call(["ls", "-l"])
	518	"""
	519	retcode = call(popenargs, *kwargs)
	520	if retcode:
	521	cmd = kwargs.get("args")
	522	if cmd is None:
	523	cmd = popenargs[0]
	524	raise CalledProcessError(retcode, cmd)
	525	return 0
	526
	527
	528	def check_output(popenargs, *kwargs):
	529	r"""Run command with arguments and return its output as a byte string.
	530
	531	If the exit code was non-zero it raises a CalledProcessError. The
	532	CalledProcessError object will have the return code in the returncode
	533	attribute and output in the output attribute.
	534
	535	The arguments are the same as for the Popen constructor. Example:
	536
	537	>>> check_output(["ls", "-l", "/dev/null"])
	538	'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'
	539
	540	The stdout argument is not allowed as it is used internally.
	541	To capture standard error in the result, use stderr=STDOUT.
	542
	543	>>> check_output(["/bin/sh", "-c",
	544	... "ls -l non_existent_file ; exit 0"],
	545	... stderr=STDOUT)
	546	'ls: non_existent_file: No such file or directory\n'
	547	"""
	548	if 'stdout' in kwargs:
	549	raise ValueError('stdout argument not allowed, it will be overridden.')
	550	process = Popen(stdout=PIPE, popenargs, *kwargs)
	551	output, unused_err = process.communicate()
	552	retcode = process.poll()
	553	if retcode:
	554	cmd = kwargs.get("args")
	555	if cmd is None:
	556	cmd = popenargs[0]
	557	raise CalledProcessError(retcode, cmd, output=output)
	558	return output
	559
	560
	561	def list2cmdline(seq):
	562	"""
	563	Translate a sequence of arguments into a command line
	564	string, using the same rules as the MS C runtime:
	565
	566	1) Arguments are delimited by white space, which is either a
	567	space or a tab.
	568
	569	2) A string surrounded by double quotation marks is
	570	interpreted as a single argument, regardless of white space
	571	contained within. A quoted string can be embedded in an
	572	argument.
	573
	574	3) A double quotation mark preceded by a backslash is
	575	interpreted as a literal double quotation mark.
	576
	577	4) Backslashes are interpreted literally, unless they
	578	immediately precede a double quotation mark.
	579
	580	5) If backslashes immediately precede a double quotation mark,
	581	every pair of backslashes is interpreted as a literal
	582	backslash. If the number of backslashes is odd, the last
	583	backslash escapes the next double quotation mark as
	584	described in rule 3.
	585	"""
	586
	587	# See
	588	# http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
	589	# or search http://msdn.microsoft.com for
	590	# "Parsing C++ Command-Line Arguments"
	591	result = []
	592	needquote = False
	593	for arg in seq:
	594	bs_buf = []
	595
	596	# Add a space to separate this argument from the others
	597	if result:
	598	result.append(' ')
	599
	600	needquote = (" " in arg) or ("\t" in arg) or not arg
	601	if needquote:
	602	result.append('"')
	603
	604	for c in arg:
	605	if c == '\\':
	606	# Don't know if we need to double yet.
	607	bs_buf.append(c)
	608	elif c == '"':
	609	# Double backslashes.
	610	result.append('\\' * len(bs_buf) * 2)
	611	bs_buf = []
	612	result.append('\\"')
	613	else:
	614	# Normal char
	615	if bs_buf:
	616	result.extend(bs_buf)
	617	bs_buf = []
	618	result.append(c)
	619
	620	# Add remaining backslashes, if any.
	621	if bs_buf:
	622	result.extend(bs_buf)
	623
	624	if needquote:
	625	result.extend(bs_buf)
	626	result.append('"')
	627
	628	return ''.join(result)
	629
	630
	631	class Popen(object):
	632
	633	def __init__(self, args, bufsize=0, executable=None,
	634	stdin=None, stdout=None, stderr=None,
	635	preexec_fn=None, close_fds=False, shell=False,
	636	cwd=None, env=None, universal_newlines=False,
	637	startupinfo=None, creationflags=0):
	638	"""Create new Popen instance."""
	639	_cleanup()
	640
	641	self._child_created = False
	642	if not isinstance(bufsize, (int, long)):
	643	raise TypeError("bufsize must be an integer")
	644
	645	if mswindows:
	646	if preexec_fn is not None:
	647	raise ValueError("preexec_fn is not supported on Windows "
	648	"platforms")
	649	if close_fds and (stdin is not None or stdout is not None or
	650	stderr is not None):
	651	raise ValueError("close_fds is not supported on Windows "
	652	"platforms if you redirect "
	653	"stdin/stdout/stderr")
	654	else:
	655	# POSIX
	656	if startupinfo is not None:
	657	raise ValueError("startupinfo is only supported on Windows "
	658	"platforms")
	659	if creationflags != 0:
	660	raise ValueError("creationflags is only supported on Windows "
	661	"platforms")
	662
	663	self.stdin = None
	664	self.stdout = None
	665	self.stderr = None
	666	self.pid = None
	667	self.returncode = None
	668	self.universal_newlines = universal_newlines
	669
	670	# Input and output objects. The general principle is like
	671	# this:
	672	#
	673	# Parent Child
	674	# ------ -----
	675	# p2cwrite ---stdin---> p2cread
	676	# c2pread <--stdout--- c2pwrite
	677	# errread <--stderr--- errwrite
	678	#
	679	# On POSIX, the child objects are file descriptors. On
	680	# Windows, these are Windows file handles. The parent objects
	681	# are file descriptors on both platforms. The parent objects
	682	# are None when not using PIPEs. The child objects are None
	683	# when not redirecting.
	684
	685	(p2cread, p2cwrite,
	686	c2pread, c2pwrite,
	687	errread, errwrite) = self._get_handles(stdin, stdout, stderr)
	688
	689	self._execute_child(args, executable, preexec_fn, close_fds,
	690	cwd, env, universal_newlines,
	691	startupinfo, creationflags, shell,
	692	p2cread, p2cwrite,
	693	c2pread, c2pwrite,
	694	errread, errwrite)
	695
	696	if mswindows:
	697	if p2cwrite is not None:
	698	p2cwrite = msvcrt.open_osfhandle(p2cwrite.Detach(), 0)
	699	if c2pread is not None:
	700	c2pread = msvcrt.open_osfhandle(c2pread.Detach(), 0)
	701	if errread is not None:
	702	errread = msvcrt.open_osfhandle(errread.Detach(), 0)
	703
	704	if p2cwrite is not None:
	705	self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
	706	if c2pread is not None:
	707	if universal_newlines:
	708	self.stdout = os.fdopen(c2pread, 'rU', bufsize)
	709	else:
	710	self.stdout = os.fdopen(c2pread, 'rb', bufsize)
	711	if errread is not None:
	712	if universal_newlines:
	713	self.stderr = os.fdopen(errread, 'rU', bufsize)
	714	else:
	715	self.stderr = os.fdopen(errread, 'rb', bufsize)
	716
	717	def _translate_newlines(self, data):
	718	data = data.replace("\r\n", "\n")
	719	data = data.replace("\r", "\n")
	720	return data
	721
	722	def __del__(self, _maxint=sys.maxint, _active=_active):
	723	# If __init__ hasn't had a chance to execute (e.g. if it
	724	# was passed an undeclared keyword argument), we don't
	725	# have a _child_created attribute at all.
	726	if not getattr(self, '_child_created', False):
	727	# We didn't get to successfully create a child process.
	728	return
	729	# In case the child hasn't been waited on, check if it's done.
	730	self._internal_poll(_deadstate=_maxint)
	731	if self.returncode is None and _active is not None:
	732	# Child is still running, keep us alive until we can wait on it.
	733	_active.append(self)
	734
	735	def communicate(self, input=None):
	736	"""Interact with process: Send data to stdin. Read data from
	737	stdout and stderr, until end-of-file is reached. Wait for
	738	process to terminate. The optional input argument should be a
	739	string to be sent to the child process, or None, if no data
	740	should be sent to the child.
	741
	742	communicate() returns a tuple (stdout, stderr)."""
	743
	744	# Optimization: If we are only using one pipe, or no pipe at
	745	# all, using select() or threads is unnecessary.
	746	if [self.stdin, self.stdout, self.stderr].count(None) >= 2:
	747	stdout = None
	748	stderr = None
	749	if self.stdin:
	750	if input:
	751	try:
	752	self.stdin.write(input)
	753	except IOError, e:
	754	if e.errno != errno.EPIPE and e.errno != errno.EINVAL:
	755	raise
	756	self.stdin.close()
	757	elif self.stdout:
	758	stdout = _eintr_retry_call(self.stdout.read)
	759	self.stdout.close()
	760	elif self.stderr:
	761	stderr = _eintr_retry_call(self.stderr.read)
	762	self.stderr.close()
	763	self.wait()
	764	return (stdout, stderr)
	765
	766	return self._communicate(input)
	767
	768	def poll(self):
	769	return self._internal_poll()
	770
	771	if mswindows:
	772	#
	773	# Windows methods
	774	#
	775	def _get_handles(self, stdin, stdout, stderr):
	776	"""Construct and return tuple with IO objects:
	777	p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
	778	"""
	779	if stdin is None and stdout is None and stderr is None:
	780	return (None, None, None, None, None, None)
	781
	782	p2cread, p2cwrite = None, None
	783	c2pread, c2pwrite = None, None
	784	errread, errwrite = None, None
	785
	786	if stdin is None:
	787	p2cread = _subprocess.GetStdHandle(
	788	_subprocess.STD_INPUT_HANDLE)
	789	if p2cread is None:
	790	p2cread, _ = _subprocess.CreatePipe(None, 0)
	791	elif stdin == PIPE:
	792	p2cread, p2cwrite = _subprocess.CreatePipe(None, 0)
	793	elif isinstance(stdin, int):
	794	p2cread = msvcrt.get_osfhandle(stdin)
	795	else:
	796	# Assuming file-like object
	797	p2cread = msvcrt.get_osfhandle(stdin.fileno())
	798	p2cread = self._make_inheritable(p2cread)
	799
	800	if stdout is None:
	801	c2pwrite = _subprocess.GetStdHandle(
	802	_subprocess.STD_OUTPUT_HANDLE)
	803	if c2pwrite is None:
	804	_, c2pwrite = _subprocess.CreatePipe(None, 0)
	805	elif stdout == PIPE:
	806	c2pread, c2pwrite = _subprocess.CreatePipe(None, 0)
	807	elif isinstance(stdout, int):
	808	c2pwrite = msvcrt.get_osfhandle(stdout)
	809	else:
	810	# Assuming file-like object
	811	c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
	812	c2pwrite = self._make_inheritable(c2pwrite)
	813
	814	if stderr is None:
	815	errwrite = _subprocess.GetStdHandle(
	816	_subprocess.STD_ERROR_HANDLE)
	817	if errwrite is None:
	818	_, errwrite = _subprocess.CreatePipe(None, 0)
	819	elif stderr == PIPE:
	820	errread, errwrite = _subprocess.CreatePipe(None, 0)
	821	elif stderr == STDOUT:
	822	errwrite = c2pwrite
	823	elif isinstance(stderr, int):
	824	errwrite = msvcrt.get_osfhandle(stderr)
	825	else:
	826	# Assuming file-like object
	827	errwrite = msvcrt.get_osfhandle(stderr.fileno())
	828	errwrite = self._make_inheritable(errwrite)
	829
	830	return (p2cread, p2cwrite,
	831	c2pread, c2pwrite,
	832	errread, errwrite)
	833
	834	def _make_inheritable(self, handle):
	835	"""Return a duplicate of handle, which is inheritable"""
	836	return _subprocess.DuplicateHandle(
	837	_subprocess.GetCurrentProcess(),
	838	handle,
	839	_subprocess.GetCurrentProcess(),
	840	0,
	841	1,
	842	_subprocess.DUPLICATE_SAME_ACCESS
	843	)
	844
	845	def _find_w9xpopen(self):
	846	"""Find and return absolut path to w9xpopen.exe"""
	847	w9xpopen = os.path.join(
	848	os.path.dirname(_subprocess.GetModuleFileName(0)),
	849	"w9xpopen.exe")
	850	if not os.path.exists(w9xpopen):
	851	# Eeek - file-not-found - possibly an embedding
	852	# situation - see if we can locate it in sys.exec_prefix
	853	w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix),
	854	"w9xpopen.exe")
	855	if not os.path.exists(w9xpopen):
	856	raise RuntimeError("Cannot locate w9xpopen.exe, which is "
	857	"needed for Popen to work with your "
	858	"shell or platform.")
	859	return w9xpopen
	860
	861	def _execute_child(self, args, executable, preexec_fn, close_fds,
	862	cwd, env, universal_newlines,
	863	startupinfo, creationflags, shell,
	864	p2cread, p2cwrite,
	865	c2pread, c2pwrite,
	866	errread, errwrite):
	867	"""Execute program (MS Windows version)"""
	868
	869	if not isinstance(args, types.StringTypes):
	870	args = list2cmdline(args)
	871
	872	# Process startup details
	873	if startupinfo is None:
	874	startupinfo = STARTUPINFO()
	875	if None not in (p2cread, c2pwrite, errwrite):
	876	startupinfo.dwFlags \|= _subprocess.STARTF_USESTDHANDLES
	877	startupinfo.hStdInput = p2cread
	878	startupinfo.hStdOutput = c2pwrite
	879	startupinfo.hStdError = errwrite
	880
	881	if shell:
	882	startupinfo.dwFlags \|= _subprocess.STARTF_USESHOWWINDOW
	883	startupinfo.wShowWindow = _subprocess.SW_HIDE
	884	comspec = os.environ.get("COMSPEC", "cmd.exe")
	885	args = '{} /c "{}"'.format(comspec, args)
	886	if (_subprocess.GetVersion() >= 0x80000000 or
	887	os.path.basename(comspec).lower() == "command.com"):
	888	# Win9x, or using command.com on NT. We need to
	889	# use the w9xpopen intermediate program. For more
	890	# information, see KB Q150956
	891	# (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp)
	892	w9xpopen = self._find_w9xpopen()
	893	args = '"%s" %s' % (w9xpopen, args)
	894	# Not passing CREATE_NEW_CONSOLE has been known to
	895	# cause random failures on win9x. Specifically a
	896	# dialog: "Your program accessed mem currently in
	897	# use at xxx" and a hopeful warning about the
	898	# stability of your system. Cost is Ctrl+C wont
	899	# kill children.
	900	creationflags \|= _subprocess.CREATE_NEW_CONSOLE
	901
	902	# Start the process
	903	try:
	904	try:
	905	hp, ht, pid, tid = _subprocess.CreateProcess(
	906	executable, args,
	907	# no special
	908	# security
	909	None, None,
	910	int(not close_fds),
	911	creationflags,
	912	env,
	913	cwd,
	914	startupinfo)
	915	except pywintypes.error, e:
	916	# Translate pywintypes.error to WindowsError, which is
	917	# a subclass of OSError. FIXME: We should really
	918	# translate errno using _sys_errlist (or similar), but
	919	# how can this be done from Python?
	920	raise WindowsError(*e.args)
	921	finally:
	922	# Child is launched. Close the parent's copy of those pipe
	923	# handles that only the child should have open. You need
	924	# to make sure that no handles to the write end of the
	925	# output pipe are maintained in this process or else the
	926	# pipe will not close when the child process exits and the
	927	# ReadFile will hang.
	928	if p2cread is not None:
	929	p2cread.Close()
	930	if c2pwrite is not None:
	931	c2pwrite.Close()
	932	if errwrite is not None:
	933	errwrite.Close()
	934
	935	# Retain the process handle, but close the thread handle
	936	self._child_created = True
	937	self._handle = hp
	938	self.pid = pid
	939	ht.Close()
	940
	941	def _internal_poll(
	942	self, _deadstate=None,
	943	_WaitForSingleObject=_subprocess.WaitForSingleObject,
	944	_WAIT_OBJECT_0=_subprocess.WAIT_OBJECT_0,
	945	_GetExitCodeProcess=_subprocess.GetExitCodeProcess
	946	):
	947	"""Check if child process has terminated. Returns returncode
	948	attribute.
	949
	950	This method is called by __del__, so it can only refer to objects
	951	in its local scope.
	952
	953	"""
	954	if self.returncode is None:
	955	if _WaitForSingleObject(self._handle, 0) == _WAIT_OBJECT_0:
	956	self.returncode = _GetExitCodeProcess(self._handle)
	957	return self.returncode
	958
	959	def wait(self):
	960	"""Wait for child process to terminate. Returns returncode
	961	attribute."""
	962	if self.returncode is None:
	963	_subprocess.WaitForSingleObject(self._handle,
	964	_subprocess.INFINITE)
	965	self.returncode = _subprocess.GetExitCodeProcess(self._handle)
	966	return self.returncode
	967
	968	def _readerthread(self, fh, buffer):
	969	buffer.append(fh.read())
	970
	971	def _communicate(self, input):
	972	stdout = None # Return
	973	stderr = None # Return
	974
	975	if self.stdout:
	976	stdout = []
	977	stdout_thread = threading.Thread(target=self._readerthread,
	978	args=(self.stdout, stdout))
	979	stdout_thread.setDaemon(True)
	980	stdout_thread.start()
	981	if self.stderr:
	982	stderr = []
	983	stderr_thread = threading.Thread(target=self._readerthread,
	984	args=(self.stderr, stderr))
	985	stderr_thread.setDaemon(True)
	986	stderr_thread.start()
	987
	988	if self.stdin:
	989	if input is not None:
	990	try:
	991	self.stdin.write(input)
	992	except IOError, e:
	993	if e.errno != errno.EPIPE:
	994	raise
	995	self.stdin.close()
	996
	997	if self.stdout:
	998	stdout_thread.join()
	999	if self.stderr:
	1000	stderr_thread.join()
	1001
	1002	# All data exchanged. Translate lists into strings.
	1003	if stdout is not None:
	1004	stdout = stdout[0]
	1005	if stderr is not None:
	1006	stderr = stderr[0]
	1007
	1008	# Translate newlines, if requested. We cannot let the file
	1009	# object do the translation: It is based on stdio, which is
	1010	# impossible to combine with select (unless forcing no
	1011	# buffering).
	1012	if self.universal_newlines and hasattr(file, 'newlines'):
	1013	if stdout:
	1014	stdout = self._translate_newlines(stdout)
	1015	if stderr:
	1016	stderr = self._translate_newlines(stderr)
	1017
	1018	self.wait()
	1019	return (stdout, stderr)
	1020
	1021	def send_signal(self, sig):
	1022	"""Send a signal to the process
	1023	"""
	1024	if sig == signal.SIGTERM:
	1025	self.terminate()
	1026	elif sig == signal.CTRL_C_EVENT:
	1027	os.kill(self.pid, signal.CTRL_C_EVENT)
	1028	elif sig == signal.CTRL_BREAK_EVENT:
	1029	os.kill(self.pid, signal.CTRL_BREAK_EVENT)
	1030	else:
	1031	raise ValueError("Unsupported signal: {}".format(sig))
	1032
	1033	def terminate(self):
	1034	"""Terminates the process
	1035	"""
	1036	_subprocess.TerminateProcess(self._handle, 1)
	1037
	1038	kill = terminate
	1039
	1040	else:
	1041	#
	1042	# POSIX methods
	1043	#
	1044	def _get_handles(self, stdin, stdout, stderr):
	1045	"""Construct and return tuple with IO objects:
	1046	p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
	1047	"""
	1048	p2cread, p2cwrite = None, None
	1049	c2pread, c2pwrite = None, None
	1050	errread, errwrite = None, None
	1051
	1052	if stdin is None:
	1053	pass
	1054	elif stdin == PIPE:
	1055	p2cread, p2cwrite = self.pipe_cloexec()
	1056	elif isinstance(stdin, int):
	1057	p2cread = stdin
	1058	else:
	1059	# Assuming file-like object
	1060	p2cread = stdin.fileno()
	1061
	1062	if stdout is None:
	1063	pass
	1064	elif stdout == PIPE:
	1065	c2pread, c2pwrite = self.pipe_cloexec()
	1066	elif isinstance(stdout, int):
	1067	c2pwrite = stdout
	1068	else:
	1069	# Assuming file-like object
	1070	c2pwrite = stdout.fileno()
	1071
	1072	if stderr is None:
	1073	pass
	1074	elif stderr == PIPE:
	1075	errread, errwrite = self.pipe_cloexec()
	1076	elif stderr == STDOUT:
	1077	errwrite = c2pwrite
	1078	elif isinstance(stderr, int):
	1079	errwrite = stderr
	1080	else:
	1081	# Assuming file-like object
	1082	errwrite = stderr.fileno()
	1083
	1084	return (p2cread, p2cwrite,
	1085	c2pread, c2pwrite,
	1086	errread, errwrite)
	1087
	1088	def _set_cloexec_flag(self, fd, cloexec=True):
	1089	try:
	1090	cloexec_flag = fcntl.FD_CLOEXEC
	1091	except AttributeError:
	1092	cloexec_flag = 1
	1093
	1094	old = fcntl.fcntl(fd, fcntl.F_GETFD)
	1095	if cloexec:
	1096	fcntl.fcntl(fd, fcntl.F_SETFD, old \| cloexec_flag)
	1097	else:
	1098	fcntl.fcntl(fd, fcntl.F_SETFD, old & ~cloexec_flag)
	1099
	1100	def pipe_cloexec(self):
	1101	"""Create a pipe with FDs set CLOEXEC."""
	1102	# Pipes' FDs are set CLOEXEC by default because we don't want them
	1103	# to be inherited by other subprocesses: the CLOEXEC flag is
	1104	# removed from the child's FDs by _dup2(), between fork() and
	1105	# exec().
	1106	# This is not atomic: we would need the pipe2() syscall for that.
	1107	r, w = os.pipe()
	1108	self._set_cloexec_flag(r)
	1109	self._set_cloexec_flag(w)
	1110	return r, w
	1111
	1112	def _close_fds(self, but):
	1113	if hasattr(os, 'closerange'):
	1114	os.closerange(3, but)
	1115	os.closerange(but + 1, MAXFD)
	1116	else:
	1117	for i in xrange(3, MAXFD):
	1118	if i == but:
	1119	continue
	1120	try:
	1121	os.close(i)
	1122	except:
	1123	pass
	1124
	1125	def _execute_child(self, args, executable, preexec_fn, close_fds,
	1126	cwd, env, universal_newlines,
	1127	startupinfo, creationflags, shell,
	1128	p2cread, p2cwrite,
	1129	c2pread, c2pwrite,
	1130	errread, errwrite):
	1131	"""Execute program (POSIX version)"""
	1132
	1133	if isinstance(args, types.StringTypes):
	1134	args = [args]
	1135	else:
	1136	args = list(args)
	1137
	1138	if shell:
	1139	args = ["/bin/sh", "-c"] + args
	1140	if executable:
	1141	args[0] = executable
	1142
	1143	if executable is None:
	1144	executable = args[0]
	1145
	1146	# For transferring possible exec failure from child to parent
	1147	# The first char specifies the exception type: 0 means
	1148	# OSError, 1 means some other error.
	1149	errpipe_read, errpipe_write = self.pipe_cloexec()
	1150	try:
	1151	try:
	1152	gc_was_enabled = gc.isenabled()
	1153	# Disable gc to avoid bug where gc -> file_dealloc ->
	1154	# write to stderr -> hang.
	1155	# http://bugs.python.org/issue1336
	1156	gc.disable()
	1157	try:
	1158	self.pid = os.fork()
	1159	except:
	1160	if gc_was_enabled:
	1161	gc.enable()
	1162	raise
	1163	self._child_created = True
	1164	if self.pid == 0:
	1165	# Child
	1166	try:
	1167	# Close parent's pipe ends
	1168	if p2cwrite is not None:
	1169	os.close(p2cwrite)
	1170	if c2pread is not None:
	1171	os.close(c2pread)
	1172	if errread is not None:
	1173	os.close(errread)
	1174	os.close(errpipe_read)
	1175
	1176	# When duping fds, if there arises a situation
	1177	# where one of the fds is either 0, 1 or 2, it
	1178	# is possible that it is overwritten (#12607).
	1179	if c2pwrite == 0:
	1180	c2pwrite = os.dup(c2pwrite)
	1181	if errwrite == 0 or errwrite == 1:
	1182	errwrite = os.dup(errwrite)
	1183
	1184	# Dup fds for child
	1185	def _dup2(a, b):
	1186	# dup2() removes the CLOEXEC flag but
	1187	# we must do it ourselves if dup2()
	1188	# would be a no-op (issue #10806).
	1189	if a == b:
	1190	self._set_cloexec_flag(a, False)
	1191	elif a is not None:
	1192	os.dup2(a, b)
	1193	_dup2(p2cread, 0)
	1194	_dup2(c2pwrite, 1)
	1195	_dup2(errwrite, 2)
	1196
	1197	# Close pipe fds. Make sure we don't close the
	1198	# same fd more than once, or standard fds.
	1199	closed = set([None])
	1200	for fd in [p2cread, c2pwrite, errwrite]:
	1201	if fd not in closed and fd > 2:
	1202	os.close(fd)
	1203	closed.add(fd)
	1204
	1205	# Close all other fds, if asked for
	1206	if close_fds:
	1207	self._close_fds(but=errpipe_write)
	1208
	1209	if cwd is not None:
	1210	os.chdir(cwd)
	1211
	1212	if preexec_fn:
	1213	preexec_fn()
	1214
	1215	if env is None:
	1216	os.execvp(executable, args)
	1217	else:
	1218	os.execvpe(executable, args, env)
	1219
	1220	except:
	1221	exc_type, exc_value, tb = sys.exc_info()
	1222	# Save the traceback and attach it to the exception
	1223	# object
	1224	exc_lines = traceback.format_exception(exc_type,
	1225	exc_value,
	1226	tb)
	1227	exc_value.child_traceback = ''.join(exc_lines)
	1228	os.write(errpipe_write, pickle.dumps(exc_value))
	1229
	1230	# This exitcode won't be reported to applications,
	1231	# so it really doesn't matter what we return.
	1232	os._exit(255)
	1233
	1234	# Parent
	1235	if gc_was_enabled:
	1236	gc.enable()
	1237	finally:
	1238	# be sure the FD is closed no matter what
	1239	os.close(errpipe_write)
	1240
	1241	if p2cread is not None and p2cwrite is not None:
	1242	os.close(p2cread)
	1243	if c2pwrite is not None and c2pread is not None:
	1244	os.close(c2pwrite)
	1245	if errwrite is not None and errread is not None:
	1246	os.close(errwrite)
	1247
	1248	# Wait for exec to fail or succeed; possibly raising exception
	1249	# Exception limited to 1M
	1250	data = _eintr_retry_call(os.read, errpipe_read, 1048576)
	1251	finally:
	1252	# be sure the FD is closed no matter what
	1253	os.close(errpipe_read)
	1254
	1255	if data != "":
	1256	try:
	1257	_eintr_retry_call(os.waitpid, self.pid, 0)
	1258	except OSError, e:
	1259	if e.errno != errno.ECHILD:
	1260	raise
	1261	child_exception = pickle.loads(data)
	1262	for fd in (p2cwrite, c2pread, errread):
	1263	if fd is not None:
	1264	os.close(fd)
	1265	raise child_exception
	1266
	1267	def _handle_exitstatus(self, sts, _WIFSIGNALED=os.WIFSIGNALED,
	1268	_WTERMSIG=os.WTERMSIG, _WIFEXITED=os.WIFEXITED,
	1269	_WEXITSTATUS=os.WEXITSTATUS):
	1270	# This method is called (indirectly) by __del__, so it cannot
	1271	# refer to anything outside of its local scope."""
	1272	if _WIFSIGNALED(sts):
	1273	self.returncode = -_WTERMSIG(sts)
	1274	elif _WIFEXITED(sts):
	1275	self.returncode = _WEXITSTATUS(sts)
	1276	else:
	1277	# Should never happen
	1278	raise RuntimeError("Unknown child exit status!")
	1279
	1280	def _internal_poll(self, _deadstate=None, _waitpid=os.waitpid,
	1281	_WNOHANG=os.WNOHANG, _os_error=os.error):
	1282	"""Check if child process has terminated. Returns returncode
	1283	attribute.
	1284
	1285	This method is called by __del__, so it cannot reference anything
	1286	outside of the local scope (nor can any methods it calls).
	1287
	1288	"""
	1289	if self.returncode is None:
	1290	try:
	1291	pid, sts = _waitpid(self.pid, _WNOHANG)
	1292	if pid == self.pid:
	1293	self._handle_exitstatus(sts)
	1294	except _os_error:
	1295	if _deadstate is not None:
	1296	self.returncode = _deadstate
	1297	return self.returncode
	1298
	1299	def wait(self):
	1300	"""Wait for child process to terminate. Returns returncode
	1301	attribute."""
	1302	if self.returncode is None:
	1303	try:
	1304	pid, sts = _eintr_retry_call(os.waitpid, self.pid, 0)
	1305	except OSError, e:
	1306	if e.errno != errno.ECHILD:
	1307	raise
	1308	# This happens if SIGCLD is set to be ignored or waiting
	1309	# for child processes has otherwise been disabled for our
	1310	# process. This child is dead, we can't get the status.
	1311	sts = 0
	1312	self._handle_exitstatus(sts)
	1313	return self.returncode
	1314
	1315	def _communicate(self, input):
	1316	if self.stdin:
	1317	# Flush stdio buffer. This might block, if the user has
	1318	# been writing to .stdin in an uncontrolled fashion.
	1319	self.stdin.flush()
	1320	if not input:
	1321	self.stdin.close()
	1322
	1323	if _has_poll:
	1324	stdout, stderr = self._communicate_with_poll(input)
	1325	else:
	1326	stdout, stderr = self._communicate_with_select(input)
	1327
	1328	# All data exchanged. Translate lists into strings.
	1329	if stdout is not None:
	1330	stdout = ''.join(stdout)
	1331	if stderr is not None:
	1332	stderr = ''.join(stderr)
	1333
	1334	# Translate newlines, if requested. We cannot let the file
	1335	# object do the translation: It is based on stdio, which is
	1336	# impossible to combine with select (unless forcing no
	1337	# buffering).
	1338	if self.universal_newlines and hasattr(file, 'newlines'):
	1339	if stdout:
	1340	stdout = self._translate_newlines(stdout)
	1341	if stderr:
	1342	stderr = self._translate_newlines(stderr)
	1343
	1344	self.wait()
	1345	return (stdout, stderr)
	1346
	1347	def _communicate_with_poll(self, input):
	1348	stdout = None # Return
	1349	stderr = None # Return
	1350	fd2file = {}
	1351	fd2output = {}
	1352
	1353	poller = select.poll()
	1354
	1355	def register_and_append(file_obj, eventmask):
	1356	poller.register(file_obj.fileno(), eventmask)
	1357	fd2file[file_obj.fileno()] = file_obj
	1358
	1359	def close_unregister_and_remove(fd):
	1360	poller.unregister(fd)
	1361	fd2file[fd].close()
	1362	fd2file.pop(fd)
	1363
	1364	if self.stdin and input:
	1365	register_and_append(self.stdin, select.POLLOUT)
	1366
	1367	select_POLLIN_POLLPRI = select.POLLIN \| select.POLLPRI
	1368	if self.stdout:
	1369	register_and_append(self.stdout, select_POLLIN_POLLPRI)
	1370	fd2output[self.stdout.fileno()] = stdout = []
	1371	if self.stderr:
	1372	register_and_append(self.stderr, select_POLLIN_POLLPRI)
	1373	fd2output[self.stderr.fileno()] = stderr = []
	1374
	1375	input_offset = 0
	1376	while fd2file:
	1377	try:
	1378	ready = poller.poll()
	1379	except select.error, e:
	1380	if e.args[0] == errno.EINTR:
	1381	continue
	1382	raise
	1383
	1384	for fd, mode in ready:
	1385	if mode & select.POLLOUT:
	1386	chunk = input[input_offset: input_offset + _PIPE_BUF]
	1387	try:
	1388	input_offset += os.write(fd, chunk)
	1389	except OSError, e:
	1390	if e.errno == errno.EPIPE:
	1391	close_unregister_and_remove(fd)
	1392	else:
	1393	raise
	1394	else:
	1395	if input_offset >= len(input):
	1396	close_unregister_and_remove(fd)
	1397	elif mode & select_POLLIN_POLLPRI:
	1398	data = os.read(fd, 4096)
	1399	if not data:
	1400	close_unregister_and_remove(fd)
	1401	fd2output[fd].append(data)
	1402	else:
	1403	# Ignore hang up or errors.
	1404	close_unregister_and_remove(fd)
	1405
	1406	return (stdout, stderr)
	1407
	1408	def _communicate_with_select(self, input):
	1409	read_set = []
	1410	write_set = []
	1411	stdout = None # Return
	1412	stderr = None # Return
	1413
	1414	if self.stdin and input:
	1415	write_set.append(self.stdin)
	1416	if self.stdout:
	1417	read_set.append(self.stdout)
	1418	stdout = []
	1419	if self.stderr:
	1420	read_set.append(self.stderr)
	1421	stderr = []
	1422
	1423	input_offset = 0
	1424	while read_set or write_set:
	1425	try:
	1426	rlist, wlist, xlist = select.select(
	1427	read_set, write_set, [])
	1428	except select.error, e:
	1429	if e.args[0] == errno.EINTR:
	1430	continue
	1431	raise
	1432
	1433	if self.stdin in wlist:
	1434	chunk = input[input_offset: input_offset + _PIPE_BUF]
	1435	try:
	1436	bytes_written = os.write(self.stdin.fileno(), chunk)
	1437	except OSError, e:
	1438	if e.errno == errno.EPIPE:
	1439	self.stdin.close()
	1440	write_set.remove(self.stdin)
	1441	else:
	1442	raise
	1443	else:
	1444	input_offset += bytes_written
	1445	if input_offset >= len(input):
	1446	self.stdin.close()
	1447	write_set.remove(self.stdin)
	1448
	1449	if self.stdout in rlist:
	1450	data = os.read(self.stdout.fileno(), 1024)
	1451	if data == "":
	1452	self.stdout.close()
	1453	read_set.remove(self.stdout)
	1454	stdout.append(data)
	1455
	1456	if self.stderr in rlist:
	1457	data = os.read(self.stderr.fileno(), 1024)
	1458	if data == "":
	1459	self.stderr.close()
	1460	read_set.remove(self.stderr)
	1461	stderr.append(data)
	1462
	1463	return (stdout, stderr)
	1464
	1465	def send_signal(self, sig):
	1466	"""Send a signal to the process
	1467	"""
	1468	os.kill(self.pid, sig)
	1469
	1470	def terminate(self):
	1471	"""Terminate the process with SIGTERM
	1472	"""
	1473	self.send_signal(signal.SIGTERM)
	1474
	1475	def kill(self):
	1476	"""Kill the process with SIGKILL
	1477	"""
	1478	self.send_signal(signal.SIGKILL)
	1479
	1480
	1481	def _demo_posix():
	1482	#
	1483	# Example 1: Simple redirection: Get process list
	1484	#
	1485	plist = Popen(["ps"], stdout=PIPE).communicate()[0]
	1486	print "Process list:"
	1487	print plist
	1488
	1489	#
	1490	# Example 2: Change uid before executing child
	1491	#
	1492	if os.getuid() == 0:
	1493	p = Popen(["id"], preexec_fn=lambda: os.setuid(100))
	1494	p.wait()
	1495
	1496	#
	1497	# Example 3: Connecting several subprocesses
	1498	#
	1499	print "Looking for 'hda'..."
	1500	p1 = Popen(["dmesg"], stdout=PIPE)
	1501	p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
	1502	print repr(p2.communicate()[0])
	1503
	1504	#
	1505	# Example 4: Catch execution error
	1506	#
	1507	print
	1508	print "Trying a weird file..."
	1509	try:
	1510	print Popen(["/this/path/does/not/exist"]).communicate()
	1511	except OSError, e:
	1512	if e.errno == errno.ENOENT:
	1513	print "The file didn't exist. I thought so..."
	1514	print "Child traceback:"
	1515	print e.child_traceback
	1516	else:
	1517	print "Error", e.errno
	1518	else:
	1519	print >>sys.stderr, "Gosh. No error."
	1520
	1521
	1522	def _demo_windows():
	1523	#
	1524	# Example 1: Connecting several subprocesses
	1525	#
	1526	print "Looking for 'PROMPT' in set output..."
	1527	p1 = Popen("set", stdout=PIPE, shell=True)
	1528	p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE)
	1529	print repr(p2.communicate()[0])
	1530
	1531	#
	1532	# Example 2: Simple execution of program
	1533	#
	1534	print "Executing calc..."
	1535	p = Popen("calc")
	1536	p.wait()
	1537
	1538
	1539	if __name__ == "__main__":
	1540	if mswindows:
	1541	_demo_windows()
	1542	else:
	1543	_demo_posix()

+43

-21

cherrypy/_cpconfig.py less more

49	49
50	50	class Demo:
51	51	_cp_config = {'tools.gzip.on': True}
52
	52
53	53	def index(self):
54	54	return "Hello world"
55	55	index.exposed = True
56	56	index._cp_config = {'request.show_tracebacks': False}
57	57
58	58	.. note::
59
	59
60	60	This behavior is only guaranteed for the default dispatcher.
61	61	Other dispatchers may have different restrictions on where
62	62	you can attach _cp_config attributes.

124	124	# Deprecated in CherryPy 3.2--remove in 3.3
125	125	NamespaceSet = reprconf.NamespaceSet
126	126
	127
127	128	def merge(base, other):
128	129	"""Merge one app config (from a dict, file, or filename) into another.
129
	130
130	131	If the given config is a filename, it will be appended to
131	132	the list of files to monitor for "autoreload" changes.
132	133	"""
133	134	if isinstance(other, basestring):
134	135	cherrypy.engine.autoreload.files.add(other)
135
	136
136	137	# Load other into base
137	138	for section, value_map in reprconf.as_dict(other).items():
138	139	if not isinstance(value_map, dict):

145	146
146	147
147	148	class Config(reprconf.Config):
	149
148	150	"""The 'global' configuration data for the entire CherryPy process."""
149	151
150	152	def update(self, config):

156	158
157	159	def _apply(self, config):
158	160	"""Update self from a dict."""
159		if isinstance(config.get("global", None), dict):
	161	if isinstance(config.get("global"), dict):
160	162	if len(config) > 1:
161	163	cherrypy.checker.global_config_contained_paths = True
162	164	config = config["global"]
163	165	if 'tools.staticdir.dir' in config:
164	166	config['tools.staticdir.section'] = "global"
165	167	reprconf.Config._apply(self, config)
166
	168
167	169	def __call__(self, args, *kwargs):
168	170	"""Decorator for page handlers to set _cp_config."""
169	171	if args:
170	172	raise TypeError(
171	173	"The cherrypy.config decorator does not accept positional "
172	174	"arguments; you must use keyword arguments.")
	175
173	176	def tool_decorator(f):
174	177	if not hasattr(f, "_cp_config"):
175	178	f._cp_config = {}

179	182	return tool_decorator
180	183
181	184
	185	# Sphinx begin config.environments
182	186	Config.environments = environments = {
183	187	"staging": {
184		'engine.autoreload_on': False,
	188	'engine.autoreload.on': False,
185	189	'checker.on': False,
186	190	'tools.log_headers.on': False,
187	191	'request.show_tracebacks': False,
188	192	'request.show_mismatched_params': False,
189		},
	193	},
190	194	"production": {
191		'engine.autoreload_on': False,
	195	'engine.autoreload.on': False,
192	196	'checker.on': False,
193	197	'tools.log_headers.on': False,
194	198	'request.show_tracebacks': False,
195	199	'request.show_mismatched_params': False,
196	200	'log.screen': False,
197		},
	201	},
198	202	"embedded": {
199	203	# For use with CherryPy embedded in another deployment stack.
200		'engine.autoreload_on': False,
	204	'engine.autoreload.on': False,
201	205	'checker.on': False,
202	206	'tools.log_headers.on': False,
203	207	'request.show_tracebacks': False,

205	209	'log.screen': False,
206	210	'engine.SIGHUP': None,
207	211	'engine.SIGTERM': None,
208		},
	212	},
209	213	"test_suite": {
210		'engine.autoreload_on': False,
	214	'engine.autoreload.on': False,
211	215	'checker.on': False,
212	216	'tools.log_headers.on': False,
213	217	'request.show_tracebacks': True,
214	218	'request.show_mismatched_params': True,
215	219	'log.screen': False,
216		},
217		}
	220	},
	221	}
	222	# Sphinx end config.environments
218	223
219	224
220	225	def _server_namespace_handler(k, v):

225	230	# to configure additional HTTP servers.
226	231	if not hasattr(cherrypy, "servers"):
227	232	cherrypy.servers = {}
228
	233
229	234	servername, k = atoms
230	235	if servername not in cherrypy.servers:
231	236	from cherrypy import _cpserver
232	237	cherrypy.servers[servername] = _cpserver.Server()
233	238	# On by default, but 'on = False' can unsubscribe it (see below).
234	239	cherrypy.servers[servername].subscribe()
235
	240
236	241	if k == 'on':
237	242	if v:
238	243	cherrypy.servers[servername].subscribe()

244	249	setattr(cherrypy.server, k, v)
245	250	Config.namespaces["server"] = _server_namespace_handler
246	251
	252
247	253	def _engine_namespace_handler(k, v):
248	254	"""Backward compatibility handler for the "engine" namespace."""
249	255	engine = cherrypy.engine
	256
	257	deprecated = {
	258	'autoreload_on': 'autoreload.on',
	259	'autoreload_frequency': 'autoreload.frequency',
	260	'autoreload_match': 'autoreload.match',
	261	'reload_files': 'autoreload.files',
	262	'deadlock_poll_freq': 'timeout_monitor.frequency'
	263	}
	264
	265	if k in deprecated:
	266	engine.log(
	267	'WARNING: Use of engine.%s is deprecated and will be removed in a '
	268	'future version. Use engine.%s instead.' % (k, deprecated[k]))
	269
250	270	if k == 'autoreload_on':
251	271	if v:
252	272	engine.autoreload.subscribe()

271	291	if v and hasattr(getattr(plugin, 'subscribe', None), '__call__'):
272	292	plugin.subscribe()
273	293	return
274		elif (not v) and hasattr(getattr(plugin, 'unsubscribe', None), '__call__'):
	294	elif (
	295	(not v) and
	296	hasattr(getattr(plugin, 'unsubscribe', None), '__call__')
	297	):
275	298	plugin.unsubscribe()
276	299	return
277	300	setattr(plugin, attrname, v)

285	308	if isinstance(v, dict):
286	309	for script_name, app in v.items():
287	310	cherrypy.tree.graft(app, script_name)
288		cherrypy.engine.log("Mounted: %s on %s" % (app, script_name or "/"))
	311	cherrypy.engine.log("Mounted: %s on %s" %
	312	(app, script_name or "/"))
289	313	else:
290	314	cherrypy.tree.graft(v, v.script_name)
291	315	cherrypy.engine.log("Mounted: %s on %s" % (v, v.script_name or "/"))
292	316	Config.namespaces["tree"] = _tree_namespace_handler
293
294

+142

-98

cherrypy/_cpdispatch.py less more

21	21
22	22
23	23	class PageHandler(object):
	24
24	25	"""Callable which sets response.body."""
25
	26
26	27	def __init__(self, callable, args, *kwargs):
27	28	self.callable = callable
28	29	self.args = args
29	30	self.kwargs = kwargs
30
	31
	32	def get_args(self):
	33	return cherrypy.serving.request.args
	34
	35	def set_args(self, args):
	36	cherrypy.serving.request.args = args
	37	return cherrypy.serving.request.args
	38
	39	args = property(
	40	get_args,
	41	set_args,
	42	doc="The ordered args should be accessible from post dispatch hooks"
	43	)
	44
	45	def get_kwargs(self):
	46	return cherrypy.serving.request.kwargs
	47
	48	def set_kwargs(self, kwargs):
	49	cherrypy.serving.request.kwargs = kwargs
	50	return cherrypy.serving.request.kwargs
	51
	52	kwargs = property(
	53	get_kwargs,
	54	set_kwargs,
	55	doc="The named kwargs should be accessible from post dispatch hooks"
	56	)
	57
31	58	def __call__(self):
32	59	try:
33	60	return self.callable(self.args, *self.kwargs)

53	80	2. Too little parameters are passed to the function.
54	81
55	82	There are 3 sources of parameters to a cherrypy handler.
56		1. query string parameters are passed as keyword parameters to the handler.
	83	1. query string parameters are passed as keyword parameters to the
	84	handler.
57	85	2. body parameters are also passed as keyword parameters.
58	86	3. when partial matching occurs, the final path atoms are passed as
59	87	positional args.

67	95	(args, varargs, varkw, defaults) = inspect.getargspec(callable)
68	96	except TypeError:
69	97	if isinstance(callable, object) and hasattr(callable, '__call__'):
70		(args, varargs, varkw, defaults) = inspect.getargspec(callable.__call__)
	98	(args, varargs, varkw,
	99	defaults) = inspect.getargspec(callable.__call__)
71	100	else:
72		# If it wasn't one of our own types, re-raise
	101	# If it wasn't one of our own types, re-raise
73	102	# the original error
74	103	raise
75	104

116	145	# 2. not enough body parameters -> 400
117	146	# 3. not enough path parts (partial matches) -> 404
118	147	#
119		# We can't actually tell which case it is,
	148	# We can't actually tell which case it is,
120	149	# so I'm raising a 404 because that covers 2/3 of the
121	150	# possibilities
122		#
	151	#
123	152	# In the case where the method does not allow body
124	153	# arguments it's definitely a 404.
125	154	message = None
126	155	if show_mismatched_params:
127		message="Missing parameters: %s" % ",".join(missing_args)
	156	message = "Missing parameters: %s" % ",".join(missing_args)
128	157	raise cherrypy.HTTPError(404, message=message)
129	158
130	159	# the extra positional arguments come from the path - 404 Not Found

146	175
147	176	message = None
148	177	if show_mismatched_params:
149		message="Multiple values for parameters: "\
150		"%s" % ",".join(multiple_args)
	178	message = "Multiple values for parameters: "\
	179	"%s" % ",".join(multiple_args)
151	180	raise cherrypy.HTTPError(error, message=message)
152	181
153	182	if not varkw and varkw_usage > 0:

157	186	if extra_qs_params:
158	187	message = None
159	188	if show_mismatched_params:
160		message="Unexpected query string "\
161		"parameters: %s" % ", ".join(extra_qs_params)
	189	message = "Unexpected query string "\
	190	"parameters: %s" % ", ".join(extra_qs_params)
162	191	raise cherrypy.HTTPError(404, message=message)
163	192
164	193	# If there were any extra body parameters, it's a 400 Not Found

166	195	if extra_body_params:
167	196	message = None
168	197	if show_mismatched_params:
169		message="Unexpected body parameters: "\
170		"%s" % ", ".join(extra_body_params)
	198	message = "Unexpected body parameters: "\
	199	"%s" % ", ".join(extra_body_params)
171	200	raise cherrypy.HTTPError(400, message=message)
172	201
173	202

177	206	test_callable_spec = lambda callable, args, kwargs: None
178	207
179	208
180
181	209	class LateParamPageHandler(PageHandler):
	210
182	211	"""When passing cherrypy.request.params to the page handler, we do not
183	212	want to capture that dict too early; we want to give tools like the
184	213	decoding tool a chance to modify the params dict in-between the lookup

186	215	takes that into account, and allows request.params to be 'bound late'
187	216	(it's more complicated than that, but that's the effect).
188	217	"""
189
	218
190	219	def _get_kwargs(self):
191	220	kwargs = cherrypy.serving.request.params.copy()
192	221	if self._kwargs:
193	222	kwargs.update(self._kwargs)
194	223	return kwargs
195
	224
196	225	def _set_kwargs(self, kwargs):
	226	cherrypy.serving.request.kwargs = kwargs
197	227	self._kwargs = kwargs
198
	228
199	229	kwargs = property(_get_kwargs, _set_kwargs,
200	230	doc='page handler kwargs (with '
201	231	'cherrypy.request.params copied in)')

204	234	if sys.version_info < (3, 0):
205	235	punctuation_to_underscores = string.maketrans(
206	236	string.punctuation, '_' * len(string.punctuation))
	237
207	238	def validate_translator(t):
208	239	if not isinstance(t, str) or len(t) != 256:
209		raise ValueError("The translate argument must be a str of len 256.")
	240	raise ValueError(
	241	"The translate argument must be a str of len 256.")
210	242	else:
211	243	punctuation_to_underscores = str.maketrans(
212	244	string.punctuation, '_' * len(string.punctuation))
	245
213	246	def validate_translator(t):
214	247	if not isinstance(t, dict):
215	248	raise ValueError("The translate argument must be a dict.")
216	249
	250
217	251	class Dispatcher(object):
	252
218	253	"""CherryPy Dispatcher which walks a tree of objects to find a handler.
219
	254
220	255	The tree is rooted at cherrypy.request.app.root, and each hierarchical
221	256	component in the path_info argument is matched to a corresponding nested
222	257	attribute of the root object. Matching handlers must have an 'exposed'

224	259	matches a URI which ends in a slash ("/"). The special method name
225	260	"default" may match a portion of the path_info (but only when no longer
226	261	substring of the path_info matches some other object).
227
	262
228	263	This is the default, built-in dispatcher for CherryPy.
229	264	"""
230
	265
231	266	dispatch_method_name = '_cp_dispatch'
232	267	"""
233	268	The name of the dispatch method that nodes may optionally implement
234	269	to provide their own dynamic dispatch algorithm.
235	270	"""
236
	271
237	272	def __init__(self, dispatch_method_name=None,
238	273	translate=punctuation_to_underscores):
239	274	validate_translator(translate)

245	280	"""Set handler and config for the current request."""
246	281	request = cherrypy.serving.request
247	282	func, vpath = self.find_handler(path_info)
248
	283
249	284	if func:
250	285	# Decode any leftover %2F in the virtual_path atoms.
251	286	vpath = [x.replace("%2F", "/") for x in vpath]
252	287	request.handler = LateParamPageHandler(func, *vpath)
253	288	else:
254	289	request.handler = cherrypy.NotFound()
255
	290
256	291	def find_handler(self, path):
257	292	"""Return the appropriate page handler, plus any virtual path.
258
	293
259	294	This will return two objects. The first will be a callable,
260	295	which can be used to generate page output. Any parameters from
261	296	the query string or request body will be sent to that callable
262	297	as keyword arguments.
263
	298
264	299	The callable is found by traversing the application's tree,
265	300	starting from cherrypy.request.app.root, and matching path
266	301	components to successive objects in the tree. For example, the
267	302	URL "/path/to/handler" might return root.path.to.handler.
268
	303
269	304	The second object returned will be a list of names which are
270	305	'virtual path' components: parts of the URL which are dynamic,
271	306	and were not used when looking up the handler.

276	311	app = request.app
277	312	root = app.root
278	313	dispatch_name = self.dispatch_method_name
279
	314
280	315	# Get config for the root object/path.
281	316	fullpath = [x for x in path.strip('/').split('/') if x] + ['index']
282	317	fullpath_len = len(fullpath)

287	322	if "/" in app.config:
288	323	nodeconf.update(app.config["/"])
289	324	object_trail = [['root', root, nodeconf, segleft]]
290
	325
291	326	node = root
292	327	iternames = fullpath[:]
293	328	while iternames:
294	329	name = iternames[0]
295	330	# map to legal Python identifiers (e.g. replace '.' with '_')
296	331	objname = name.translate(self.translate)
297
	332
298	333	nodeconf = {}
299	334	subnode = getattr(node, objname, None)
300	335	pre_len = len(iternames)

303	338	if dispatch and hasattr(dispatch, '__call__') and not \
304	339	getattr(dispatch, 'exposed', False) and \
305	340	pre_len > 1:
306		#Don't expose the hidden 'index' token to _cp_dispatch
307		#We skip this if pre_len == 1 since it makes no sense
308		#to call a dispatcher when we have no tokens left.
	341	# Don't expose the hidden 'index' token to _cp_dispatch
	342	# We skip this if pre_len == 1 since it makes no sense
	343	# to call a dispatcher when we have no tokens left.
309	344	index_name = iternames.pop()
310	345	subnode = dispatch(vpath=iternames)
311	346	iternames.append(index_name)
312	347	else:
313		#We didn't find a path, but keep processing in case there
314		#is a default() handler.
	348	# We didn't find a path, but keep processing in case there
	349	# is a default() handler.
315	350	iternames.pop(0)
316	351	else:
317		#We found the path, remove the vpath entry
	352	# We found the path, remove the vpath entry
318	353	iternames.pop(0)
319	354	segleft = len(iternames)
320	355	if segleft > pre_len:
321		#No path segment was removed. Raise an error.
	356	# No path segment was removed. Raise an error.
322	357	raise cherrypy.CherryPyException(
323	358	"A vpath segment was added. Custom dispatchers may only "
324	359	+ "remove elements. While trying to process "
325	360	+ "{0} in {1}".format(name, fullpath)
326		)
	361	)
327	362	elif segleft == pre_len:
328		#Assume that the handler used the current path segment, but
329		#did not pop it. This allows things like
330		#return getattr(self, vpath[0], None)
	363	# Assume that the handler used the current path segment, but
	364	# did not pop it. This allows things like
	365	# return getattr(self, vpath[0], None)
331	366	iternames.pop(0)
332	367	segleft -= 1
333	368	node = subnode

336	371	# Get _cp_config attached to this node.
337	372	if hasattr(node, "_cp_config"):
338	373	nodeconf.update(node._cp_config)
339
	374
340	375	# Mix in values from app.config for this path.
341	376	existing_len = fullpath_len - pre_len
342	377	if existing_len != 0:

348	383	curpath += '/' + seg
349	384	if curpath in app.config:
350	385	nodeconf.update(app.config[curpath])
351
	386
352	387	object_trail.append([name, node, nodeconf, segleft])
353
	388
354	389	def set_conf():
355		"""Collapse all object_trail config into cherrypy.request.config."""
	390	"""Collapse all object_trail config into cherrypy.request.config.
	391	"""
356	392	base = cherrypy.config.copy()
357	393	# Note that we merge the config from each node
358	394	# even if that node was None.
359	395	for name, obj, conf, segleft in object_trail:
360	396	base.update(conf)
361	397	if 'tools.staticdir.dir' in conf:
362		base['tools.staticdir.section'] = '/' + '/'.join(fullpath[0:fullpath_len - segleft])
	398	base['tools.staticdir.section'] = '/' + \
	399	'/'.join(fullpath[0:fullpath_len - segleft])
363	400	return base
364
	401
365	402	# Try successive objects (reverse order)
366	403	num_candidates = len(object_trail) - 1
367	404	for i in range(num_candidates, -1, -1):
368
	405
369	406	name, candidate, nodeconf, segleft = object_trail[i]
370	407	if candidate is None:
371	408	continue
372
	409
373	410	# Try a "default" method on the current leaf.
374	411	if hasattr(candidate, "default"):
375	412	defhandler = candidate.default
376	413	if getattr(defhandler, 'exposed', False):
377	414	# Insert any extra _cp_config from the default handler.
378	415	conf = getattr(defhandler, "_cp_config", {})
379		object_trail.insert(i+1, ["default", defhandler, conf, segleft])
	416	object_trail.insert(
	417	i + 1, ["default", defhandler, conf, segleft])
380	418	request.config = set_conf()
381		# See http://www.cherrypy.org/ticket/613
	419	# See https://bitbucket.org/cherrypy/cherrypy/issue/613
382	420	request.is_index = path.endswith("/")
383	421	return defhandler, fullpath[fullpath_len - segleft:-1]
384
385		# Uncomment the next line to restrict positional params to "default".
	422
	423	# Uncomment the next line to restrict positional params to
	424	# "default".
386	425	# if i < num_candidates - 2: continue
387
	426
388	427	# Try the current leaf.
389	428	if getattr(candidate, 'exposed', False):
390	429	request.config = set_conf()

399	438	# positional parameters (virtual paths).
400	439	request.is_index = False
401	440	return candidate, fullpath[fullpath_len - segleft:-1]
402
	441
403	442	# We didn't find anything
404	443	request.config = set_conf()
405	444	return None, []
406	445
407	446
408	447	class MethodDispatcher(Dispatcher):
	448
409	449	"""Additional dispatch based on cherrypy.request.method.upper().
410
	450
411	451	Methods named GET, POST, etc will be called on an exposed class.
412	452	The method names must be all caps; the appropriate Allow header
413	453	will be output showing all capitalized method names as allowable
414	454	HTTP verbs.
415
	455
416	456	Note that the containing class must be exposed, not the methods.
417	457	"""
418
	458
419	459	def __call__(self, path_info):
420	460	"""Set handler and config for the current request."""
421	461	request = cherrypy.serving.request
422	462	resource, vpath = self.find_handler(path_info)
423
	463
424	464	if resource:
425	465	# Set Allow header
426	466	avail = [m for m in dir(resource) if m.isupper()]

428	468	avail.append("HEAD")
429	469	avail.sort()
430	470	cherrypy.serving.response.headers['Allow'] = ", ".join(avail)
431
	471
432	472	# Find the subhandler
433	473	meth = request.method.upper()
434	474	func = getattr(resource, meth, None)

438	478	# Grab any _cp_config on the subhandler.
439	479	if hasattr(func, "_cp_config"):
440	480	request.config.update(func._cp_config)
441
	481
442	482	# Decode any leftover %2F in the virtual_path atoms.
443	483	vpath = [x.replace("%2F", "/") for x in vpath]
444	484	request.handler = LateParamPageHandler(func, *vpath)

449	489
450	490
451	491	class RoutesDispatcher(object):
	492
452	493	"""A Routes based dispatcher for CherryPy."""
453
454		def __init__(self, full_result=False):
	494
	495	def __init__(self, full_result=False, **mapper_options):
455	496	"""
456	497	Routes dispatcher
457	498

462	503	import routes
463	504	self.full_result = full_result
464	505	self.controllers = {}
465		self.mapper = routes.Mapper()
	506	self.mapper = routes.Mapper(**mapper_options)
466	507	self.mapper.controller_scan = self.controllers.keys
467
	508
468	509	def connect(self, name, route, controller, **kwargs):
469	510	self.controllers[name] = controller
470	511	self.mapper.connect(name, route, controller=name, **kwargs)
471
	512
472	513	def redirect(self, url):
473	514	raise cherrypy.HTTPRedirect(url)
474
	515
475	516	def __call__(self, path_info):
476	517	"""Set handler and config for the current request."""
477	518	func = self.find_handler(path_info)

479	520	cherrypy.serving.request.handler = LateParamPageHandler(func)
480	521	else:
481	522	cherrypy.serving.request.handler = cherrypy.NotFound()
482
	523
483	524	def find_handler(self, path_info):
484	525	"""Find the right page handler, and set request.config."""
485	526	import routes
486
	527
487	528	request = cherrypy.serving.request
488
	529
489	530	config = routes.request_config()
490	531	config.mapper = self.mapper
491	532	if hasattr(request, 'wsgi_environ'):

493	534	config.host = request.headers.get('Host', None)
494	535	config.protocol = request.scheme
495	536	config.redirect = self.redirect
496
	537
497	538	result = self.mapper.match(path_info)
498
	539
499	540	config.mapper_dict = result
500	541	params = {}
501	542	if result:

504	545	params.pop('controller', None)
505	546	params.pop('action', None)
506	547	request.params.update(params)
507
	548
508	549	# Get config for the root object/path.
509	550	request.config = base = cherrypy.config.copy()
510	551	curpath = ""
511
	552
512	553	def merge(nodeconf):
513	554	if 'tools.staticdir.dir' in nodeconf:
514	555	nodeconf['tools.staticdir.section'] = curpath or "/"
515	556	base.update(nodeconf)
516
	557
517	558	app = request.app
518	559	root = app.root
519	560	if hasattr(root, "_cp_config"):
520	561	merge(root._cp_config)
521	562	if "/" in app.config:
522	563	merge(app.config["/"])
523
	564
524	565	# Mix in values from app.config.
525	566	atoms = [x for x in path_info.split("/") if x]
526	567	if atoms:

531	572	curpath = "/".join((curpath, atom))
532	573	if curpath in app.config:
533	574	merge(app.config[curpath])
534
	575
535	576	handler = None
536	577	if result:
537	578	controller = result.get('controller')

542	583	# Get config from the controller.
543	584	if hasattr(controller, "_cp_config"):
544	585	merge(controller._cp_config)
545
	586
546	587	action = result.get('action')
547	588	if action is not None:
548	589	handler = getattr(controller, action, None)
549		# Get config from the handler
550		if hasattr(handler, "_cp_config"):
	590	# Get config from the handler
	591	if hasattr(handler, "_cp_config"):
551	592	merge(handler._cp_config)
552	593	else:
553	594	handler = controller
554
	595
555	596	# Do the last path atom here so it can
556	597	# override the controller's _cp_config.
557	598	if last:
558	599	curpath = "/".join((curpath, last))
559	600	if curpath in app.config:
560	601	merge(app.config[curpath])
561
	602
562	603	return handler
563	604
564	605
565	606	def XMLRPCDispatcher(next_dispatcher=Dispatcher()):
566	607	from cherrypy.lib import xmlrpcutil
	608
567	609	def xmlrpc_dispatch(path_info):
568	610	path_info = xmlrpcutil.patched_path(path_info)
569	611	return next_dispatcher(path_info)
570	612	return xmlrpc_dispatch
571	613
572	614
573		def VirtualHost(next_dispatcher=Dispatcher(), use_x_forwarded_host=True, **domains):
	615	def VirtualHost(next_dispatcher=Dispatcher(), use_x_forwarded_host=True,
	616	**domains):
574	617	"""
575	618	Select a different handler based on the Host header.
576
	619
577	620	This can be useful when running multiple sites within one CP server.
578	621	It allows several domains to point to different parts of a single
579	622	website structure. For example::
580
	623
581	624	http://www.domain.example -> root
582	625	http://www.domain2.example -> root/domain2/
583	626	http://www.domain2.example:443 -> root/secure
584
	627
585	628	can be accomplished via the following config::
586
	629
587	630	[/]
588	631	request.dispatch = cherrypy.dispatch.VirtualHost(
589	632	**{'www.domain2.example': '/domain2',
590	633	'www.domain2.example:443': '/secure',
591	634	})
592
	635
593	636	next_dispatcher
594	637	The next dispatcher object in the dispatch chain.
595	638	The VirtualHost dispatcher adds a prefix to the URL and calls
596	639	another dispatcher. Defaults to cherrypy.dispatch.Dispatcher().
597
	640
598	641	use_x_forwarded_host
599	642	If True (the default), any "X-Forwarded-Host"
600	643	request header will be used instead of the "Host" header. This
601	644	is commonly added by HTTP servers (such as Apache) when proxying.
602
	645
603	646	``**domains``
604	647	A dict of {host header value: virtual prefix} pairs.
605	648	The incoming "Host" request header is looked up in this dict,

610	653	headers may contain the port number.
611	654	"""
612	655	from cherrypy.lib import httputil
	656
613	657	def vhost_dispatch(path_info):
614	658	request = cherrypy.serving.request
615	659	header = request.headers.get
616
	660
617	661	domain = header('Host', '')
618	662	if use_x_forwarded_host:
619	663	domain = header("X-Forwarded-Host", domain)
620
	664
621	665	prefix = domains.get(domain, "")
622	666	if prefix:
623	667	path_info = httputil.urljoin(prefix, path_info)
624
	668
625	669	result = next_dispatcher(path_info)
626
627		# Touch up staticdir config. See http://www.cherrypy.org/ticket/614.
	670
	671	# Touch up staticdir config. See
	672	# https://bitbucket.org/cherrypy/cherrypy/issue/614.
628	673	section = request.config.get('tools.staticdir.section')
629	674	if section:
630	675	section = section[len(prefix):]
631	676	request.config['tools.staticdir.section'] = section
632
	677
633	678	return result
634	679	return vhost_dispatch
635

+157

-104

cherrypy/_cperror.py less more

1	1
2	2	CherryPy provides (and uses) exceptions for declaring that the HTTP response
3	3	should be a status other than the default "200 OK". You can ``raise`` them like
4		normal Python exceptions. You can also call them and they will raise themselves;
5		this means you can set an :class:`HTTPError<cherrypy._cperror.HTTPError>`
	4	normal Python exceptions. You can also call them and they will raise
	5	themselves; this means you can set an
	6	:class:`HTTPError<cherrypy._cperror.HTTPError>`
6	7	or :class:`HTTPRedirect<cherrypy._cperror.HTTPRedirect>` as the
7	8	:attr:`request.handler<cherrypy._cprequest.Request.handler>`.
8	9

20	21	charge a credit card, you don't want to be charged twice by a redirect!
21	22
22	23	For this reason, none of the 3xx responses permit a user-agent (browser) to
23		resubmit a POST on redirection without first confirming the action with the user:
	24	resubmit a POST on redirection without first confirming the action with the
	25	user:
24	26
25	27	===== ================================= ===========
26	28	300 Multiple Choices Confirm with the user

52	54	--------------------------
53	55
54	56	The 'error_page' config namespace can be used to provide custom HTML output for
55		expected responses (like 404 Not Found). Supply a filename from which the output
56		will be read. The contents will be interpolated with the values %(status)s,
57		%(message)s, %(traceback)s, and %(version)s using plain old Python
58		`string formatting <http://www.python.org/doc/2.6.4/library/stdtypes.html#string-formatting-operations>`_.
	57	expected responses (like 404 Not Found). Supply a filename from which the
	58	output will be read. The contents will be interpolated with the values
	59	%(status)s, %(message)s, %(traceback)s, and %(version)s using plain old Python
	60	`string formatting <http://docs.python.org/2/library/stdtypes.html#string-formatting-operations>`_.
59	61
60	62	::
61	63
62		_cp_config = {'error_page.404': os.path.join(localDir, "static/index.html")}
	64	_cp_config = {
	65	'error_page.404': os.path.join(localDir, "static/index.html")
	66	}
63	67
64	68
65	69	Beginning in version 3.1, you may also provide a function or other callable as

71	75	cherrypy.config.update({'error_page.402': error_page_402})
72	76
73	77	Also in 3.1, in addition to the numbered error codes, you may also supply
74		"error_page.default" to handle all codes which do not have their own error_page entry.
	78	"error_page.default" to handle all codes which do not have their own error_page
	79	entry.
75	80
76	81
77	82

80	85
81	86	CherryPy also has a generic error handling mechanism: whenever an unanticipated
82	87	error occurs in your code, it will call
83		:func:`Request.error_response<cherrypy._cprequest.Request.error_response>` to set
84		the response status, headers, and body. By default, this is the same output as
	88	:func:`Request.error_response<cherrypy._cprequest.Request.error_response>` to
	89	set the response status, headers, and body. By default, this is the same
	90	output as
85	91	:class:`HTTPError(500) <cherrypy._cperror.HTTPError>`. If you want to provide
86	92	some other behavior, you generally replace "request.error_response".
87	93

92	98
93	99	def handle_error():
94	100	cherrypy.response.status = 500
95		cherrypy.response.body = ["<html><body>Sorry, an error occured</body></html>"]
96		sendMail('error@domain.com', 'Error in your web app', _cperror.format_exc())
	101	cherrypy.response.body = [
	102	"<html><body>Sorry, an error occured</body></html>"
	103	]
	104	sendMail('error@domain.com',
	105	'Error in your web app',
	106	_cperror.format_exc())
97	107
98	108	class Root:
99	109	_cp_config = {'request.error_response': handle_error}
100	110
101	111
102		Note that you have to explicitly set :attr:`response.body <cherrypy._cprequest.Response.body>`
	112	Note that you have to explicitly set
	113	:attr:`response.body <cherrypy._cprequest.Response.body>`
103	114	and not simply return an error message as a result.
104	115	"""
105	116
106	117	from cgi import escape as _escape
107	118	from sys import exc_info as _exc_info
108	119	from traceback import format_exception as _format_exception
109		from cherrypy._cpcompat import basestring, bytestr, iteritems, ntob, tonative, urljoin as _urljoin
	120	from cherrypy._cpcompat import basestring, bytestr, iteritems, ntob
	121	from cherrypy._cpcompat import tonative, urljoin as _urljoin
110	122	from cherrypy.lib import httputil as _httputil
111	123
112	124
113	125	class CherryPyException(Exception):
	126
114	127	"""A base class for CherryPy exceptions."""
115	128	pass
116	129
117	130
118	131	class TimeoutError(CherryPyException):
	132
119	133	"""Exception raised when Response.timed_out is detected."""
120	134	pass
121	135
122	136
123	137	class InternalRedirect(CherryPyException):
	138
124	139	"""Exception raised to switch to the handler for a different URL.
125
	140
126	141	This exception will redirect processing to another path within the site
127	142	(without informing the client). Provide the new path as an argument when
128		raising the exception. Provide any params in the querystring for the new URL.
	143	raising the exception. Provide any params in the querystring for the new
	144	URL.
129	145	"""
130
	146
131	147	def __init__(self, path, query_string=""):
132	148	import cherrypy
133	149	self.request = cherrypy.serving.request
134
	150
135	151	self.query_string = query_string
136	152	if "?" in path:
137	153	# Separate any params included in the path
138	154	path, self.query_string = path.split("?", 1)
139
	155
140	156	# Note that urljoin will "do the right thing" whether url is:
141	157	# 1. a URL relative to root (e.g. "/dummy")
142	158	# 2. a URL relative to the current path
143	159	# Note that any query string will be discarded.
144	160	path = _urljoin(self.request.path_info, path)
145
	161
146	162	# Set a 'path' member attribute so that code which traps this
147	163	# error can have access to it.
148	164	self.path = path
149
	165
150	166	CherryPyException.__init__(self, path, self.query_string)
151	167
152	168
153	169	class HTTPRedirect(CherryPyException):
	170
154	171	"""Exception raised when the request should be redirected.
155
	172
156	173	This exception will force a HTTP redirect to the URL or URL's you give it.
157	174	The new URL must be passed as the first argument to the Exception,
158	175	e.g., HTTPRedirect(newUrl). Multiple URLs are allowed in a list.

161	178
162	179	If one of the provided URL is a unicode object, it will be encoded
163	180	using the default encoding or the one passed in parameter.
164
	181
165	182	There are multiple types of redirect, from which you can select via the
166	183	``status`` argument. If you do not provide a ``status`` arg, it defaults to
167	184	303 (or 302 if responding with HTTP/1.0).
168
	185
169	186	Examples::
170
	187
171	188	raise cherrypy.HTTPRedirect("")
172	189	raise cherrypy.HTTPRedirect("/abs/path", 307)
173	190	raise cherrypy.HTTPRedirect(["path1", "path2?a=1&b=2"], 301)
174
	191
175	192	See :ref:`redirectingpost` for additional caveats.
176	193	"""
177
	194
178	195	status = None
179	196	"""The integer HTTP status code to emit."""
180
	197
181	198	urls = None
182	199	"""The list of URL's to emit."""
183	200
184	201	encoding = 'utf-8'
185	202	"""The encoding when passed urls are not native strings"""
186
	203
187	204	def __init__(self, urls, status=None, encoding=None):
188	205	import cherrypy
189	206	request = cherrypy.serving.request
190
	207
191	208	if isinstance(urls, basestring):
192	209	urls = [urls]
193
	210
194	211	abs_urls = []
195	212	for url in urls:
196	213	url = tonative(url, encoding or self.encoding)
197
	214
198	215	# Note that urljoin will "do the right thing" whether url is:
199	216	# 1. a complete URL with host (e.g. "http://www.example.com/test")
200	217	# 2. a URL relative to root (e.g. "/dummy")

203	220	url = _urljoin(cherrypy.url(), url)
204	221	abs_urls.append(url)
205	222	self.urls = abs_urls
206
	223
207	224	# RFC 2616 indicates a 301 response code fits our goal; however,
208	225	# browser support for 301 is quite messy. Do 302/303 instead. See
209	226	# http://www.alanflavell.org.uk/www/post-redirect.html

216	233	status = int(status)
217	234	if status < 300 or status > 399:
218	235	raise ValueError("status must be between 300 and 399.")
219
	236
220	237	self.status = status
221	238	CherryPyException.__init__(self, abs_urls, status)
222
	239
223	240	def set_response(self):
224		"""Modify cherrypy.response status, headers, and body to represent self.
225
	241	"""Modify cherrypy.response status, headers, and body to represent
	242	self.
	243
226	244	CherryPy uses this internally, but you can also use it to create an
227	245	HTTPRedirect object and set its output without raising the exception.
228	246	"""
229	247	import cherrypy
230	248	response = cherrypy.serving.response
231	249	response.status = status = self.status
232
	250
233	251	if status in (300, 301, 302, 303, 307):
234	252	response.headers['Content-Type'] = "text/html;charset=utf-8"
235	253	# "The ... URI SHOULD be given by the Location field
236	254	# in the response."
237	255	response.headers['Location'] = self.urls[0]
238
	256
239	257	# "Unless the request method was HEAD, the entity of the response
240	258	# SHOULD contain a short hypertext note with a hyperlink to the
241	259	# new URI(s)."
242		msg = {300: "This resource can be found at <a href='%s'>%s</a>.",
243		301: "This resource has permanently moved to <a href='%s'>%s</a>.",
244		302: "This resource resides temporarily at <a href='%s'>%s</a>.",
245		303: "This resource can be found at <a href='%s'>%s</a>.",
246		307: "This resource has moved temporarily to <a href='%s'>%s</a>.",
247		}[status]
248		msgs = [msg % (u, u) for u in self.urls]
	260	msg = {
	261	300: "This resource can be found at ",
	262	301: "This resource has permanently moved to ",
	263	302: "This resource resides temporarily at ",
	264	303: "This resource can be found at ",
	265	307: "This resource has moved temporarily to ",
	266	}[status]
	267	msg += '<a href=%s>%s</a>.'
	268	from xml.sax import saxutils
	269	msgs = [msg % (saxutils.quoteattr(u), u) for u in self.urls]
249	270	response.body = ntob("<br />\n".join(msgs), 'utf-8')
250	271	# Previous code may have set C-L, so we have to reset it
251	272	# (allow finalize to set it).

255	276	# "The response MUST include the following header fields:
256	277	# Date, unless its omission is required by section 14.18.1"
257	278	# The "Date" header should have been set in Response.__init__
258
	279
259	280	# "...the response SHOULD NOT include other entity-headers."
260	281	for key in ('Allow', 'Content-Encoding', 'Content-Language',
261	282	'Content-Length', 'Content-Location', 'Content-MD5',

263	284	'Last-Modified'):
264	285	if key in response.headers:
265	286	del response.headers[key]
266
	287
267	288	# "The 304 response MUST NOT contain a message-body."
268	289	response.body = None
269	290	# Previous code may have set C-L, so we have to reset it.

277	298	response.headers.pop('Content-Length', None)
278	299	else:
279	300	raise ValueError("The %s status code is unknown." % status)
280
	301
281	302	def __call__(self):
282	303	"""Use this exception as a request.handler (raise self)."""
283	304	raise self

286	307	def clean_headers(status):
287	308	"""Remove any headers which should not apply to an error response."""
288	309	import cherrypy
289
	310
290	311	response = cherrypy.serving.response
291
	312
292	313	# Remove headers which applied to the original content,
293	314	# but do not apply to the error page.
294	315	respheaders = response.headers

297	318	"Content-Location", "Content-MD5", "Last-Modified"]:
298	319	if key in respheaders:
299	320	del respheaders[key]
300
	321
301	322	if status != 416:
302	323	# A server sending a response with status code 416 (Requested
303	324	# range not satisfiable) SHOULD include a Content-Range field

310	331
311	332
312	333	class HTTPError(CherryPyException):
	334
313	335	"""Exception used to return an HTTP error code (4xx-5xx) to the client.
314
315		This exception can be used to automatically send a response using a http status
316		code, with an appropriate error page. It takes an optional
	336
	337	This exception can be used to automatically send a response using a
	338	http status code, with an appropriate error page. It takes an optional
317	339	``status`` argument (which must be between 400 and 599); it defaults to 500
318	340	("Internal Server Error"). It also takes an optional ``message`` argument,
319	341	which will be returned in the response body. See
320		`RFC 2616 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4>`_
	342	`RFC2616 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4>`_
321	343	for a complete list of available error codes and when to use them.
322
	344
323	345	Examples::
324
	346
325	347	raise cherrypy.HTTPError(403)
326		raise cherrypy.HTTPError("403 Forbidden", "You are not allowed to access this resource.")
	348	raise cherrypy.HTTPError(
	349	"403 Forbidden", "You are not allowed to access this resource.")
327	350	"""
328
	351
329	352	status = None
330		"""The HTTP status code. May be of type int or str (with a Reason-Phrase)."""
331
	353	"""The HTTP status code. May be of type int or str (with a Reason-Phrase).
	354	"""
	355
332	356	code = None
333	357	"""The integer HTTP status code."""
334
	358
335	359	reason = None
336	360	"""The HTTP Reason-Phrase string."""
337
	361
338	362	def __init__(self, status=500, message=None):
339	363	self.status = status
340	364	try:
341	365	self.code, self.reason, defaultmsg = _httputil.valid_status(status)
342	366	except ValueError:
343	367	raise self.__class__(500, _exc_info()[1].args[0])
344
	368
345	369	if self.code < 400 or self.code > 599:
346	370	raise ValueError("status must be between 400 and 599.")
347
	371
348	372	# See http://www.python.org/dev/peps/pep-0352/
349	373	# self.message = message
350	374	self._message = message or defaultmsg
351	375	CherryPyException.__init__(self, status, message)
352
	376
353	377	def set_response(self):
354		"""Modify cherrypy.response status, headers, and body to represent self.
355
	378	"""Modify cherrypy.response status, headers, and body to represent
	379	self.
	380
356	381	CherryPy uses this internally, but you can also use it to create an
357	382	HTTPError object and set its output without raising the exception.
358	383	"""
359	384	import cherrypy
360
	385
361	386	response = cherrypy.serving.response
362
	387
363	388	clean_headers(self.code)
364
	389
365	390	# In all cases, finalize will be called after this method,
366	391	# so don't bother cleaning up response values here.
367	392	response.status = self.status
368	393	tb = None
369	394	if cherrypy.serving.request.show_tracebacks:
370	395	tb = format_exc()
371		response.headers['Content-Type'] = "text/html;charset=utf-8"
	396
372	397	response.headers.pop('Content-Length', None)
373
374		content = ntob(self.get_error_page(self.status, traceback=tb,
375		message=self._message), 'utf-8')
	398
	399	content = self.get_error_page(self.status, traceback=tb,
	400	message=self._message)
376	401	response.body = content
377
	402
378	403	_be_ie_unfriendly(self.code)
379
	404
380	405	def get_error_page(self, args, *kwargs):
381	406	return get_error_page(args, *kwargs)
382
	407
383	408	def __call__(self):
384	409	"""Use this exception as a request.handler (raise self)."""
385	410	raise self
386	411
387	412
388	413	class NotFound(HTTPError):
	414
389	415	"""Exception raised when a URL could not be mapped to any handler (404).
390
	416
391	417	This is equivalent to raising
392	418	:class:`HTTPError("404 Not Found") <cherrypy._cperror.HTTPError>`.
393	419	"""
394
	420
395	421	def __init__(self, path=None):
396	422	if path is None:
397	423	import cherrypy

401	427	HTTPError.__init__(self, 404, "The path '%s' was not found." % path)
402	428
403	429
404		_HTTPErrorTemplate = '''<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
	430	_HTTPErrorTemplate = '''<!DOCTYPE html PUBLIC
	431	"-//W3C//DTD XHTML 1.0 Transitional//EN"
405	432	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
406	433	<html>
407	434	<head>

424	451	<p>%(message)s</p>
425	452	<pre id="traceback">%(traceback)s</pre>
426	453	<div id="powered_by">
427		<span>Powered by <a href="http://www.cherrypy.org">CherryPy %(version)s</a></span>
	454	<span>
	455	Powered by <a href="http://www.cherrypy.org">CherryPy %(version)s</a>
	456	</span>
428	457	</div>
429	458	</body>
430	459	</html>
431	460	'''
432	461
	462
433	463	def get_error_page(status, **kwargs):
434	464	"""Return an HTML page, containing a pretty error response.
435
	465
436	466	status should be an int or a str.
437	467	kwargs will be interpolated into the page template.
438	468	"""
439	469	import cherrypy
440
	470
441	471	try:
442	472	code, reason, message = _httputil.valid_status(status)
443	473	except ValueError:
444	474	raise cherrypy.HTTPError(500, _exc_info()[1].args[0])
445
	475
446	476	# We can't use setdefault here, because some
447	477	# callers send None for kwarg values.
448	478	if kwargs.get('status') is None:

453	483	kwargs['traceback'] = ''
454	484	if kwargs.get('version') is None:
455	485	kwargs['version'] = cherrypy.__version__
456
	486
457	487	for k, v in iteritems(kwargs):
458	488	if v is None:
459	489	kwargs[k] = ""
460	490	else:
461	491	kwargs[k] = _escape(kwargs[k])
462
	492
463	493	# Use a custom template or callable for the error page?
464	494	pages = cherrypy.serving.request.error_page
465	495	error_page = pages.get(code) or pages.get('default')
	496
	497	# Default template, can be overridden below.
	498	template = _HTTPErrorTemplate
466	499	if error_page:
467	500	try:
468	501	if hasattr(error_page, '__call__'):
469		return error_page(**kwargs)
	502	# The caller function may be setting headers manually,
	503	# so we delegate to it completely. We may be returning
	504	# an iterator as well as a string here.
	505	#
	506	# We must make sure any content is not unicode.
	507	result = error_page(**kwargs)
	508	if cherrypy.lib.is_iterator(result):
	509	from cherrypy.lib.encoding import UTF8StreamEncoder
	510	return UTF8StreamEncoder(result)
	511	elif isinstance(result, cherrypy._cpcompat.unicodestr):
	512	return result.encode('utf-8')
	513	else:
	514	if not isinstance(result, cherrypy._cpcompat.bytestr):
	515	raise ValueError('error page function did not '
	516	'return a bytestring, unicodestring or an '
	517	'iterator - returned object of type %s.'
	518	% (type(result).__name__))
	519	return result
470	520	else:
471		data = open(error_page, 'rb').read()
472		return tonative(data) % kwargs
	521	# Load the template from this path.
	522	template = tonative(open(error_page, 'rb').read())
473	523	except:
474	524	e = _format_exception(*_exc_info())[-1]
475	525	m = kwargs['message']

477	527	m += "<br />"
478	528	m += "In addition, the custom error page failed:\n<br />%s" % e
479	529	kwargs['message'] = m
480
481		return _HTTPErrorTemplate % kwargs
	530
	531	response = cherrypy.serving.response
	532	response.headers['Content-Type'] = "text/html;charset=utf-8"
	533	result = template % kwargs
	534	return result.encode('utf-8')
	535
482	536
483	537
484	538	_ie_friendly_error_sizes = {
485	539	400: 512, 403: 256, 404: 512, 405: 256,
486	540	406: 512, 408: 512, 409: 512, 410: 256,
487	541	500: 512, 501: 512, 505: 512,
488		}
	542	}
489	543
490	544
491	545	def _be_ie_unfriendly(status):
492	546	import cherrypy
493	547	response = cherrypy.serving.response
494
	548
495	549	# For some statuses, Internet Explorer 5+ shows "friendly error
496	550	# messages" instead of our response.body if the body is smaller
497	551	# than a given size. Fix this by returning a body over that size

524	578	finally:
525	579	del exc
526	580
	581
527	582	def bare_error(extrabody=None):
528	583	"""Produce status, headers, body for a critical error.
529
	584
530	585	Returns a triple without calling any other questionable functions,
531	586	so it should be as error-free as possible. Call it from an HTTP server
532	587	if you get errors outside of the request.
533
	588
534	589	If extrabody is None, a friendly but rather unhelpful error message
535	590	is set in the body. If extrabody is a string, it will be appended
536	591	as-is to the body.
537	592	"""
538
	593
539	594	# The whole point of this function is to be a last line-of-defense
540	595	# in handling errors. That is, it must not raise any errors itself;
541	596	# it cannot be allowed to fail. Therefore, don't add to it!
542	597	# In particular, don't call any other CP functions.
543
	598
544	599	body = ntob("Unrecoverable error in the server.")
545	600	if extrabody is not None:
546	601	if not isinstance(extrabody, bytestr):
547	602	extrabody = extrabody.encode('utf-8')
548	603	body += ntob("\n") + extrabody
549
	604
550	605	return (ntob("500 Internal Server Error"),
551	606	[(ntob('Content-Type'), ntob('text/plain')),
552		(ntob('Content-Length'), ntob(str(len(body)),'ISO-8859-1'))],
	607	(ntob('Content-Length'), ntob(str(len(body)), 'ISO-8859-1'))],
553	608	[body])
554
555

+76

-65

cherrypy/_cplogging.py less more

33	33	manager is found at :func:`cherrypy.log`, and the log manager for each
34	34	application is found at :attr:`app.log<cherrypy._cptree.Application.log>`.
35	35	If you're inside a request, the latter is reachable from
36		``cherrypy.request.app.log``; if you're outside a request, you'll have to obtain
37		a reference to the ``app``: either the return value of
	36	``cherrypy.request.app.log``; if you're outside a request, you'll have to
	37	obtain a reference to the ``app``: either the return value of
38	38	:func:`tree.mount()<cherrypy._cptree.Tree.mount>` or, if you used
39		:func:`quickstart()<cherrypy.quickstart>` instead, via ``cherrypy.tree.apps['/']``.
	39	:func:`quickstart()<cherrypy.quickstart>` instead, via
	40	``cherrypy.tree.apps['/']``.
40	41
41	42	By default, the global logs are named "cherrypy.error" and "cherrypy.access",
42	43	and the application logs are named "cherrypy.error.2378745" and

68	69
69	70	#python
70	71	log = app.log
71
	72
72	73	# Remove the default FileHandlers if present.
73	74	log.error_file = ""
74	75	log.access_file = ""
75
	76
76	77	maxBytes = getattr(log, "rot_maxBytes", 10000000)
77	78	backupCount = getattr(log, "rot_backupCount", 1000)
78
	79
79	80	# Make a new RotatingFileHandler for the error log.
80	81	fname = getattr(log, "rot_error_file", "error.log")
81	82	h = handlers.RotatingFileHandler(fname, 'a', maxBytes, backupCount)
82	83	h.setLevel(DEBUG)
83	84	h.setFormatter(_cplogging.logfmt)
84	85	log.error_log.addHandler(h)
85
	86
86	87	# Make a new RotatingFileHandler for the access log.
87	88	fname = getattr(log, "rot_access_file", "access.log")
88	89	h = handlers.RotatingFileHandler(fname, 'a', maxBytes, backupCount)

112	113
113	114
114	115	class NullHandler(logging.Handler):
	116
115	117	"""A no-op logging handler to silence the logging.lastResort handler."""
116	118
117	119	def handle(self, record):

125	127
126	128
127	129	class LogManager(object):
	130
128	131	"""An object to assist both simple and advanced logging.
129
	132
130	133	``cherrypy.log`` is an instance of this class.
131	134	"""
132
	135
133	136	appid = None
134	137	"""The id() of the Application object which owns this log manager. If this
135	138	is a global log manager, appid is None."""
136
	139
137	140	error_log = None
138	141	"""The actual :class:`logging.Logger` instance for error messages."""
139
	142
140	143	access_log = None
141	144	"""The actual :class:`logging.Logger` instance for access messages."""
142
	145
143	146	if py3k:
144	147	access_log_format = \
145	148	'{h} {l} {u} {t} "{r}" {s} {b} "{f}" "{a}"'
146	149	else:
147	150	access_log_format = \
148	151	'%(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'
149
	152
150	153	logger_root = None
151	154	"""The "top-level" logger name.
152
	155
153	156	This string will be used as the first segment in the Logger names.
154	157	The default is "cherrypy", for example, in which case the Logger names
155	158	will be of the form::
156
	159
157	160	cherrypy.error.<appid>
158	161	cherrypy.access.<appid>
159	162	"""
160
	163
161	164	def __init__(self, appid=None, logger_root="cherrypy"):
162	165	self.logger_root = logger_root
163	166	self.appid = appid

165	168	self.error_log = logging.getLogger("%s.error" % logger_root)
166	169	self.access_log = logging.getLogger("%s.access" % logger_root)
167	170	else:
168		self.error_log = logging.getLogger("%s.error.%s" % (logger_root, appid))
169		self.access_log = logging.getLogger("%s.access.%s" % (logger_root, appid))
	171	self.error_log = logging.getLogger(
	172	"%s.error.%s" % (logger_root, appid))
	173	self.access_log = logging.getLogger(
	174	"%s.access.%s" % (logger_root, appid))
170	175	self.error_log.setLevel(logging.INFO)
171	176	self.access_log.setLevel(logging.INFO)
172	177

185	190	h.stream.close()
186	191	h.stream = open(h.baseFilename, h.mode)
187	192	h.release()
188
189		def error(self, msg='', context='', severity=logging.INFO, traceback=False):
	193
	194	def error(self, msg='', context='', severity=logging.INFO,
	195	traceback=False):
190	196	"""Write the given ``msg`` to the error log.
191
	197
192	198	This is not just for errors! Applications may call this at any time
193	199	to log application-specific information.
194
	200
195	201	If ``traceback`` is True, the traceback of the current exception
196	202	(if any) will be appended to ``msg``.
197	203	"""
198	204	if traceback:
199	205	msg += _cperror.format_exc()
200	206	self.error_log.log(severity, ' '.join((self.time(), context, msg)))
201
	207
202	208	def __call__(self, args, *kwargs):
203	209	"""An alias for ``error``."""
204	210	return self.error(args, *kwargs)
205
	211
206	212	def access(self):
207	213	"""Write to the access log (in Apache/NCSA Combined Log format).
208
209		See http://httpd.apache.org/docs/2.0/logs.html#combined for format
210		details.
211
	214
	215	See the
	216	`apache documentation <http://httpd.apache.org/docs/current/logs.html#combined>`_
	217	for format details.
	218
212	219	CherryPy calls this automatically for you. Note there are no arguments;
213	220	it collects the data itself from
214	221	:class:`cherrypy.request<cherrypy._cprequest.Request>`.
215
	222
216	223	Like Apache started doing in 2.0.46, non-printable and other special
217	224	characters in %r (and we expand that to all parts) are escaped using
218	225	\\xhh sequences, where hh stands for the hexadecimal representation

231	238	status = response.output_status.split(ntob(" "), 1)[0]
232	239	if py3k:
233	240	status = status.decode('ISO-8859-1')
234
	241
235	242	atoms = {'h': remote.name or remote.ip,
236	243	'l': '-',
237	244	'u': getattr(request, "login", None) or "-",

250	257	# Fortunately, repr(str) escapes unprintable chars, \n, \t, etc
251	258	# and backslash for us. All we have to do is strip the quotes.
252	259	v = repr(v)[2:-1]
253
254		# in python 3.0 the repr of bytes (as returned by encode)
	260
	261	# in python 3.0 the repr of bytes (as returned by encode)
255	262	# uses double \'s. But then the logger escapes them yet, again
256	263	# resulting in quadruple slashes. Remove the extra one here.
257	264	v = v.replace('\\\\', '\\')
258
	265
259	266	# Escape double-quote.
260	267	atoms[k] = v
261
	268
262	269	try:
263		self.access_log.log(logging.INFO, self.access_log_format.format(**atoms))
	270	self.access_log.log(
	271	logging.INFO, self.access_log_format.format(**atoms))
264	272	except:
265	273	self(traceback=True)
266	274	else:

274	282	v = repr(v)[1:-1]
275	283	# Escape double-quote.
276	284	atoms[k] = v.replace('"', '\\"')
277
	285
278	286	try:
279		self.access_log.log(logging.INFO, self.access_log_format % atoms)
	287	self.access_log.log(
	288	logging.INFO, self.access_log_format % atoms)
280	289	except:
281	290	self(traceback=True)
282
	291
283	292	def time(self):
284	293	"""Return now() in Apache Common Log Format (no timezone)."""
285	294	now = datetime.datetime.now()

288	297	month = monthnames[now.month - 1].capitalize()
289	298	return ('[%02d/%s/%04d:%02d:%02d:%02d]' %
290	299	(now.day, month, now.year, now.hour, now.minute, now.second))
291
	300
292	301	def _get_builtin_handler(self, log, key):
293	302	for h in log.handlers:
294	303	if getattr(h, "_cpbuiltin", None) == key:
295	304	return h
296
297
	305
298	306	# ------------------------- Screen handlers ------------------------- #
299
300	307	def _set_screen_handler(self, log, enable, stream=None):
301	308	h = self._get_builtin_handler(log, "screen")
302	309	if enable:
303	310	if not h:
304	311	if stream is None:
305		stream=sys.stderr
	312	stream = sys.stderr
306	313	h = logging.StreamHandler(stream)
307	314	h.setFormatter(logfmt)
308	315	h._cpbuiltin = "screen"
309	316	log.addHandler(h)
310	317	elif h:
311	318	log.handlers.remove(h)
312
	319
313	320	def _get_screen(self):
314	321	h = self._get_builtin_handler
315	322	has_h = h(self.error_log, "screen") or h(self.access_log, "screen")
316	323	return bool(has_h)
317
	324
318	325	def _set_screen(self, newvalue):
319	326	self._set_screen_handler(self.error_log, newvalue, stream=sys.stderr)
320	327	self._set_screen_handler(self.access_log, newvalue, stream=sys.stdout)
321	328	screen = property(_get_screen, _set_screen,
322		doc="""Turn stderr/stdout logging on or off.
323
	329	doc="""Turn stderr/stdout logging on or off.
	330
324	331	If you set this to True, it'll add the appropriate StreamHandler for
325	332	you. If you set it to False, it will remove the handler.
326	333	""")
327
	334
328	335	# -------------------------- File handlers -------------------------- #
329
	336
330	337	def _add_builtin_file_handler(self, log, fname):
331	338	h = logging.FileHandler(fname)
332	339	h.setFormatter(logfmt)
333	340	h._cpbuiltin = "file"
334	341	log.addHandler(h)
335
	342
336	343	def _set_file_handler(self, log, filename):
337	344	h = self._get_builtin_handler(log, "file")
338	345	if filename:

347	354	if h:
348	355	h.close()
349	356	log.handlers.remove(h)
350
	357
351	358	def _get_error_file(self):
352	359	h = self._get_builtin_handler(self.error_log, "file")
353	360	if h:
354	361	return h.baseFilename
355	362	return ''
	363
356	364	def _set_error_file(self, newvalue):
357	365	self._set_file_handler(self.error_log, newvalue)
358	366	error_file = property(_get_error_file, _set_error_file,
359		doc="""The filename for self.error_log.
360
	367	doc="""The filename for self.error_log.
	368
361	369	If you set this to a string, it'll add the appropriate FileHandler for
362	370	you. If you set it to ``None`` or ``''``, it will remove the handler.
363	371	""")
364
	372
365	373	def _get_access_file(self):
366	374	h = self._get_builtin_handler(self.access_log, "file")
367	375	if h:
368	376	return h.baseFilename
369	377	return ''
	378
370	379	def _set_access_file(self, newvalue):
371	380	self._set_file_handler(self.access_log, newvalue)
372	381	access_file = property(_get_access_file, _set_access_file,
373		doc="""The filename for self.access_log.
374
	382	doc="""The filename for self.access_log.
	383
375	384	If you set this to a string, it'll add the appropriate FileHandler for
376	385	you. If you set it to ``None`` or ``''``, it will remove the handler.
377	386	""")
378
	387
379	388	# ------------------------- WSGI handlers ------------------------- #
380
	389
381	390	def _set_wsgi_handler(self, log, enable):
382	391	h = self._get_builtin_handler(log, "wsgi")
383	392	if enable:

388	397	log.addHandler(h)
389	398	elif h:
390	399	log.handlers.remove(h)
391
	400
392	401	def _get_wsgi(self):
393	402	return bool(self._get_builtin_handler(self.error_log, "wsgi"))
394
	403
395	404	def _set_wsgi(self, newvalue):
396	405	self._set_wsgi_handler(self.error_log, newvalue)
397	406	wsgi = property(_get_wsgi, _set_wsgi,
398		doc="""Write errors to wsgi.errors.
399
	407	doc="""Write errors to wsgi.errors.
	408
400	409	If you set this to True, it'll add the appropriate
401	410	:class:`WSGIErrorHandler<cherrypy._cplogging.WSGIErrorHandler>` for you
402	411	(which writes errors to ``wsgi.errors``).

405	414
406	415
407	416	class WSGIErrorHandler(logging.Handler):
	417
408	418	"A handler class which writes logging records to environ['wsgi.errors']."
409
	419
410	420	def flush(self):
411	421	"""Flushes the stream."""
412	422	try:

415	425	pass
416	426	else:
417	427	stream.flush()
418
	428
419	429	def emit(self, record):
420	430	"""Emit a record."""
421	431	try:

427	437	msg = self.format(record)
428	438	fs = "%s\n"
429	439	import types
430		if not hasattr(types, "UnicodeType"): #if no unicode support...
	440	# if no unicode support...
	441	if not hasattr(types, "UnicodeType"):
431	442	stream.write(fs % msg)
432	443	else:
433	444	try:

+57

-48

cherrypy/_cpmodpy.py less more

34	34	LoadModule python_module /usr/lib/apache2/modules/mod_python.so
35	35
36	36	<Location "/">
37		PythonPath "sys.path+['/path/to/my/application']"
38		SetHandler python-program
39		PythonHandler cherrypy._cpmodpy::handler
40		PythonOption cherrypy.setup myapp::setup_server
41		PythonDebug On
42		</Location>
	37	PythonPath "sys.path+['/path/to/my/application']"
	38	SetHandler python-program
	39	PythonHandler cherrypy._cpmodpy::handler
	40	PythonOption cherrypy.setup myapp::setup_server
	41	PythonDebug On
	42	</Location>
43	43	# End
44	44
45	45	The actual path to your mod_python.so is dependent on your

66	66	# ------------------------------ Request-handling
67	67
68	68
69
70	69	def setup(req):
71	70	from mod_python import apache
72
73		# Run any setup functions defined by a "PythonOption cherrypy.setup" directive.
	71
	72	# Run any setup functions defined by a "PythonOption cherrypy.setup"
	73	# directive.
74	74	options = req.get_options()
75	75	if 'cherrypy.setup' in options:
76	76	for function in options['cherrypy.setup'].split():

82	82	mod = __import__(modname, globals(), locals(), [fname])
83	83	func = getattr(mod, fname)
84	84	func()
85
	85
86	86	cherrypy.config.update({'log.screen': False,
87	87	"tools.ignore_headers.on": True,
88	88	"tools.ignore_headers.headers": ['Range'],
89	89	})
90
	90
91	91	engine = cherrypy.engine
92	92	if hasattr(engine, "signal_handler"):
93	93	engine.signal_handler.unsubscribe()

95	95	engine.console_control_handler.unsubscribe()
96	96	engine.autoreload.unsubscribe()
97	97	cherrypy.server.unsubscribe()
98
	98
99	99	def _log(msg, level):
100	100	newlevel = apache.APLOG_ERR
101	101	if logging.DEBUG >= level:

105	105	elif logging.WARNING >= level:
106	106	newlevel = apache.APLOG_WARNING
107	107	# On Windows, req.server is required or the msg will vanish. See
108		# http://www.modpython.org/pipermail/mod_python/2003-October/014291.html.
	108	# http://www.modpython.org/pipermail/mod_python/2003-October/014291.html
109	109	# Also, "When server is not specified...LogLevel does not apply..."
110	110	apache.log_error(msg, newlevel, req.server)
111	111	engine.subscribe('log', _log)
112
	112
113	113	engine.start()
114
	114
115	115	def cherrypy_cleanup(data):
116	116	engine.exit()
117	117	try:

123	123
124	124	class _ReadOnlyRequest:
125	125	expose = ('read', 'readline', 'readlines')
	126
126	127	def __init__(self, req):
127	128	for method in self.expose:
128	129	self.__dict__[method] = getattr(req, method)

131	132	recursive = False
132	133
133	134	_isSetUp = False
	135
	136
134	137	def handler(req):
135	138	from mod_python import apache
136	139	try:

138	141	if not _isSetUp:
139	142	setup(req)
140	143	_isSetUp = True
141
	144
142	145	# Obtain a Request object from CherryPy
143	146	local = req.connection.local_addr
144		local = httputil.Host(local[0], local[1], req.connection.local_host or "")
	147	local = httputil.Host(
	148	local[0], local[1], req.connection.local_host or "")
145	149	remote = req.connection.remote_addr
146		remote = httputil.Host(remote[0], remote[1], req.connection.remote_host or "")
147
	150	remote = httputil.Host(
	151	remote[0], remote[1], req.connection.remote_host or "")
	152
148	153	scheme = req.parsed_uri[0] or 'http'
149	154	req.get_basic_auth_pw()
150
	155
151	156	try:
152	157	# apache.mpm_query only became available in mod_python 3.1
153	158	q = apache.mpm_query

157	162	bad_value = ("You must provide a PythonOption '%s', "
158	163	"either 'on' or 'off', when running a version "
159	164	"of mod_python < 3.1")
160
	165
161	166	threaded = options.get('multithread', '').lower()
162	167	if threaded == 'on':
163	168	threaded = True

165	170	threaded = False
166	171	else:
167	172	raise ValueError(bad_value % "multithread")
168
	173
169	174	forked = options.get('multiprocess', '').lower()
170	175	if forked == 'on':
171	176	forked = True

173	178	forked = False
174	179	else:
175	180	raise ValueError(bad_value % "multiprocess")
176
	181
177	182	sn = cherrypy.tree.script_name(req.uri or "/")
178	183	if sn is None:
179	184	send_response(req, '404 Not Found', [], '')

186	191	headers = copyitems(req.headers_in)
187	192	rfile = _ReadOnlyRequest(req)
188	193	prev = None
189
	194
190	195	try:
191	196	redirections = []
192	197	while True:

197	202	request.multiprocess = bool(forked)
198	203	request.app = app
199	204	request.prev = prev
200
	205
201	206	# Run the CherryPy Request object and obtain the response
202	207	try:
203	208	request.run(method, path, qs, reqproto, headers, rfile)

206	211	ir = sys.exc_info()[1]
207	212	app.release_serving()
208	213	prev = request
209
	214
210	215	if not recursive:
211	216	if ir.path in redirections:
212		raise RuntimeError("InternalRedirector visited the "
213		"same URL twice: %r" % ir.path)
	217	raise RuntimeError(
	218	"InternalRedirector visited the same URL "
	219	"twice: %r" % ir.path)
214	220	else:
215		# Add the previous path_info + qs to redirections.
	221	# Add the previous path_info + qs to
	222	# redirections.
216	223	if qs:
217	224	qs = "?" + qs
218	225	redirections.append(sn + path + qs)
219
	226
220	227	# Munge environment and try again.
221	228	method = "GET"
222	229	path = ir.path
223	230	qs = ir.query_string
224	231	rfile = BytesIO()
225
226		send_response(req, response.output_status, response.header_list,
227		response.body, response.stream)
	232
	233	send_response(
	234	req, response.output_status, response.header_list,
	235	response.body, response.stream)
228	236	finally:
229	237	app.release_serving()
230	238	except:

238	246	def send_response(req, status, headers, body, stream=False):
239	247	# Set response status
240	248	req.status = int(status[:3])
241
	249
242	250	# Set response headers
243	251	req.content_type = "text/plain"
244	252	for header, value in headers:

246	254	req.content_type = value
247	255	continue
248	256	req.headers_out.add(header, value)
249
	257
250	258	if stream:
251	259	# Flush now so the status and headers are sent immediately.
252	260	req.flush()
253
	261
254	262	# Set response body
255	263	if isinstance(body, basestring):
256	264	req.write(body)

259	267	req.write(seg)
260	268
261	269
262
263	270	# --------------- Startup tools for CherryPy + mod_python --------------- #
264
265
266	271	import os
267	272	import re
268	273	try:
269	274	import subprocess
	275
270	276	def popen(fullcmd):
271	277	p = subprocess.Popen(fullcmd, shell=True,
272	278	stdout=subprocess.PIPE, stderr=subprocess.STDOUT,

283	289	pipeout = popen(fullcmd)
284	290	try:
285	291	firstline = pipeout.readline()
286		if (re.search(ntob("(not recognized\|No such file\|not found)"), firstline,
287		re.IGNORECASE)):
	292	cmd_not_found = re.search(
	293	ntob("(not recognized\|No such file\|not found)"),
	294	firstline,
	295	re.IGNORECASE
	296	)
	297	if cmd_not_found:
288	298	raise IOError('%s must be on your system path.' % cmd)
289	299	output = firstline + pipeout.read()
290	300	finally:

293	303
294	304
295	305	class ModPythonServer(object):
296
	306
297	307	template = """
298	308	# Apache2 server configuration file for running CherryPy with mod_python.
299	309

308	318	%(opts)s
309	319	</Location>
310	320	"""
311
	321
312	322	def __init__(self, loc="/", port=80, opts=None, apache_path="apache",
313	323	handler="cherrypy._cpmodpy::handler"):
314	324	self.loc = loc

316	326	self.opts = opts
317	327	self.apache_path = apache_path
318	328	self.handler = handler
319
	329
320	330	def start(self):
321	331	opts = "".join([" PythonOption %s %s\n" % (k, v)
322	332	for k, v in self.opts])

325	335	"opts": opts,
326	336	"handler": self.handler,
327	337	}
328
	338
329	339	mpconf = os.path.join(os.path.dirname(__file__), "cpmodpy.conf")
330	340	f = open(mpconf, 'wb')
331	341	try:
332	342	f.write(conf_data)
333	343	finally:
334	344	f.close()
335
	345
336	346	response = read_process(self.apache_path, "-k start -f %s" % mpconf)
337	347	self.ready = True
338	348	return response
339
	349
340	350	def stop(self):
341	351	os.popen("apache -k stop")
342	352	self.ready = False
343

+33

-28

cherrypy/_cpnative_server.py less more

10	10
11	11
12	12	class NativeGateway(wsgiserver.Gateway):
13
	13
14	14	recursive = False
15
	15
16	16	def respond(self):
17	17	req = self.req
18	18	try:

21	21	local = httputil.Host(local[0], local[1], "")
22	22	remote = req.conn.remote_addr, req.conn.remote_port
23	23	remote = httputil.Host(remote[0], remote[1], "")
24
	24
25	25	scheme = req.scheme
26	26	sn = cherrypy.tree.script_name(req.uri or "/")
27	27	if sn is None:

34	34	headers = req.inheaders.items()
35	35	rfile = req.rfile
36	36	prev = None
37
	37
38	38	try:
39	39	redirections = []
40	40	while True:

44	44	request.multiprocess = False
45	45	request.app = app
46	46	request.prev = prev
47
48		# Run the CherryPy Request object and obtain the response
	47
	48	# Run the CherryPy Request object and obtain the
	49	# response
49	50	try:
50		request.run(method, path, qs, req.request_protocol, headers, rfile)
	51	request.run(method, path, qs,
	52	req.request_protocol, headers, rfile)
51	53	break
52	54	except cherrypy.InternalRedirect:
53	55	ir = sys.exc_info()[1]
54	56	app.release_serving()
55	57	prev = request
56
	58
57	59	if not self.recursive:
58	60	if ir.path in redirections:
59		raise RuntimeError("InternalRedirector visited the "
60		"same URL twice: %r" % ir.path)
	61	raise RuntimeError(
	62	"InternalRedirector visited the same "
	63	"URL twice: %r" % ir.path)
61	64	else:
62		# Add the previous path_info + qs to redirections.
	65	# Add the previous path_info + qs to
	66	# redirections.
63	67	if qs:
64	68	qs = "?" + qs
65	69	redirections.append(sn + path + qs)
66
	70
67	71	# Munge environment and try again.
68	72	method = "GET"
69	73	path = ir.path
70	74	qs = ir.query_string
71	75	rfile = BytesIO()
72
	76
73	77	self.send_response(
74	78	response.output_status, response.header_list,
75	79	response.body)

77	81	app.release_serving()
78	82	except:
79	83	tb = format_exc()
80		#print tb
	84	# print tb
81	85	cherrypy.log(tb, 'NATIVE_ADAPTER', severity=logging.ERROR)
82	86	s, h, b = bare_error()
83	87	self.send_response(s, h, b)
84
	88
85	89	def send_response(self, status, headers, body):
86	90	req = self.req
87
	91
88	92	# Set response status
89	93	req.status = str(status or "500 Server Error")
90
	94
91	95	# Set response headers
92	96	for header, value in headers:
93	97	req.outheaders.append((header, value))
94	98	if (req.ready and not req.sent_headers):
95	99	req.sent_headers = True
96	100	req.send_headers()
97
	101
98	102	# Set response body
99	103	for seg in body:
100	104	req.write(seg)
101	105
102	106
103	107	class CPHTTPServer(wsgiserver.HTTPServer):
	108
104	109	"""Wrapper for wsgiserver.HTTPServer.
105
	110
106	111	wsgiserver has been designed to not reference CherryPy in any way,
107	112	so that it can be used in other frameworks and applications.
108	113	Therefore, we wrap it here, so we can apply some attributes
109	114	from config -> cherrypy.server -> HTTPServer.
110	115	"""
111
	116
112	117	def __init__(self, server_adapter=cherrypy.server):
113	118	self.server_adapter = server_adapter
114
	119
115	120	server_name = (self.server_adapter.socket_host or
116	121	self.server_adapter.socket_file or
117	122	None)
118
	123
119	124	wsgiserver.HTTPServer.__init__(
120	125	self, server_adapter.bind_addr, NativeGateway,
121	126	minthreads=server_adapter.thread_pool,
122	127	maxthreads=server_adapter.thread_pool_max,
123	128	server_name=server_name)
124
125		self.max_request_header_size = self.server_adapter.max_request_header_size or 0
126		self.max_request_body_size = self.server_adapter.max_request_body_size or 0
	129
	130	self.max_request_header_size = (
	131	self.server_adapter.max_request_header_size or 0)
	132	self.max_request_body_size = (
	133	self.server_adapter.max_request_body_size or 0)
127	134	self.request_queue_size = self.server_adapter.socket_queue_size
128	135	self.timeout = self.server_adapter.socket_timeout
129	136	self.shutdown_timeout = self.server_adapter.shutdown_timeout
130	137	self.protocol = self.server_adapter.protocol_version
131	138	self.nodelay = self.server_adapter.nodelay
132
	139
133	140	ssl_module = self.server_adapter.ssl_module or 'pyopenssl'
134	141	if self.server_adapter.ssl_context:
135	142	adapter_class = wsgiserver.get_ssl_adapter_class(ssl_module)

144	151	self.server_adapter.ssl_certificate,
145	152	self.server_adapter.ssl_private_key,
146	153	self.server_adapter.ssl_certificate_chain)
147
148

+234

-186

cherrypy/_cpreqbody.py less more

2	2	.. versionadded:: 3.2
3	3
4	4	Application authors have complete control over the parsing of HTTP request
5		entities. In short, :attr:`cherrypy.request.body<cherrypy._cprequest.Request.body>`
6		is now always set to an instance of :class:`RequestBody<cherrypy._cpreqbody.RequestBody>`,
	5	entities. In short,
	6	:attr:`cherrypy.request.body<cherrypy._cprequest.Request.body>`
	7	is now always set to an instance of
	8	:class:`RequestBody<cherrypy._cpreqbody.RequestBody>`,
7	9	and that class is a subclass of :class:`Entity<cherrypy._cpreqbody.Entity>`.
8	10
9	11	When an HTTP request includes an entity body, it is often desirable to

20	22	:attr:`request.body.processors<cherrypy._cpreqbody.Entity.processors>` dict.
21	23	If the full media
22	24	type is not found, then the major type is tried; for example, if no processor
23		is found for the 'image/jpeg' type, then we look for a processor for the 'image'
24		types altogether. If neither the full type nor the major type has a matching
25		processor, then a default processor is used
	25	is found for the 'image/jpeg' type, then we look for a processor for the
	26	'image' types altogether. If neither the full type nor the major type has a
	27	matching processor, then a default processor is used
26	28	(:func:`default_proc<cherrypy._cpreqbody.Entity.default_proc>`). For most
27	29	types, this means no processing is done, and the body is left unread as a
28	30	raw byte stream. Processors are configurable in an 'on_start_resource' hook.

52	54
53	55	You can add your own processors for any specific or major MIME type. Simply add
54	56	it to the :attr:`processors<cherrypy._cprequest.Entity.processors>` dict in a
55		hook/tool that runs at ``on_start_resource`` or ``before_request_body``.
	57	hook/tool that runs at ``on_start_resource`` or ``before_request_body``.
56	58	Here's the built-in JSON tool for an example::
57	59
58	60	def json_in(force=True, debug=False):

61	63	\"""Read application/json data into request.json.\"""
62	64	if not entity.headers.get("Content-Length", ""):
63	65	raise cherrypy.HTTPError(411)
64
	66
65	67	body = entity.fp.read()
66	68	try:
67	69	request.json = json_decode(body)

73	75	415, 'Expected an application/json content type')
74	76	request.body.processors['application/json'] = json_processor
75	77
76		We begin by defining a new ``json_processor`` function to stick in the ``processors``
77		dictionary. All processor functions take a single argument, the ``Entity`` instance
78		they are to process. It will be called whenever a request is received (for those
79		URI's where the tool is turned on) which has a ``Content-Type`` of
80		"application/json".
81
82		First, it checks for a valid ``Content-Length`` (raising 411 if not valid), then
83		reads the remaining bytes on the socket. The ``fp`` object knows its own length, so
84		it won't hang waiting for data that never arrives. It will return when all data
85		has been read. Then, we decode those bytes using Python's built-in ``json`` module,
86		and stick the decoded result onto ``request.json`` . If it cannot be decoded, we
87		raise 400.
88
89		If the "force" argument is True (the default), the ``Tool`` clears the ``processors``
90		dict so that request entities of other ``Content-Types`` aren't parsed at all. Since
91		there's no entry for those invalid MIME types, the ``default_proc`` method of ``cherrypy.request.body``
92		is called. But this does nothing by default (usually to provide the page handler an opportunity to handle it.)
93		But in our case, we want to raise 415, so we replace ``request.body.default_proc``
	78	We begin by defining a new ``json_processor`` function to stick in the
	79	``processors`` dictionary. All processor functions take a single argument,
	80	the ``Entity`` instance they are to process. It will be called whenever a
	81	request is received (for those URI's where the tool is turned on) which
	82	has a ``Content-Type`` of "application/json".
	83
	84	First, it checks for a valid ``Content-Length`` (raising 411 if not valid),
	85	then reads the remaining bytes on the socket. The ``fp`` object knows its
	86	own length, so it won't hang waiting for data that never arrives. It will
	87	return when all data has been read. Then, we decode those bytes using
	88	Python's built-in ``json`` module, and stick the decoded result onto
	89	``request.json`` . If it cannot be decoded, we raise 400.
	90
	91	If the "force" argument is True (the default), the ``Tool`` clears the
	92	``processors`` dict so that request entities of other ``Content-Types``
	93	aren't parsed at all. Since there's no entry for those invalid MIME
	94	types, the ``default_proc`` method of ``cherrypy.request.body`` is
	95	called. But this does nothing by default (usually to provide the page
	96	handler an opportunity to handle it.)
	97	But in our case, we want to raise 415, so we replace
	98	``request.body.default_proc``
94	99	with the error (``HTTPError`` instances, when called, raise themselves).
95	100
96		If we were defining a custom processor, we can do so without making a ``Tool``. Just add the config entry::
	101	If we were defining a custom processor, we can do so without making a ``Tool``.
	102	Just add the config entry::
97	103
98	104	request.body.processors = {'application/json': json_processor}
99	105
100		Note that you can only replace the ``processors`` dict wholesale this way, not update the existing one.
	106	Note that you can only replace the ``processors`` dict wholesale this way,
	107	not update the existing one.
101	108	"""
102	109
103	110	try:

128	135	from cherrypy.lib import httputil
129	136
130	137
131		# -------------------------------- Processors -------------------------------- #
	138	# ------------------------------- Processors -------------------------------- #
132	139
133	140	def process_urlencoded(entity):
134	141	"""Read application/x-www-form-urlencoded data into entity.params."""

140	147	for pair in aparam.split(ntob(';')):
141	148	if not pair:
142	149	continue
143
	150
144	151	atoms = pair.split(ntob('='), 1)
145	152	if len(atoms) == 1:
146	153	atoms.append(ntob(''))
147
	154
148	155	key = unquote_plus(atoms[0]).decode(charset)
149	156	value = unquote_plus(atoms[1]).decode(charset)
150
	157
151	158	if key in params:
152	159	if not isinstance(params[key], list):
153	160	params[key] = [params[key]]

163	170	raise cherrypy.HTTPError(
164	171	400, "The request entity could not be decoded. The following "
165	172	"charsets were attempted: %s" % repr(entity.attempt_charsets))
166
	173
167	174	# Now that all values have been successfully parsed and decoded,
168	175	# apply them to the entity.params dict.
169	176	for key, value in params.items():

184	191	# is often necessary to enclose the boundary parameter values in quotes
185	192	# on the Content-type line"
186	193	ib = entity.content_type.params['boundary'].strip('"')
187
	194
188	195	if not re.match("^[ -~]{0,200}[!-~]$", ib):
189	196	raise ValueError('Invalid boundary in multipart form: %r' % (ib,))
190
	197
191	198	ib = ('--' + ib).encode('ascii')
192
	199
193	200	# Find the first marker
194	201	while True:
195	202	b = entity.readline()
196	203	if not b:
197	204	return
198
	205
199	206	b = b.strip()
200	207	if b == ib:
201	208	break
202
	209
203	210	# Read all parts
204	211	while True:
205	212	part = entity.part_class.from_fp(entity.fp, ib)

208	215	if part.fp.done:
209	216	break
210	217
	218
211	219	def process_multipart_form_data(entity):
212		"""Read all multipart/form-data parts into entity.parts or entity.params."""
	220	"""Read all multipart/form-data parts into entity.parts or entity.params.
	221	"""
213	222	process_multipart(entity)
214
	223
215	224	kept_parts = []
216	225	for part in entity.parts:
217	226	if part.name is None:

224	233	# It's a file upload. Retain the whole part so consumer code
225	234	# has access to its .file and .filename attributes.
226	235	value = part
227
	236
228	237	if part.name in entity.params:
229	238	if not isinstance(entity.params[part.name], list):
230	239	entity.params[part.name] = [entity.params[part.name]]
231	240	entity.params[part.name].append(value)
232	241	else:
233	242	entity.params[part.name] = value
234
	243
235	244	entity.parts = kept_parts
	245
236	246
237	247	def _old_process_multipart(entity):
238	248	"""The behavior of 3.2 and lower. Deprecated and will be changed in 3.3."""
239	249	process_multipart(entity)
240
	250
241	251	params = entity.params
242
	252
243	253	for part in entity.parts:
244	254	if part.name is None:
245	255	key = ntou('parts')
246	256	else:
247	257	key = part.name
248
	258
249	259	if part.filename is None:
250	260	# It's a regular field
251	261	value = part.fullvalue()

253	263	# It's a file upload. Retain the whole part so consumer code
254	264	# has access to its .file and .filename attributes.
255	265	value = part
256
	266
257	267	if key in params:
258	268	if not isinstance(params[key], list):
259	269	params[key] = [params[key]]

262	272	params[key] = value
263	273
264	274
265
266		# --------------------------------- Entities --------------------------------- #
267
268
	275	# -------------------------------- Entities --------------------------------- #
269	276	class Entity(object):
	277
270	278	"""An HTTP request body, or MIME multipart body.
271
	279
272	280	This class collects information about the HTTP request entity. When a
273	281	given entity is of MIME type "multipart", each part is parsed into its own
274	282	Entity instance, and the set of parts stored in
275	283	:attr:`entity.parts<cherrypy._cpreqbody.Entity.parts>`.
276
	284
277	285	Between the ``before_request_body`` and ``before_handler`` tools, CherryPy
278	286	tries to process the request body (if any) by calling
279		:func:`request.body.process<cherrypy._cpreqbody.RequestBody.process`.
280		This uses the ``content_type`` of the Entity to look up a suitable processor
281		in :attr:`Entity.processors<cherrypy._cpreqbody.Entity.processors>`, a dict.
	287	:func:`request.body.process<cherrypy._cpreqbody.RequestBody.process>`.
	288	This uses the ``content_type`` of the Entity to look up a suitable
	289	processor in
	290	:attr:`Entity.processors<cherrypy._cpreqbody.Entity.processors>`,
	291	a dict.
282	292	If a matching processor cannot be found for the complete Content-Type,
283	293	it tries again using the major type. For example, if a request with an
284	294	entity of type "image/jpeg" arrives, but no processor can be found for
285	295	that complete type, then one is sought for the major type "image". If a
286	296	processor is still not found, then the
287		:func:`default_proc<cherrypy._cpreqbody.Entity.default_proc>` method of the
288		Entity is called (which does nothing by default; you can override this too).
289
	297	:func:`default_proc<cherrypy._cpreqbody.Entity.default_proc>` method
	298	of the Entity is called (which does nothing by default; you can
	299	override this too).
	300
290	301	CherryPy includes processors for the "application/x-www-form-urlencoded"
291	302	type, the "multipart/form-data" type, and the "multipart" major type.
292	303	CherryPy 3.2 processes these types almost exactly as older versions.

297	308	case it will have ``file`` and ``filename`` attributes, or possibly a
298	309	``value`` attribute). Each Part is itself a subclass of
299	310	Entity, and has its own ``process`` method and ``processors`` dict.
300
	311
301	312	There is a separate processor for the "multipart" major type which is more
302	313	flexible, and simply stores all multipart parts in
303	314	:attr:`request.body.parts<cherrypy._cpreqbody.Entity.parts>`. You can
304	315	enable it with::
305
	316
306	317	cherrypy.request.body.processors['multipart'] = _cpreqbody.process_multipart
307
	318
308	319	in an ``on_start_resource`` tool.
309	320	"""
310
	321
311	322	# http://tools.ietf.org/html/rfc2046#section-4.1.2:
312	323	# "The default character set, which must be assumed in the
313	324	# absence of a charset parameter, is US-ASCII."
314	325	# However, many browsers send data in utf-8 with no charset.
315	326	attempt_charsets = ['utf-8']
316	327	"""A list of strings, each of which should be a known encoding.
317
	328
318	329	When the Content-Type of the request body warrants it, each of the given
319	330	encodings will be tried in order. The first one to successfully decode the
320	331	entity without raising an error is stored as
321	332	:attr:`entity.charset<cherrypy._cpreqbody.Entity.charset>`. This defaults
322		to ``['utf-8']`` (plus 'ISO-8859-1' for "text/\*" types, as required by
323		`HTTP/1.1 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1>`_),
	333	to ``['utf-8']`` (plus 'ISO-8859-1' for "text/\*" types, as required by
	334	`HTTP/1.1 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1>`_),
324	335	but ``['us-ascii', 'utf-8']`` for multipart parts.
325	336	"""
326
	337
327	338	charset = None
328	339	"""The successful decoding; see "attempt_charsets" above."""
329
	340
330	341	content_type = None
331	342	"""The value of the Content-Type request header.
332
	343
333	344	If the Entity is part of a multipart payload, this will be the Content-Type
334	345	given in the MIME headers for this part.
335	346	"""
336
	347
337	348	default_content_type = 'application/x-www-form-urlencoded'
338	349	"""This defines a default ``Content-Type`` to use if no Content-Type header
339	350	is given. The empty string is used for RequestBody, which results in the

343	354	declares that a part with no Content-Type defaults to "text/plain"
344	355	(see :class:`Part<cherrypy._cpreqbody.Part>`).
345	356	"""
346
	357
347	358	filename = None
348	359	"""The ``Content-Disposition.filename`` header, if available."""
349
	360
350	361	fp = None
351	362	"""The readable socket file object."""
352
	363
353	364	headers = None
354	365	"""A dict of request/multipart header names and values.
355
	366
356	367	This is a copy of the ``request.headers`` for the ``request.body``;
357	368	for multipart parts, it is the set of headers for that part.
358	369	"""
359
	370
360	371	length = None
361	372	"""The value of the ``Content-Length`` header, if provided."""
362
	373
363	374	name = None
364	375	"""The "name" parameter of the ``Content-Disposition`` header, if any."""
365
	376
366	377	params = None
367	378	"""
368	379	If the request Content-Type is 'application/x-www-form-urlencoded' or

372	383	can be sent with various HTTP method verbs). This value is set between
373	384	the 'before_request_body' and 'before_handler' hooks (assuming that
374	385	process_request_body is True)."""
375
	386
376	387	processors = {'application/x-www-form-urlencoded': process_urlencoded,
377	388	'multipart/form-data': process_multipart_form_data,
378	389	'multipart': process_multipart,
379	390	}
380	391	"""A dict of Content-Type names to processor methods."""
381
	392
382	393	parts = None
383		"""A list of Part instances if ``Content-Type`` is of major type "multipart"."""
384
	394	"""A list of Part instances if ``Content-Type`` is of major type
	395	"multipart"."""
	396
385	397	part_class = None
386	398	"""The class used for multipart parts.
387
	399
388	400	You can replace this with custom subclasses to alter the processing of
389	401	multipart parts.
390	402	"""
391
	403
392	404	def __init__(self, fp, headers, params=None, parts=None):
393	405	# Make an instance-specific copy of the class processors
394	406	# so Tools, etc. can replace them per-request.
395	407	self.processors = self.processors.copy()
396
	408
397	409	self.fp = fp
398	410	self.headers = headers
399
	411
400	412	if params is None:
401	413	params = {}
402	414	self.params = params
403
	415
404	416	if parts is None:
405	417	parts = []
406	418	self.parts = parts
407
	419
408	420	# Content-Type
409	421	self.content_type = headers.elements('Content-Type')
410	422	if self.content_type:

412	424	else:
413	425	self.content_type = httputil.HeaderElement.from_str(
414	426	self.default_content_type)
415
416		# Copy the class 'attempt_charsets', prepending any Content-Type charset
	427
	428	# Copy the class 'attempt_charsets', prepending any Content-Type
	429	# charset
417	430	dec = self.content_type.params.get("charset", None)
418	431	if dec:
419	432	self.attempt_charsets = [dec] + [c for c in self.attempt_charsets
420	433	if c != dec]
421	434	else:
422	435	self.attempt_charsets = self.attempt_charsets[:]
423
	436
424	437	# Length
425	438	self.length = None
426	439	clen = headers.get('Content-Length', None)
427	440	# If Transfer-Encoding is 'chunked', ignore any Content-Length.
428		if clen is not None and 'chunked' not in headers.get('Transfer-Encoding', ''):
	441	if (
	442	clen is not None and
	443	'chunked' not in headers.get('Transfer-Encoding', '')
	444	):
429	445	try:
430	446	self.length = int(clen)
431	447	except ValueError:
432	448	pass
433
	449
434	450	# Content-Disposition
435	451	self.name = None
436	452	self.filename = None

443	459	self.name = self.name[1:-1]
444	460	if 'filename' in disp.params:
445	461	self.filename = disp.params['filename']
446		if self.filename.startswith('"') and self.filename.endswith('"'):
	462	if (
	463	self.filename.startswith('"') and
	464	self.filename.endswith('"')
	465	):
447	466	self.filename = self.filename[1:-1]
448
	467
449	468	# The 'type' attribute is deprecated in 3.2; remove it in 3.3.
450		type = property(lambda self: self.content_type,
451		doc="""A deprecated alias for :attr:`content_type<cherrypy._cpreqbody.Entity.content_type>`.""")
452
	469	type = property(
	470	lambda self: self.content_type,
	471	doc="A deprecated alias for "
	472	":attr:`content_type<cherrypy._cpreqbody.Entity.content_type>`."
	473	)
	474
453	475	def read(self, size=None, fp_out=None):
454	476	return self.fp.read(size, fp_out)
455
	477
456	478	def readline(self, size=None):
457	479	return self.fp.readline(size)
458
	480
459	481	def readlines(self, sizehint=None):
460	482	return self.fp.readlines(sizehint)
461
	483
462	484	def __iter__(self):
463	485	return self
464
	486
465	487	def __next__(self):
466	488	line = self.readline()
467	489	if not line:

470	492
471	493	def next(self):
472	494	return self.__next__()
473
	495
474	496	def read_into_file(self, fp_out=None):
475		"""Read the request body into fp_out (or make_file() if None). Return fp_out."""
	497	"""Read the request body into fp_out (or make_file() if None).
	498
	499	Return fp_out.
	500	"""
476	501	if fp_out is None:
477	502	fp_out = self.make_file()
478	503	self.read(fp_out=fp_out)
479	504	return fp_out
480
	505
481	506	def make_file(self):
482	507	"""Return a file-like object into which the request body will be read.
483
	508
484	509	By default, this will return a TemporaryFile. Override as needed.
485	510	See also :attr:`cherrypy._cpreqbody.Part.maxrambytes`."""
486	511	return tempfile.TemporaryFile()
487
	512
488	513	def fullvalue(self):
489	514	"""Return this entity as a string, whether stored in a file or not."""
490	515	if self.file:

495	520	else:
496	521	value = self.value
497	522	return value
498
	523
499	524	def process(self):
500	525	"""Execute the best-match processor for the given media type."""
501	526	proc = None

512	537	self.default_proc()
513	538	else:
514	539	proc(self)
515
	540
516	541	def default_proc(self):
517		"""Called if a more-specific processor is not found for the ``Content-Type``."""
	542	"""Called if a more-specific processor is not found for the
	543	``Content-Type``.
	544	"""
518	545	# Leave the fp alone for someone else to read. This works fine
519	546	# for request.body, but the Part subclasses need to override this
520	547	# so they can move on to the next part.

522	549
523	550
524	551	class Part(Entity):
	552
525	553	"""A MIME part entity, part of a multipart entity."""
526
	554
527	555	# "The default character set, which must be assumed in the absence of a
528	556	# charset parameter, is US-ASCII."
529	557	attempt_charsets = ['us-ascii', 'utf-8']
530	558	"""A list of strings, each of which should be a known encoding.
531
	559
532	560	When the Content-Type of the request body warrants it, each of the given
533	561	encodings will be tried in order. The first one to successfully decode the
534	562	entity without raising an error is stored as
535	563	:attr:`entity.charset<cherrypy._cpreqbody.Entity.charset>`. This defaults
536		to ``['utf-8']`` (plus 'ISO-8859-1' for "text/\*" types, as required by
537		`HTTP/1.1 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1>`_),
	564	to ``['utf-8']`` (plus 'ISO-8859-1' for "text/\*" types, as required by
	565	`HTTP/1.1 <http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1>`_),
538	566	but ``['us-ascii', 'utf-8']`` for multipart parts.
539	567	"""
540
	568
541	569	boundary = None
542	570	"""The MIME multipart boundary."""
543
	571
544	572	default_content_type = 'text/plain'
545	573	"""This defines a default ``Content-Type`` to use if no Content-Type header
546	574	is given. The empty string is used for RequestBody, which results in the

550	578	the MIME spec declares that a part with no Content-Type defaults to
551	579	"text/plain".
552	580	"""
553
	581
554	582	# This is the default in stdlib cgi. We may want to increase it.
555	583	maxrambytes = 1000
556		"""The threshold of bytes after which point the ``Part`` will store its data
557		in a file (generated by :func:`make_file<cherrypy._cprequest.Entity.make_file>`)
558		instead of a string. Defaults to 1000, just like the :mod:`cgi` module in
559		Python's standard library.
560		"""
561
	584	"""The threshold of bytes after which point the ``Part`` will store
	585	its data in a file (generated by
	586	:func:`make_file<cherrypy._cprequest.Entity.make_file>`)
	587	instead of a string. Defaults to 1000, just like the :mod:`cgi`
	588	module in Python's standard library.
	589	"""
	590
562	591	def __init__(self, fp, headers, boundary):
563	592	Entity.__init__(self, fp, headers)
564	593	self.boundary = boundary
565	594	self.file = None
566	595	self.value = None
567
	596
568	597	def from_fp(cls, fp, boundary):
569	598	headers = cls.read_headers(fp)
570	599	return cls(fp, headers, boundary)
571	600	from_fp = classmethod(from_fp)
572
	601
573	602	def read_headers(cls, fp):
574	603	headers = httputil.HeaderMap()
575	604	while True:

577	606	if not line:
578	607	# No more data--illegal end of headers
579	608	raise EOFError("Illegal end of headers.")
580
	609
581	610	if line == ntob('\r\n'):
582	611	# Normal end of headers
583	612	break
584	613	if not line.endswith(ntob('\r\n')):
585	614	raise ValueError("MIME requires CRLF terminators: %r" % line)
586
	615
587	616	if line[0] in ntob(' \t'):
588	617	# It's a continuation line.
589	618	v = line.strip().decode('ISO-8859-1')

591	620	k, v = line.split(ntob(":"), 1)
592	621	k = k.strip().decode('ISO-8859-1')
593	622	v = v.strip().decode('ISO-8859-1')
594
	623
595	624	existing = headers.get(k)
596	625	if existing:
597	626	v = ", ".join((existing, v))
598	627	headers[k] = v
599
	628
600	629	return headers
601	630	read_headers = classmethod(read_headers)
602
	631
603	632	def read_lines_to_boundary(self, fp_out=None):
604	633	"""Read bytes from self.fp and return or write them to a file.
605
	634
606	635	If the 'fp_out' argument is None (the default), all bytes read are
607	636	returned in a single byte string.
608
609		If the 'fp_out' argument is not None, it must be a file-like object that
610		supports the 'write' method; all bytes read will be written to the fp,
611		and that fp is returned.
	637
	638	If the 'fp_out' argument is not None, it must be a file-like
	639	object that supports the 'write' method; all bytes read will be
	640	written to the fp, and that fp is returned.
612	641	"""
613	642	endmarker = self.boundary + ntob("--")
614	643	delim = ntob("")

616	645	lines = []
617	646	seen = 0
618	647	while True:
619		line = self.fp.readline(1<<16)
	648	line = self.fp.readline(1 << 16)
620	649	if not line:
621	650	raise EOFError("Illegal end of multipart body.")
622	651	if line.startswith(ntob("--")) and prev_lf:

626	655	if strippedline == endmarker:
627	656	self.fp.finish()
628	657	break
629
	658
630	659	line = delim + line
631
	660
632	661	if line.endswith(ntob("\r\n")):
633	662	delim = ntob("\r\n")
634	663	line = line[:-2]

640	669	else:
641	670	delim = ntob("")
642	671	prev_lf = False
643
	672
644	673	if fp_out is None:
645	674	lines.append(line)
646	675	seen += len(line)

650	679	fp_out.write(line)
651	680	else:
652	681	fp_out.write(line)
653
	682
654	683	if fp_out is None:
655	684	result = ntob('').join(lines)
656	685	for charset in self.attempt_charsets:

663	692	return result
664	693	else:
665	694	raise cherrypy.HTTPError(
666		400, "The request entity could not be decoded. The following "
667		"charsets were attempted: %s" % repr(self.attempt_charsets))
	695	400,
	696	"The request entity could not be decoded. The following "
	697	"charsets were attempted: %s" % repr(self.attempt_charsets)
	698	)
668	699	else:
669	700	fp_out.seek(0)
670	701	return fp_out
671
	702
672	703	def default_proc(self):
673		"""Called if a more-specific processor is not found for the ``Content-Type``."""
	704	"""Called if a more-specific processor is not found for the
	705	``Content-Type``.
	706	"""
674	707	if self.filename:
675	708	# Always read into a file if a .filename was given.
676	709	self.file = self.read_into_file()

680	713	self.value = result
681	714	else:
682	715	self.file = result
683
	716
684	717	def read_into_file(self, fp_out=None):
685		"""Read the request body into fp_out (or make_file() if None). Return fp_out."""
	718	"""Read the request body into fp_out (or make_file() if None).
	719
	720	Return fp_out.
	721	"""
686	722	if fp_out is None:
687	723	fp_out = self.make_file()
688	724	self.read_lines_to_boundary(fp_out=fp_out)

695	731	except ValueError:
696	732	# Python 2.4 and lower
697	733	class Infinity(object):
	734
698	735	def __cmp__(self, other):
699	736	return 1
	737
700	738	def __sub__(self, other):
701	739	return self
702	740	inf = Infinity()
703	741
704	742
705		comma_separated_headers = ['Accept', 'Accept-Charset', 'Accept-Encoding',
706		'Accept-Language', 'Accept-Ranges', 'Allow', 'Cache-Control', 'Connection',
707		'Content-Encoding', 'Content-Language', 'Expect', 'If-Match',
708		'If-None-Match', 'Pragma', 'Proxy-Authenticate', 'Te', 'Trailer',
709		'Transfer-Encoding', 'Upgrade', 'Vary', 'Via', 'Warning', 'Www-Authenticate']
	743	comma_separated_headers = [
	744	'Accept', 'Accept-Charset', 'Accept-Encoding',
	745	'Accept-Language', 'Accept-Ranges', 'Allow',
	746	'Cache-Control', 'Connection', 'Content-Encoding',
	747	'Content-Language', 'Expect', 'If-Match',
	748	'If-None-Match', 'Pragma', 'Proxy-Authenticate',
	749	'Te', 'Trailer', 'Transfer-Encoding', 'Upgrade',
	750	'Vary', 'Via', 'Warning', 'Www-Authenticate'
	751	]
710	752
711	753
712	754	class SizedReader:
713
714		def __init__(self, fp, length, maxbytes, bufsize=DEFAULT_BUFFER_SIZE, has_trailers=False):
	755
	756	def __init__(self, fp, length, maxbytes, bufsize=DEFAULT_BUFFER_SIZE,
	757	has_trailers=False):
715	758	# Wrap our fp in a buffer so peek() works
716	759	self.fp = fp
717	760	self.length = length

721	764	self.bytes_read = 0
722	765	self.done = False
723	766	self.has_trailers = has_trailers
724
	767
725	768	def read(self, size=None, fp_out=None):
726	769	"""Read bytes from the request body and return or write them to a file.
727
	770
728	771	A number of bytes less than or equal to the 'size' argument are read
729	772	off the socket. The actual number of bytes read are tracked in
730	773	self.bytes_read. The number may be smaller than 'size' when 1) the
731	774	client sends fewer bytes, 2) the 'Content-Length' request header
732	775	specifies fewer bytes than requested, or 3) the number of bytes read
733	776	exceeds self.maxbytes (in which case, 413 is raised).
734
	777
735	778	If the 'fp_out' argument is None (the default), all bytes read are
736	779	returned in a single byte string.
737
738		If the 'fp_out' argument is not None, it must be a file-like object that
739		supports the 'write' method; all bytes read will be written to the fp,
740		and None is returned.
	780
	781	If the 'fp_out' argument is not None, it must be a file-like
	782	object that supports the 'write' method; all bytes read will be
	783	written to the fp, and None is returned.
741	784	"""
742
	785
743	786	if self.length is None:
744	787	if size is None:
745	788	remaining = inf

755	798	return ntob('')
756	799	else:
757	800	return None
758
	801
759	802	chunks = []
760
	803
761	804	# Read bytes from the buffer.
762	805	if self.buffer:
763	806	if remaining is inf:

768	811	self.buffer = self.buffer[remaining:]
769	812	datalen = len(data)
770	813	remaining -= datalen
771
	814
772	815	# Check lengths.
773	816	self.bytes_read += datalen
774	817	if self.maxbytes and self.bytes_read > self.maxbytes:
775	818	raise cherrypy.HTTPError(413)
776
	819
777	820	# Store the data.
778	821	if fp_out is None:
779	822	chunks.append(data)
780	823	else:
781	824	fp_out.write(data)
782
	825
783	826	# Read bytes from the socket.
784	827	while remaining > 0:
785	828	chunksize = min(remaining, self.bufsize)

798	841	break
799	842	datalen = len(data)
800	843	remaining -= datalen
801
	844
802	845	# Check lengths.
803	846	self.bytes_read += datalen
804	847	if self.maxbytes and self.bytes_read > self.maxbytes:
805	848	raise cherrypy.HTTPError(413)
806
	849
807	850	# Store the data.
808	851	if fp_out is None:
809	852	chunks.append(data)
810	853	else:
811	854	fp_out.write(data)
812
	855
813	856	if fp_out is None:
814	857	return ntob('').join(chunks)
815
	858
816	859	def readline(self, size=None):
817	860	"""Read a line from the request body and return it."""
818	861	chunks = []

833	876	else:
834	877	chunks.append(data)
835	878	return ntob('').join(chunks)
836
	879
837	880	def readlines(self, sizehint=None):
838	881	"""Read lines from the request body and return them."""
839	882	if self.length is not None:

841	884	sizehint = self.length - self.bytes_read
842	885	else:
843	886	sizehint = min(sizehint, self.length - self.bytes_read)
844
	887
845	888	lines = []
846	889	seen = 0
847	890	while True:

853	896	if seen >= sizehint:
854	897	break
855	898	return lines
856
	899
857	900	def finish(self):
858	901	self.done = True
859	902	if self.has_trailers and hasattr(self.fp, 'read_trailer_lines'):
860	903	self.trailers = {}
861
	904
862	905	try:
863	906	for line in self.fp.read_trailer_lines():
864	907	if line[0] in ntob(' \t'):

871	914	raise ValueError("Illegal header line.")
872	915	k = k.strip().title()
873	916	v = v.strip()
874
	917
875	918	if k in comma_separated_headers:
876	919	existing = self.trailers.get(envname)
877	920	if existing:

888	931
889	932
890	933	class RequestBody(Entity):
	934
891	935	"""The entity of the HTTP request."""
892
	936
893	937	bufsize = 8 * 1024
894	938	"""The buffer size used when reading the socket."""
895
	939
896	940	# Don't parse the request body at all if the client didn't provide
897		# a Content-Type header. See http://www.cherrypy.org/ticket/790
	941	# a Content-Type header. See
	942	# https://bitbucket.org/cherrypy/cherrypy/issue/790
898	943	default_content_type = ''
899	944	"""This defines a default ``Content-Type`` to use if no Content-Type header
900	945	is given. The empty string is used for RequestBody, which results in the

904	949	declares that a part with no Content-Type defaults to "text/plain"
905	950	(see :class:`Part<cherrypy._cpreqbody.Part>`).
906	951	"""
907
	952
908	953	maxbytes = None
909		"""Raise ``MaxSizeExceeded`` if more bytes than this are read from the socket."""
910
	954	"""Raise ``MaxSizeExceeded`` if more bytes than this are read from
	955	the socket.
	956	"""
	957
911	958	def __init__(self, fp, headers, params=None, request_params=None):
912	959	Entity.__init__(self, fp, headers, params)
913
	960
914	961	# http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1
915	962	# When no explicit charset parameter is provided by the
916	963	# sender, media subtypes of the "text" type are defined

922	969	break
923	970	else:
924	971	self.attempt_charsets.append('ISO-8859-1')
925
	972
926	973	# Temporary fix while deprecating passing .parts as .params.
927	974	self.processors['multipart'] = _old_process_multipart
928
	975
929	976	if request_params is None:
930	977	request_params = {}
931	978	self.request_params = request_params
932
	979
933	980	def process(self):
934	981	"""Process the request entity based on its Content-Type."""
935	982	# "The presence of a message-body in a request is signaled by the

941	988	h = cherrypy.serving.request.headers
942	989	if 'Content-Length' not in h and 'Transfer-Encoding' not in h:
943	990	raise cherrypy.HTTPError(411)
944
	991
945	992	self.fp = SizedReader(self.fp, self.length,
946	993	self.maxbytes, bufsize=self.bufsize,
947	994	has_trailers='Trailer' in h)
948	995	super(RequestBody, self).process()
949
	996
950	997	# Body params should also be a part of the request_params
951	998	# add them in here.
952	999	request_params = self.request_params
953	1000	for key, value in self.params.items():
954		# Python 2 only: keyword arguments must be byte strings (type 'str').
	1001	# Python 2 only: keyword arguments must be byte strings (type
	1002	# 'str').
955	1003	if sys.version_info < (3, 0):
956	1004	if isinstance(key, unicode):
957	1005	key = key.encode('ISO-8859-1')
958
	1006
959	1007	if key in request_params:
960	1008	if not isinstance(request_params[key], list):
961	1009	request_params[key] = [request_params[key]]

+183

-166

cherrypy/_cprequest.py less more

12	12
13	13
14	14	class Hook(object):
	15
15	16	"""A callback and its metadata: failsafe, priority, and kwargs."""
16
	17
17	18	callback = None
18	19	"""
19	20	The bare callable that this Hook object is wrapping, which will
20	21	be called when the Hook is called."""
21
	22
22	23	failsafe = False
23	24	"""
24	25	If True, the callback is guaranteed to run even if other callbacks
25	26	from the same call point raise exceptions."""
26
	27
27	28	priority = 50
28	29	"""
29	30	Defines the order of execution for a list of Hooks. Priority numbers
30	31	should be limited to the closed interval [0, 100], but values outside
31	32	this range are acceptable, as are fractional values."""
32
	33
33	34	kwargs = {}
34	35	"""
35	36	A set of keyword arguments that will be passed to the
36	37	callable on each call."""
37
	38
38	39	def __init__(self, callback, failsafe=None, priority=None, **kwargs):
39	40	self.callback = callback
40
	41
41	42	if failsafe is None:
42	43	failsafe = getattr(callback, "failsafe", False)
43	44	self.failsafe = failsafe
44
	45
45	46	if priority is None:
46	47	priority = getattr(callback, "priority", 50)
47	48	self.priority = priority
48
	49
49	50	self.kwargs = kwargs
50
	51
51	52	def __lt__(self, other):
52	53	# Python 3
53	54	return self.priority < other.priority

55	56	def __cmp__(self, other):
56	57	# Python 2
57	58	return cmp(self.priority, other.priority)
58
	59
59	60	def __call__(self):
60	61	"""Run self.callback(**self.kwargs)."""
61	62	return self.callback(**self.kwargs)
62
	63
63	64	def __repr__(self):
64	65	cls = self.__class__
65	66	return ("%s.%s(callback=%r, failsafe=%r, priority=%r, %s)"

70	71
71	72
72	73	class HookMap(dict):
	74
73	75	"""A map of call points to lists of callbacks (Hook objects)."""
74
	76
75	77	def __new__(cls, points=None):
76	78	d = dict.__new__(cls)
77	79	for p in points or []:
78	80	d[p] = []
79	81	return d
80
	82
81	83	def __init__(self, a, *kw):
82	84	pass
83
	85
84	86	def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
85	87	"""Append a new Hook made from the supplied arguments."""
86	88	self[point].append(Hook(callback, failsafe, priority, **kwargs))
87
	89
88	90	def run(self, point):
89	91	"""Execute all registered Hooks (callbacks) for the given point."""
90	92	exc = None

109	111	cherrypy.log(traceback=True, severity=40)
110	112	if exc:
111	113	raise exc
112
	114
113	115	def __copy__(self):
114	116	newmap = self.__class__()
115	117	# We can't just use 'update' because we want copies of the

118	120	newmap[k] = v[:]
119	121	return newmap
120	122	copy = __copy__
121
	123
122	124	def __repr__(self):
123	125	cls = self.__class__
124		return "%s.%s(points=%r)" % (cls.__module__, cls.__name__, copykeys(self))
	126	return "%s.%s(points=%r)" % (
	127	cls.__module__,
	128	cls.__name__,
	129	copykeys(self)
	130	)
125	131
126	132
127	133	# Config namespace handlers

138	144	v = Hook(v)
139	145	cherrypy.serving.request.hooks[hookpoint].append(v)
140	146
	147
141	148	def request_namespace(k, v):
142	149	"""Attach request attributes declared in config."""
143		# Provides config entries to set request.body attrs (like attempt_charsets).
	150	# Provides config entries to set request.body attrs (like
	151	# attempt_charsets).
144	152	if k[:5] == 'body.':
145	153	setattr(cherrypy.serving.request.body, k[5:], v)
146	154	else:
147	155	setattr(cherrypy.serving.request, k, v)
	156
148	157
149	158	def response_namespace(k, v):
150	159	"""Attach response attributes declared in config."""

155	164	else:
156	165	setattr(cherrypy.serving.response, k, v)
157	166
	167
158	168	def error_page_namespace(k, v):
159	169	"""Attach error pages declared in config."""
160	170	if k != 'default':

169	179
170	180
171	181	class Request(object):
	182
172	183	"""An HTTP request.
173
	184
174	185	This object represents the metadata of an HTTP request message;
175	186	that is, it contains attributes which describe the environment
176	187	in which the request URL, headers, and body were sent (if you

180	191	also contains data regarding the configuration in effect for
181	192	the given URL, and the execution plan for generating a response.
182	193	"""
183
	194
184	195	prev = None
185	196	"""
186	197	The previous Request object (if any). This should be None
187	198	unless we are processing an InternalRedirect."""
188
	199
189	200	# Conversation/connection attributes
190	201	local = httputil.Host("127.0.0.1", 80)
191	202	"An httputil.Host(ip, port, hostname) object for the server socket."
192
	203
193	204	remote = httputil.Host("127.0.0.1", 1111)
194	205	"An httputil.Host(ip, port, hostname) object for the client socket."
195
	206
196	207	scheme = "http"
197	208	"""
198	209	The protocol used between client and server. In most cases,
199	210	this will be either 'http' or 'https'."""
200
	211
201	212	server_protocol = "HTTP/1.1"
202	213	"""
203	214	The HTTP version for which the HTTP server is at least
204	215	conditionally compliant."""
205
	216
206	217	base = ""
207	218	"""The (scheme://host) portion of the requested URL.
208	219	In some cases (e.g. when proxying via mod_rewrite), this may contain
209	220	path segments which cherrypy.url uses when constructing url's, but
210	221	which otherwise are ignored by CherryPy. Regardless, this value
211	222	MUST NOT end in a slash."""
212
	223
213	224	# Request-Line attributes
214	225	request_line = ""
215	226	"""
216	227	The complete Request-Line received from the client. This is a
217	228	single string consisting of the request method, URI, and protocol
218	229	version (joined by spaces). Any final CRLF is removed."""
219
	230
220	231	method = "GET"
221	232	"""
222	233	Indicates the HTTP method to be performed on the resource identified

224	235	DELETE. CherryPy allows any extension method; however, various HTTP
225	236	servers and gateways may restrict the set of allowable methods.
226	237	CherryPy applications SHOULD restrict the set (on a per-URI basis)."""
227
	238
228	239	query_string = ""
229	240	"""
230	241	The query component of the Request-URI, a string of information to be

232	243	path component, and is separated by a '?'. For example, the URI
233	244	'http://www.cherrypy.org/wiki?a=3&b=4' has the query component,
234	245	'a=3&b=4'."""
235
	246
236	247	query_string_encoding = 'utf8'
237	248	"""
238	249	The encoding expected for query string arguments after % HEX HEX decoding).

241	252	arbitrary encodings to not error, set this to 'Latin-1'; you can then
242	253	encode back to bytes and re-decode to whatever encoding you like later.
243	254	"""
244
	255
245	256	protocol = (1, 1)
246	257	"""The HTTP protocol version corresponding to the set
247	258	of features which should be allowed in the response. If BOTH

249	260	compliance is HTTP/1.1, this attribute will be the tuple (1, 1).
250	261	If either is 1.0, this attribute will be the tuple (1, 0).
251	262	Lower HTTP protocol versions are not explicitly supported."""
252
	263
253	264	params = {}
254	265	"""
255	266	A dict which combines query string (GET) and request entity (POST)
256	267	variables. This is populated in two stages: GET params are added
257	268	before the 'on_start_resource' hook, and POST params are added
258	269	between the 'before_request_body' and 'before_handler' hooks."""
259
	270
260	271	# Message attributes
261	272	header_list = []
262	273	"""
263	274	A list of the HTTP request headers as (name, value) tuples.
264	275	In general, you should use request.headers (a dict) instead."""
265
	276
266	277	headers = httputil.HeaderMap()
267	278	"""
268	279	A dict-like object containing the request headers. Keys are header

271	282	headers['content-type'] refer to the same value. Values are header
272	283	values (decoded according to :rfc:`2047` if necessary). See also:
273	284	httputil.HeaderMap, httputil.HeaderElement."""
274
	285
275	286	cookie = SimpleCookie()
276	287	"""See help(Cookie)."""
277
	288
278	289	rfile = None
279	290	"""
280	291	If the request included an entity (body), it will be available

282	293	be read for you between the 'before_request_body' hook and the
283	294	'before_handler' hook, and the resulting string is placed into
284	295	either request.params or the request.body attribute.
285
	296
286	297	You may disable the automatic consumption of the rfile by setting
287	298	request.process_request_body to False, either in config for the desired
288	299	path, or in an 'on_start_resource' or 'before_request_body' hook.
289
	300
290	301	WARNING: In almost every case, you should not attempt to read from the
291	302	rfile stream after CherryPy's automatic mechanism has read it. If you
292	303	turn off the automatic parsing of rfile, you should read exactly the

294	305	Ignoring either of these warnings may result in a hung request thread
295	306	or in corruption of the next (pipelined) request.
296	307	"""
297
	308
298	309	process_request_body = True
299	310	"""
300	311	If True, the rfile (if any) is automatically read and parsed,
301	312	and the result placed into request.params or request.body."""
302
	313
303	314	methods_with_bodies = ("POST", "PUT")
304	315	"""
305	316	A sequence of HTTP methods for which CherryPy will automatically
306		attempt to read a body from the rfile."""
307
	317	attempt to read a body from the rfile. If you are going to change
	318	this property, modify it on the configuration (recommended)
	319	or on the "hook point" `on_start_resource`.
	320	"""
	321
308	322	body = None
309	323	"""
310	324	If the request Content-Type is 'application/x-www-form-urlencoded'

312	326	of :class:`RequestBody<cherrypy._cpreqbody.RequestBody>` (which you
313	327	can .read()); this value is set between the 'before_request_body' and
314	328	'before_handler' hooks (assuming that process_request_body is True)."""
315
	329
316	330	# Dispatch attributes
317	331	dispatch = cherrypy.dispatch.Dispatcher()
318	332	"""

321	335	request attributes, and the application architecture. The core
322	336	calls the dispatcher as early as possible, passing it a 'path_info'
323	337	argument.
324
	338
325	339	The default dispatcher discovers the page handler by matching path_info
326	340	to a hierarchical arrangement of objects, starting at request.app.root.
327	341	See help(cherrypy.dispatch) for more information."""
328
	342
329	343	script_name = ""
330	344	"""
331	345	The 'mount point' of the application which is handling this request.
332
	346
333	347	This attribute MUST NOT end in a slash. If the script_name refers to
334	348	the root of the URI, it MUST be an empty string (not "/").
335	349	"""
336
	350
337	351	path_info = "/"
338	352	"""
339	353	The 'relative path' portion of the Request-URI. This is relative

345	359	When authentication is used during the request processing this is
346	360	set to 'False' if it failed and to the 'username' value if it succeeded.
347	361	The default 'None' implies that no authentication happened."""
348
	362
349	363	# Note that cherrypy.url uses "if request.app:" to determine whether
350	364	# the call is during a real HTTP request or not. So leave this None.
351	365	app = None
352	366	"""The cherrypy.Application object which is handling this request."""
353
	367
354	368	handler = None
355	369	"""
356	370	The function, method, or other callable which CherryPy will call to

359	373	By default, the handler is discovered by walking a tree of objects
360	374	starting at request.app.root, and is then passed all HTTP params
361	375	(from the query string and POST body) as keyword arguments."""
362
	376
363	377	toolmaps = {}
364	378	"""
365	379	A nested dict of all Toolboxes and Tools in effect for this request,
366	380	of the form: {Toolbox.namespace: {Tool.name: config dict}}."""
367
	381
368	382	config = None
369	383	"""
370	384	A flat dict of all configuration entries which apply to the

374	388	effect for this request; by default, handler config can be attached
375	389	anywhere in the tree between request.app.root and the final handler,
376	390	and inherits downward)."""
377
	391
378	392	is_index = None
379	393	"""
380	394	This will be True if the current request is mapped to an 'index'

382	396	a slash). The value may be used to automatically redirect the
383	397	user-agent to a 'more canonical' URL which either adds or removes
384	398	the trailing slash. See cherrypy.tools.trailing_slash."""
385
	399
386	400	hooks = HookMap(hookpoints)
387	401	"""
388	402	A HookMap (dict-like object) of the form: {hookpoint: [hook, ...]}.

391	405	The list of hooks is generally populated as early as possible (mostly
392	406	from Tools specified in config), but may be extended at any time.
393	407	See also: _cprequest.Hook, _cprequest.HookMap, and cherrypy.tools."""
394
	408
395	409	error_response = cherrypy.HTTPError(500).set_response
396	410	"""
397	411	The no-arg callable which will handle unexpected, untrapped errors

401	415	via request.error_page or by overriding HTTPError.set_response).
402	416	By default, error_response uses HTTPError(500) to return a generic
403	417	error response to the user-agent."""
404
	418
405	419	error_page = {}
406	420	"""
407	421	A dict of {error code: response filename or callable} pairs.
408
	422
409	423	The error code must be an int representing a given HTTP error code,
410	424	or the string 'default', which will be used if no matching entry
411	425	is found for a given numeric code.
412
	426
413	427	If a filename is provided, the file should contain a Python string-
414		formatting template, and can expect by default to receive format
	428	formatting template, and can expect by default to receive format
415	429	values with the mapping keys %(status)s, %(message)s, %(traceback)s,
416	430	and %(version)s. The set of format mappings can be extended by
417	431	overriding HTTPError.set_response.
418
	432
419	433	If a callable is provided, it will be called by default with keyword
420	434	arguments 'status', 'message', 'traceback', and 'version', as for a
421		string-formatting template. The callable must return a string or iterable of
422		strings which will be set to response.body. It may also override headers or
423		perform any other processing.
424
	435	string-formatting template. The callable must return a string or
	436	iterable of strings which will be set to response.body. It may also
	437	override headers or perform any other processing.
	438
425	439	If no entry is given for an error code, and no 'default' entry exists,
426	440	a default template will be used.
427	441	"""
428
	442
429	443	show_tracebacks = True
430	444	"""
431	445	If True, unexpected errors encountered during request processing will

435	449	"""
436	450	If True, mismatched parameters encountered during PageHandler invocation
437	451	processing will be included in the response body."""
438
	452
439	453	throws = (KeyboardInterrupt, SystemExit, cherrypy.InternalRedirect)
440	454	"""The sequence of exceptions which Request.run does not trap."""
441
	455
442	456	throw_errors = False
443	457	"""
444	458	If True, Request.run will not trap any errors (except HTTPRedirect and
445	459	HTTPError, which are more properly called 'exceptions', not errors)."""
446
	460
447	461	closed = False
448	462	"""True once the close method has been called, False otherwise."""
449
	463
450	464	stage = None
451	465	"""
452	466	A string containing the stage reached in the request-handling process.
453	467	This is useful when debugging a live server with hung requests."""
454
	468
455	469	namespaces = _cpconfig.NamespaceSet(
456	470	**{"hooks": hooks_namespace,
457	471	"request": request_namespace,

459	473	"error_page": error_page_namespace,
460	474	"tools": cherrypy.tools,
461	475	})
462
	476
463	477	def __init__(self, local_host, remote_host, scheme="http",
464	478	server_protocol="HTTP/1.1"):
465	479	"""Populate a new Request object.
466
	480
467	481	local_host should be an httputil.Host object with the server info.
468	482	remote_host should be an httputil.Host object with the client info.
469	483	scheme should be a string, either "http" or "https".

472	486	self.remote = remote_host
473	487	self.scheme = scheme
474	488	self.server_protocol = server_protocol
475
	489
476	490	self.closed = False
477
	491
478	492	# Put a copy of the class error_page into self.
479	493	self.error_page = self.error_page.copy()
480
	494
481	495	# Put a copy of the class namespaces into self.
482	496	self.namespaces = self.namespaces.copy()
483
	497
484	498	self.stage = None
485
	499
486	500	def close(self):
487	501	"""Run cleanup code. (Core)"""
488	502	if not self.closed:

490	504	self.stage = 'on_end_request'
491	505	self.hooks.run('on_end_request')
492	506	self.stage = 'close'
493
	507
494	508	def run(self, method, path, query_string, req_protocol, headers, rfile):
495	509	r"""Process the Request. (Core)
496
	510
497	511	method, path, query_string, and req_protocol should be pulled directly
498	512	from the Request-Line (e.g. "GET /path?key=val HTTP/1.0").
499
	513
500	514	path
501	515	This should be %XX-unquoted, but query_string should not be.
502
	516
503	517	When using Python 2, they both MUST be byte strings,
504	518	not unicode strings.
505
	519
506	520	When using Python 3, they both MUST be unicode strings,
507	521	not byte strings, and preferably not bytes \x00-\xFF
508	522	disguised as unicode.
509
	523
510	524	headers
511	525	A list of (name, value) tuples.
512
	526
513	527	rfile
514	528	A file-like object containing the HTTP request entity.
515
	529
516	530	When run() is done, the returned object should have 3 attributes:
517
	531
518	532	* status, e.g. "200 OK"
519	533	* header_list, a list of (name, value) tuples
520	534	* body, an iterable yielding strings
521
	535
522	536	Consumer code (HTTP servers) should then access these response
523	537	attributes to build the outbound stream.
524
	538
525	539	"""
526	540	response = cherrypy.serving.response
527	541	self.stage = 'run'
528	542	try:
529	543	self.error_response = cherrypy.HTTPError(500).set_response
530
	544
531	545	self.method = method
532	546	path = path or "/"
533	547	self.query_string = query_string or ''
534	548	self.params = {}
535
	549
536	550	# Compare request and server HTTP protocol versions, in case our
537	551	# server does not support the requested protocol. Limit our output
538	552	# to min(req, server). We want the following output:

549	563	sp = int(self.server_protocol[5]), int(self.server_protocol[7])
550	564	self.protocol = min(rp, sp)
551	565	response.headers.protocol = self.protocol
552
	566
553	567	# Rebuild first line of the request (e.g. "GET /path HTTP/1.0").
554	568	url = path
555	569	if query_string:
556	570	url += '?' + query_string
557	571	self.request_line = '%s %s %s' % (method, url, req_protocol)
558
	572
559	573	self.header_list = list(headers)
560	574	self.headers = httputil.HeaderMap()
561
	575
562	576	self.rfile = rfile
563	577	self.body = None
564
	578
565	579	self.cookie = SimpleCookie()
566	580	self.handler = None
567
	581
568	582	# path_info should be the path from the
569	583	# app root (script_name) to the handler.
570	584	self.script_name = self.app.script_name
571	585	self.path_info = pi = path[len(self.script_name):]
572
	586
573	587	self.stage = 'respond'
574	588	self.respond(pi)
575
	589
576	590	except self.throws:
577	591	raise
578	592	except:

588	602	body = ""
589	603	r = bare_error(body)
590	604	response.output_status, response.header_list, response.body = r
591
	605
592	606	if self.method == "HEAD":
593	607	# HEAD requests MUST NOT return a message-body in the response.
594	608	response.body = []
595
	609
596	610	try:
597	611	cherrypy.log.access()
598	612	except:
599	613	cherrypy.log.error(traceback=True)
600
	614
601	615	if response.timed_out:
602	616	raise cherrypy.TimeoutError()
603
	617
604	618	return response
605
	619
606	620	# Uncomment for stage debugging
607	621	# stage = property(lambda self: self._stage, lambda self, v: print(v))
608
	622
609	623	def respond(self, path_info):
610	624	"""Generate a response for the resource at self.path_info. (Core)"""
611	625	response = cherrypy.serving.response

614	628	try:
615	629	if self.app is None:
616	630	raise cherrypy.NotFound()
617
	631
618	632	# Get the 'Host' header, so we can HTTPRedirect properly.
619	633	self.stage = 'process_headers'
620	634	self.process_headers()
621
	635
622	636	# Make a copy of the class hooks
623	637	self.hooks = self.__class__.hooks.copy()
624	638	self.toolmaps = {}
625
	639
626	640	self.stage = 'get_resource'
627	641	self.get_resource(path_info)
628
	642
629	643	self.body = _cpreqbody.RequestBody(
630	644	self.rfile, self.headers, request_params=self.params)
631
	645
632	646	self.namespaces(self.config)
633
	647
634	648	self.stage = 'on_start_resource'
635	649	self.hooks.run('on_start_resource')
636
	650
637	651	# Parse the querystring
638	652	self.stage = 'process_query_string'
639	653	self.process_query_string()
640
	654
641	655	# Process the body
642	656	if self.process_request_body:
643	657	if self.method not in self.methods_with_bodies:

646	660	self.hooks.run('before_request_body')
647	661	if self.process_request_body:
648	662	self.body.process()
649
	663
650	664	# Run the handler
651	665	self.stage = 'before_handler'
652	666	self.hooks.run('before_handler')
653	667	if self.handler:
654	668	self.stage = 'handler'
655	669	response.body = self.handler()
656
	670
657	671	# Finalize
658	672	self.stage = 'before_finalize'
659	673	self.hooks.run('before_finalize')

673	687	if self.throw_errors:
674	688	raise
675	689	self.handle_error()
676
	690
677	691	def process_query_string(self):
678	692	"""Parse the query string into Python structures. (Core)"""
679	693	try:

684	698	404, "The given query string could not be processed. Query "
685	699	"strings for this resource must be encoded with %r." %
686	700	self.query_string_encoding)
687
	701
688	702	# Python 2 only: keyword arguments must be byte strings (type 'str').
689	703	if not py3k:
690	704	for key, value in p.items():

692	706	del p[key]
693	707	p[key.encode(self.query_string_encoding)] = value
694	708	self.params.update(p)
695
	709
696	710	def process_headers(self):
697	711	"""Parse HTTP header data into Python structures. (Core)"""
698	712	# Process the headers into self.headers

702	716	# so title doesn't have to be called twice.
703	717	name = name.title()
704	718	value = value.strip()
705
706		# Warning: if there is more than one header entry for cookies (AFAIK,
707		# only Konqueror does that), only the last one will remain in headers
708		# (but they will be correctly stored in request.cookie).
	719
	720	# Warning: if there is more than one header entry for cookies
	721	# (AFAIK, only Konqueror does that), only the last one will
	722	# remain in headers (but they will be correctly stored in
	723	# request.cookie).
709	724	if "=?" in value:
710	725	dict.__setitem__(headers, name, httputil.decode_TEXT(value))
711	726	else:
712	727	dict.__setitem__(headers, name, value)
713
	728
714	729	# Handle cookies differently because on Konqueror, multiple
715	730	# cookies come on different lines with the same key
716	731	if name == 'Cookie':

719	734	except CookieError:
720	735	msg = "Illegal cookie name %s" % value.split('=')[0]
721	736	raise cherrypy.HTTPError(400, msg)
722
	737
723	738	if not dict.__contains__(headers, 'Host'):
724	739	# All Internet-based HTTP/1.1 servers MUST respond with a 400
725	740	# (Bad Request) status code to any HTTP/1.1 request message

731	746	if not host:
732	747	host = self.local.name or self.local.ip
733	748	self.base = "%s://%s" % (self.scheme, host)
734
	749
735	750	def get_resource(self, path):
736	751	"""Call a dispatcher (which sets self.handler and .config). (Core)"""
737	752	# First, see if there is a custom dispatch at this URI. Custom
738	753	# dispatchers can only be specified in app.config, not in _cp_config
739	754	# (since custom dispatchers may not even have an app.root).
740		dispatch = self.app.find_config(path, "request.dispatch", self.dispatch)
741
	755	dispatch = self.app.find_config(
	756	path, "request.dispatch", self.dispatch)
	757
742	758	# dispatch() should set self.handler and self.config
743	759	dispatch(path)
744
	760
745	761	def handle_error(self):
746	762	"""Handle the last unanticipated exception. (Core)"""
747	763	try:

754	770	inst = sys.exc_info()[1]
755	771	inst.set_response()
756	772	cherrypy.serving.response.finalize()
757
	773
758	774	# ------------------------- Properties ------------------------- #
759
	775
760	776	def _get_body_params(self):
761	777	warnings.warn(
762		"body_params is deprecated in CherryPy 3.2, will be removed in "
763		"CherryPy 3.3.",
764		DeprecationWarning
765		)
	778	"body_params is deprecated in CherryPy 3.2, will be removed in "
	779	"CherryPy 3.3.",
	780	DeprecationWarning
	781	)
766	782	return self.body.params
767	783	body_params = property(_get_body_params,
768		doc= """
	784	doc="""
769	785	If the request Content-Type is 'application/x-www-form-urlencoded' or
770	786	multipart, this will be a dict of the params pulled from the entity
771	787	body; that is, it will be the portion of request.params that come

773	789	can be sent with various HTTP method verbs). This value is set between
774	790	the 'before_request_body' and 'before_handler' hooks (assuming that
775	791	process_request_body is True).
776
	792
777	793	Deprecated in 3.2, will be removed for 3.3 in favor of
778	794	:attr:`request.body.params<cherrypy._cprequest.RequestBody.params>`.""")
779	795
780	796
781	797	class ResponseBody(object):
	798
782	799	"""The body of the HTTP response (the response entity)."""
783
	800
784	801	if py3k:
785	802	unicode_err = ("Page handlers MUST return bytes. Use tools.encode "
786	803	"if you wish to return unicode.")
787
	804
788	805	def __get__(self, obj, objclass=None):
789	806	if obj is None:
790	807	# When calling on the class instead of an instance...
791	808	return self
792	809	else:
793	810	return obj._body
794
	811
795	812	def __set__(self, obj, value):
796	813	# Convert the given value to an iterable object.
797	814	if py3k and isinstance(value, str):
798	815	raise ValueError(self.unicode_err)
799
	816
800	817	if isinstance(value, basestring):
801	818	# strings get wrapped in a list because iterating over a single
802	819	# item list is much faster than iterating over every character

807	824	# [''] doesn't evaluate to False, so replace it with [].
808	825	value = []
809	826	elif py3k and isinstance(value, list):
810		# every item in a list must be bytes...
	827	# every item in a list must be bytes...
811	828	for i, item in enumerate(value):
812	829	if isinstance(item, str):
813	830	raise ValueError(self.unicode_err)

821	838
822	839
823	840	class Response(object):
	841
824	842	"""An HTTP Response, including status, headers, and body."""
825
	843
826	844	status = ""
827	845	"""The HTTP Status-Code and Reason-Phrase."""
828
	846
829	847	header_list = []
830	848	"""
831	849	A list of the HTTP response headers as (name, value) tuples.
832	850	In general, you should use response.headers (a dict) instead. This
833	851	attribute is generated from response.headers and is not valid until
834	852	after the finalize phase."""
835
	853
836	854	headers = httputil.HeaderMap()
837	855	"""
838	856	A dict-like object containing the response headers. Keys are header

840	858	a case-insensitive manner. That is, headers['Content-Type'] and
841	859	headers['content-type'] refer to the same value. Values are header
842	860	values (decoded according to :rfc:`2047` if necessary).
843
	861
844	862	.. seealso:: classes :class:`HeaderMap`, :class:`HeaderElement`
845	863	"""
846
	864
847	865	cookie = SimpleCookie()
848	866	"""See help(Cookie)."""
849
	867
850	868	body = ResponseBody()
851	869	"""The body (entity) of the HTTP response."""
852
	870
853	871	time = None
854	872	"""The value of time.time() when created. Use in HTTP dates."""
855
	873
856	874	timeout = 300
857	875	"""Seconds after which the response will be aborted."""
858
	876
859	877	timed_out = False
860	878	"""
861	879	Flag to indicate the response should be aborted, because it has
862	880	exceeded its timeout."""
863
	881
864	882	stream = False
865	883	"""If False, buffer the response body."""
866
	884
867	885	def __init__(self):
868	886	self.status = None
869	887	self.header_list = None
870	888	self._body = []
871	889	self.time = time.time()
872
	890
873	891	self.headers = httputil.HeaderMap()
874	892	# Since we know all our keys are titled strings, we can
875	893	# bypass HeaderMap.update and get a big speed boost.

879	897	"Date": httputil.HTTPDate(self.time),
880	898	})
881	899	self.cookie = SimpleCookie()
882
	900
883	901	def collapse_body(self):
884	902	"""Collapse self.body to a single string; replace it and return it."""
885	903	if isinstance(self.body, basestring):
886	904	return self.body
887
	905
888	906	newbody = []
889	907	for chunk in self.body:
890	908	if py3k and not isinstance(chunk, bytes):
891		raise TypeError("Chunk %s is not of type 'bytes'." % repr(chunk))
	909	raise TypeError("Chunk %s is not of type 'bytes'." %
	910	repr(chunk))
892	911	newbody.append(chunk)
893	912	newbody = ntob('').join(newbody)
894
	913
895	914	self.body = newbody
896	915	return newbody
897
	916
898	917	def finalize(self):
899	918	"""Transform headers (and cookies) into self.header_list. (Core)"""
900	919	try:
901	920	code, reason, _ = httputil.valid_status(self.status)
902	921	except ValueError:
903	922	raise cherrypy.HTTPError(500, sys.exc_info()[1].args[0])
904
	923
905	924	headers = self.headers
906
	925
907	926	self.status = "%s %s" % (code, reason)
908		self.output_status = ntob(str(code), 'ascii') + ntob(" ") + headers.encode(reason)
909
	927	self.output_status = ntob(str(code), 'ascii') + \
	928	ntob(" ") + headers.encode(reason)
	929
910	930	if self.stream:
911	931	# The upshot: wsgiserver will chunk the response if
912	932	# you pop Content-Length (or set it explicitly to None).

925	945	if dict.get(headers, 'Content-Length') is None:
926	946	content = self.collapse_body()
927	947	dict.__setitem__(headers, 'Content-Length', len(content))
928
	948
929	949	# Transform our header dict into a list of tuples.
930	950	self.header_list = h = headers.output()
931
	951
932	952	cookie = self.cookie.output()
933	953	if cookie:
934	954	for line in cookie.split("\n"):

941	961	if isinstance(value, unicodestr):
942	962	value = headers.encode(value)
943	963	h.append((name, value))
944
	964
945	965	def check_timeout(self):
946	966	"""If now > self.time + self.timeout, set self.timed_out.
947
	967
948	968	This purposefully sets a flag, rather than raising an error,
949	969	so that a monitor thread can interrupt the Response thread.
950	970	"""
951	971	if time.time() > self.time + self.timeout:
952	972	self.timed_out = True
953
954
955

+63

-50

cherrypy/_cpserver.py less more

11	11
12	12
13	13	class Server(ServerAdapter):
	14
14	15	"""An adapter for an HTTP server.
15
	16
16	17	You can set attributes (like socket_host and socket_port)
17	18	on this object (which is probably cherrypy.server), and call
18	19	quickstart. For example::
19
	20
20	21	cherrypy.server.socket_port = 80
21	22	cherrypy.quickstart()
22	23	"""
23
	24
24	25	socket_port = 8080
25	26	"""The TCP port on which to listen for connections."""
26
	27
27	28	_socket_host = '127.0.0.1'
	29
28	30	def _get_socket_host(self):
29	31	return self._socket_host
	32
30	33	def _set_socket_host(self, value):
31	34	if value == '':
32	35	raise ValueError("The empty string ('') is not an allowed value. "
33	36	"Use '0.0.0.0' instead to listen on all active "
34	37	"interfaces (INADDR_ANY).")
35	38	self._socket_host = value
36		socket_host = property(_get_socket_host, _set_socket_host,
	39	socket_host = property(
	40	_get_socket_host,
	41	_set_socket_host,
37	42	doc="""The hostname or IP address on which to listen for connections.
38
	43
39	44	Host values may be any IPv4 or IPv6 address, or any valid hostname.
40	45	The string 'localhost' is a synonym for '127.0.0.1' (or '::1', if
41	46	your hosts file prefers IPv6). The string '0.0.0.0' is a special
42	47	IPv4 entry meaning "any active interface" (INADDR_ANY), and '::'
43	48	is the similar IN6ADDR_ANY for IPv6. The empty string or None are
44	49	not allowed.""")
45
	50
46	51	socket_file = None
47	52	"""If given, the name of the UNIX socket to use instead of TCP/IP.
48
	53
49	54	When this option is not None, the `socket_host` and `socket_port` options
50	55	are ignored."""
51
	56
52	57	socket_queue_size = 5
53	58	"""The 'backlog' argument to socket.listen(); specifies the maximum number
54	59	of queued connections (default 5)."""
55
	60
56	61	socket_timeout = 10
57	62	"""The timeout in seconds for accepted connections (default 10)."""
58
	63
59	64	shutdown_timeout = 5
60	65	"""The time to wait for HTTP worker threads to clean up."""
61
	66
62	67	protocol_version = 'HTTP/1.1'
63	68	"""The version string to write in the Status-Line of all HTTP responses,
64	69	for example, "HTTP/1.1" (the default). Depending on the HTTP server used,
65	70	this should also limit the supported features used in the response."""
66
	71
67	72	thread_pool = 10
68	73	"""The number of worker threads to start up in the pool."""
69
	74
70	75	thread_pool_max = -1
71		"""The maximum size of the worker-thread pool. Use -1 to indicate no limit."""
72
	76	"""The maximum size of the worker-thread pool. Use -1 to indicate no limit.
	77	"""
	78
73	79	max_request_header_size = 500 * 1024
74		"""The maximum number of bytes allowable in the request headers. If exceeded,
75		the HTTP server should return "413 Request Entity Too Large"."""
76
	80	"""The maximum number of bytes allowable in the request headers.
	81	If exceeded, the HTTP server should return "413 Request Entity Too Large".
	82	"""
	83
77	84	max_request_body_size = 100 * 1024 * 1024
78	85	"""The maximum number of bytes allowable in the request body. If exceeded,
79	86	the HTTP server should return "413 Request Entity Too Large"."""
80
	87
81	88	instance = None
82	89	"""If not None, this should be an HTTP server instance (such as
83	90	CPWSGIServer) which cherrypy.server will control. Use this when you need
84	91	more control over object instantiation than is available in the various
85	92	configuration options."""
86
	93
87	94	ssl_context = None
88	95	"""When using PyOpenSSL, an instance of SSL.Context."""
89
	96
90	97	ssl_certificate = None
91	98	"""The filename of the SSL certificate to use."""
92
	99
93	100	ssl_certificate_chain = None
94	101	"""When using PyOpenSSL, the certificate chain to pass to
95	102	Context.load_verify_locations."""
96
	103
97	104	ssl_private_key = None
98	105	"""The filename of the private key to use with SSL."""
99
	106
100	107	if py3k:
101	108	ssl_module = 'builtin'
102		"""The name of a registered SSL adaptation module to use with the builtin
103		WSGI server. Builtin options are: 'builtin' (to use the SSL library built
104		into recent versions of Python). You may also register your
105		own classes in the wsgiserver.ssl_adapters dict."""
	109	"""The name of a registered SSL adaptation module to use with
	110	the builtin WSGI server. Builtin options are: 'builtin' (to
	111	use the SSL library built into recent versions of Python).
	112	You may also register your own classes in the
	113	wsgiserver.ssl_adapters dict."""
106	114	else:
107	115	ssl_module = 'pyopenssl'
108		"""The name of a registered SSL adaptation module to use with the builtin
109		WSGI server. Builtin options are 'builtin' (to use the SSL library built
110		into recent versions of Python) and 'pyopenssl' (to use the PyOpenSSL
111		project, which you must install separately). You may also register your
112		own classes in the wsgiserver.ssl_adapters dict."""
113
	116	"""The name of a registered SSL adaptation module to use with the
	117	builtin WSGI server. Builtin options are 'builtin' (to use the SSL
	118	library built into recent versions of Python) and 'pyopenssl' (to
	119	use the PyOpenSSL project, which you must install separately). You
	120	may also register your own classes in the wsgiserver.ssl_adapters
	121	dict."""
	122
114	123	statistics = False
115	124	"""Turns statistics-gathering on or off for aware HTTP servers."""
116
	125
117	126	nodelay = True
118	127	"""If True (the default since 3.1), sets the TCP_NODELAY socket option."""
119
	128
120	129	wsgi_version = (1, 0)
121	130	"""The WSGI version tuple to use with the builtin WSGI server.
122	131	The provided options are (1, 0) [which includes support for PEP 3333,

124	133	wsgi.version (1, 0)] and ('u', 0), an experimental unicode version.
125	134	You may create and register your own experimental versions of the WSGI
126	135	protocol by adding custom classes to the wsgiserver.wsgi_gateways dict."""
127
	136
128	137	def __init__(self):
129	138	self.bus = cherrypy.engine
130	139	self.httpserver = None
131	140	self.interrupt = None
132	141	self.running = False
133
	142
134	143	def httpserver_from_self(self, httpserver=None):
135	144	"""Return a (httpserver, bind_addr) pair based on self attributes."""
136	145	if httpserver is None:

142	151	# Is anyone using this? Can I add an arg?
143	152	httpserver = attributes(httpserver)(self)
144	153	return httpserver, self.bind_addr
145
	154
146	155	def start(self):
147	156	"""Start the HTTP server."""
148	157	if not self.httpserver:
149	158	self.httpserver, self.bind_addr = self.httpserver_from_self()
150	159	ServerAdapter.start(self)
151	160	start.priority = 75
152
	161
153	162	def _get_bind_addr(self):
154	163	if self.socket_file:
155	164	return self.socket_file
156	165	if self.socket_host is None and self.socket_port is None:
157	166	return None
158	167	return (self.socket_host, self.socket_port)
	168
159	169	def _set_bind_addr(self, value):
160	170	if value is None:
161	171	self.socket_file = None

173	183	raise ValueError("bind_addr must be a (host, port) tuple "
174	184	"(for TCP sockets) or a string (for Unix "
175	185	"domain sockets), not %r" % value)
176		bind_addr = property(_get_bind_addr, _set_bind_addr,
177		doc='A (host, port) tuple for TCP sockets or a str for Unix domain sockets.')
178
	186	bind_addr = property(
	187	_get_bind_addr,
	188	_set_bind_addr,
	189	doc='A (host, port) tuple for TCP sockets or '
	190	'a str for Unix domain sockets.')
	191
179	192	def base(self):
180		"""Return the base (scheme://host[:port] or sock file) for this server."""
	193	"""Return the base (scheme://host[:port] or sock file) for this server.
	194	"""
181	195	if self.socket_file:
182	196	return self.socket_file
183
	197
184	198	host = self.socket_host
185	199	if host in ('0.0.0.0', '::'):
186	200	# 0.0.0.0 is INADDR_ANY and :: is IN6ADDR_ANY.

188	202	# safest thing to spit out in a URL.
189	203	import socket
190	204	host = socket.gethostname()
191
	205
192	206	port = self.socket_port
193
	207
194	208	if self.ssl_certificate:
195	209	scheme = "https"
196	210	if port != 443:

199	213	scheme = "http"
200	214	if port != 80:
201	215	host += ":%s" % port
202
	216
203	217	return "%s://%s" % (scheme, host)
204

-2

cherrypy/_cpthreadinglocal.py less more

136	136
137	137	# Threading import is at end
138	138
	139
139	140	class _localbase(object):
140	141	__slots__ = '_local__key', '_local__args', '_local__lock'
141	142

156	157	currentThread().__dict__[key] = dict
157	158
158	159	return self
	160
159	161
160	162	def _patch(self):
161	163	key = object.__getattribute__(self, '_local__key')

174	176	else:
175	177	object.__setattr__(self, '__dict__', d)
176	178
	179
177	180	class local(_localbase):
178	181
179	182	def __getattribute__(self, name):

203	206	finally:
204	207	lock.release()
205	208
206
207	209	def __del__():
208	210	threading_enumerate = enumerate
209	211	__getattribute__ = object.__getattribute__

230	232	try:
231	233	del __dict__[key]
232	234	except KeyError:
233		pass # didn't have anything in this thread
	235	pass # didn't have anything in this thread
234	236
235	237	return __del__
236	238	__del__ = __del__()

+108

-89

cherrypy/_cptools.py less more

1	1
2	2	Tools are usually designed to be used in a variety of ways (although some
3	3	may only offer one if they choose):
4
	4
5	5	Library calls
6	6	All tools are callables that can be used wherever needed.
7	7	The arguments are straightforward and should be detailed within the
8	8	docstring.
9
	9
10	10	Function decorators
11	11	All tools, when called, may be used as decorators which configure
12	12	individual CherryPy page handlers (methods on the CherryPy tree).
13	13	That is, "@tools.anytool()" should "turn on" the tool via the
14	14	decorated function's _cp_config attribute.
15
	15
16	16	CherryPy config
17	17	If a tool exposes a "_setup" callable, it will be called
18	18	once per Request (if the feature is "turned on" via config).

42	42	return co.co_varnames[:co.co_argcount]
43	43
44	44
45		_attr_error = ("CherryPy Tools cannot be turned on directly. Instead, turn them "
46		"on via config, or use them as decorators on your page handlers.")
	45	_attr_error = (
	46	"CherryPy Tools cannot be turned on directly. Instead, turn them "
	47	"on via config, or use them as decorators on your page handlers."
	48	)
	49
47	50
48	51	class Tool(object):
	52
49	53	"""A registered function for use with CherryPy request-processing hooks.
50
	54
51	55	help(tool.callable) should give you more information about this Tool.
52	56	"""
53
	57
54	58	namespace = "tools"
55
	59
56	60	def __init__(self, point, callable, name=None, priority=50):
57	61	self._point = point
58	62	self.callable = callable

60	64	self._priority = priority
61	65	self.__doc__ = self.callable.__doc__
62	66	self._setargs()
63
	67
64	68	def _get_on(self):
65	69	raise AttributeError(_attr_error)
	70
66	71	def _set_on(self, value):
67	72	raise AttributeError(_attr_error)
68	73	on = property(_get_on, _set_on)
69
	74
70	75	def _setargs(self):
71	76	"""Copy func parameter names to obj attributes."""
72	77	try:

85	90	# but if we trap it here it doesn't prevent CP from working.
86	91	except IndexError:
87	92	pass
88
	93
89	94	def _merged_args(self, d=None):
90	95	"""Return a dict of configuration entries for this Tool."""
91	96	if d:
92	97	conf = d.copy()
93	98	else:
94	99	conf = {}
95
	100
96	101	tm = cherrypy.serving.request.toolmaps[self.namespace]
97	102	if self._name in tm:
98	103	conf.update(tm[self._name])
99
	104
100	105	if "on" in conf:
101	106	del conf["on"]
102
	107
103	108	return conf
104
	109
105	110	def __call__(self, args, *kwargs):
106	111	"""Compile-time decorator (turn on the tool in config).
107
	112
108	113	For example::
109
	114
110	115	@tools.proxy()
111	116	def whats_my_base(self):
112	117	return cherrypy.request.base

116	121	raise TypeError("The %r Tool does not accept positional "
117	122	"arguments; you must use keyword arguments."
118	123	% self._name)
	124
119	125	def tool_decorator(f):
120	126	if not hasattr(f, "_cp_config"):
121	127	f._cp_config = {}

125	131	f._cp_config[subspace + k] = v
126	132	return f
127	133	return tool_decorator
128
	134
129	135	def _setup(self):
130	136	"""Hook this tool into cherrypy.request.
131
	137
132	138	The standard CherryPy request object will automatically call this
133	139	method when the tool is "turned on" in config.
134	140	"""

141	147
142	148
143	149	class HandlerTool(Tool):
	150
144	151	"""Tool which is called 'before main', that may skip normal handlers.
145
	152
146	153	If the tool successfully handles the request (by setting response.body),
147	154	if should return True. This will cause CherryPy to skip any 'normal' page
148	155	handler. If the tool did not handle the request, it should return False

150	157	tool is declared AS a page handler (see the 'handler' method), returning
151	158	False will raise NotFound.
152	159	"""
153
	160
154	161	def __init__(self, callable, name=None):
155	162	Tool.__init__(self, 'before_handler', callable, name)
156
	163
157	164	def handler(self, args, *kwargs):
158	165	"""Use this tool as a CherryPy page handler.
159
	166
160	167	For example::
161
	168
162	169	class Root:
163	170	nav = tools.staticdir.handler(section="/nav", dir="nav",
164	171	root=absDir)

170	177	return cherrypy.serving.response.body
171	178	handle_func.exposed = True
172	179	return handle_func
173
	180
174	181	def _wrapper(self, **kwargs):
175	182	if self.callable(**kwargs):
176	183	cherrypy.serving.request.handler = None
177
	184
178	185	def _setup(self):
179	186	"""Hook this tool into cherrypy.request.
180
	187
181	188	The standard CherryPy request object will automatically call this
182	189	method when the tool is "turned on" in config.
183	190	"""

190	197
191	198
192	199	class HandlerWrapperTool(Tool):
	200
193	201	"""Tool which wraps request.handler in a provided wrapper function.
194
	202
195	203	The 'newhandler' arg must be a handler wrapper function that takes a
196	204	'next_handler' argument, plus ``args`` and ``*kwargs``. Like all
197	205	page handler
198	206	functions, it must return an iterable for use as cherrypy.response.body.
199
	207
200	208	For example, to allow your 'inner' page handlers to return dicts
201	209	which then get interpolated into a template::
202
	210
203	211	def interpolator(next_handler, args, *kwargs):
204	212	filename = cherrypy.request.config.get('template')
205	213	cherrypy.response.template = env.get_template(filename)

207	215	return cherrypy.response.template.render(**response_dict)
208	216	cherrypy.tools.jinja = HandlerWrapperTool(interpolator)
209	217	"""
210
211		def __init__(self, newhandler, point='before_handler', name=None, priority=50):
	218
	219	def __init__(self, newhandler, point='before_handler', name=None,
	220	priority=50):
212	221	self.newhandler = newhandler
213	222	self._point = point
214	223	self._name = name
215	224	self._priority = priority
216
	225
217	226	def callable(self, debug=False):
218	227	innerfunc = cherrypy.serving.request.handler
	228
219	229	def wrap(args, *kwargs):
220	230	return self.newhandler(innerfunc, args, *kwargs)
221	231	cherrypy.serving.request.handler = wrap
222	232
223	233
224	234	class ErrorTool(Tool):
	235
225	236	"""Tool which is used to replace the default request.error_response."""
226
	237
227	238	def __init__(self, callable, name=None):
228	239	Tool.__init__(self, None, callable, name)
229
	240
230	241	def _wrapper(self):
231	242	self.callable(**self._merged_args())
232
	243
233	244	def _setup(self):
234	245	"""Hook this tool into cherrypy.request.
235
	246
236	247	The standard CherryPy request object will automatically call this
237	248	method when the tool is "turned on" in config.
238	249	"""

248	259
249	260
250	261	class SessionTool(Tool):
	262
251	263	"""Session Tool for CherryPy.
252
	264
253	265	sessions.locking
254	266	When 'implicit' (the default), the session will be locked for you,
255	267	just before running the page handler.
256
	268
257	269	When 'early', the session will be locked before reading the request
258	270	body. This is off by default for safety reasons; for example,
259	271	a large upload would block the session, denying an AJAX
260		progress meter (see http://www.cherrypy.org/ticket/630).
261
	272	progress meter
	273	(`issue <https://bitbucket.org/cherrypy/cherrypy/issue/630>`_).
	274
262	275	When 'explicit' (or any other value), you need to call
263	276	cherrypy.session.acquire_lock() yourself before using
264	277	session data.
265	278	"""
266
	279
267	280	def __init__(self):
268	281	# _sessions.init must be bound after headers are read
269	282	Tool.__init__(self, 'before_request_body', _sessions.init)
270
	283
271	284	def _lock_session(self):
272	285	cherrypy.serving.session.acquire_lock()
273
	286
274	287	def _setup(self):
275	288	"""Hook this tool into cherrypy.request.
276
	289
277	290	The standard CherryPy request object will automatically call this
278	291	method when the tool is "turned on" in config.
279	292	"""
280	293	hooks = cherrypy.serving.request.hooks
281
	294
282	295	conf = self._merged_args()
283
	296
284	297	p = conf.pop("priority", None)
285	298	if p is None:
286	299	p = getattr(self.callable, "priority", self._priority)
287
	300
288	301	hooks.attach(self._point, self.callable, priority=p, **conf)
289
	302
290	303	locking = conf.pop('locking', 'implicit')
291	304	if locking == 'implicit':
292	305	hooks.attach('before_handler', self._lock_session)

297	310	else:
298	311	# Don't lock
299	312	pass
300
	313
301	314	hooks.attach('before_finalize', _sessions.save)
302	315	hooks.attach('on_end_request', _sessions.close)
303
	316
304	317	def regenerate(self):
305	318	"""Drop the current session and make a new one (with a new id)."""
306	319	sess = cherrypy.serving.session
307	320	sess.regenerate()
308
	321
309	322	# Grab cookie-relevant tool args
310	323	conf = dict([(k, v) for k, v in self._merged_args().items()
311	324	if k in ('path', 'path_header', 'name', 'timeout',

313	326	_sessions.set_response_cookie(**conf)
314	327
315	328
316
317
318	329	class XMLRPCController(object):
	330
319	331	"""A Controller (page handler collection) for XML-RPC.
320
	332
321	333	To use it, have your controllers subclass this base class (it will
322	334	turn on the tool for you).
323
	335
324	336	You can also supply the following optional config entries::
325
	337
326	338	tools.xmlrpc.encoding: 'utf-8'
327	339	tools.xmlrpc.allow_none: 0
328
	340
329	341	XML-RPC is a rather discontinuous layer over HTTP; dispatching to the
330	342	appropriate handler must first be performed according to the URL, and
331	343	then a second dispatch step must take place according to the RPC method

333	345	prefix in the URL, supplies its own handler args in the body, and
334	346	requires a 200 OK "Fault" response instead of 404 when the desired
335	347	method is not found.
336
	348
337	349	Therefore, XML-RPC cannot be implemented for CherryPy via a Tool alone.
338	350	This Controller acts as the dispatch target for the first half (based
339	351	on the URL); it then reads the RPC method from the request body and
340	352	does its own second dispatch step based on that method. It also reads
341	353	body params, and returns a Fault on error.
342
	354
343	355	The XMLRPCDispatcher strips any /RPC2 prefix; if you aren't using /RPC2
344	356	in your URL's, you can safely skip turning on the XMLRPCDispatcher.
345	357	Otherwise, you need to use declare it in config::
346
	358
347	359	request.dispatch: cherrypy.dispatch.XMLRPCDispatcher()
348	360	"""
349
	361
350	362	# Note we're hard-coding this into the 'tools' namespace. We could do
351	363	# a huge amount of work to make it relocatable, but the only reason why
352	364	# would be if someone actually disabled the default_toolbox. Meh.
353	365	_cp_config = {'tools.xmlrpc.on': True}
354
	366
355	367	def default(self, vpath, *params):
356	368	rpcparams, rpcmethod = _xmlrpc.process_body()
357
	369
358	370	subhandler = self
359	371	for attr in str(rpcmethod).split('.'):
360	372	subhandler = getattr(subhandler, attr, None)
361
	373
362	374	if subhandler and getattr(subhandler, "exposed", False):
363	375	body = subhandler((vpath + rpcparams), *params)
364
	376
365	377	else:
366		# http://www.cherrypy.org/ticket/533
	378	# https://bitbucket.org/cherrypy/cherrypy/issue/533
367	379	# if a method is not found, an xmlrpclib.Fault should be returned
368	380	# raising an exception here will do that; see
369	381	# cherrypy.lib.xmlrpcutil.on_error
370	382	raise Exception('method "%s" is not supported' % attr)
371
	383
372	384	conf = cherrypy.serving.request.toolmaps['tools'].get("xmlrpc", {})
373	385	_xmlrpc.respond(body,
374	386	conf.get('encoding', 'utf-8'),

378	390
379	391
380	392	class SessionAuthTool(HandlerTool):
381
	393
382	394	def _setargs(self):
383	395	for name in dir(cptools.SessionAuth):
384	396	if not name.startswith("__"):

386	398
387	399
388	400	class CachingTool(Tool):
	401
389	402	"""Caching Tool for CherryPy."""
390
	403
391	404	def _wrapper(self, **kwargs):
392	405	request = cherrypy.serving.request
393	406	if _caching.get(**kwargs):

396	409	if request.cacheable:
397	410	# Note the devious technique here of adding hooks on the fly
398	411	request.hooks.attach('before_finalize', _caching.tee_output,
399		priority = 90)
	412	priority=90)
400	413	_wrapper.priority = 20
401
	414
402	415	def _setup(self):
403	416	"""Hook caching into cherrypy.request."""
404	417	conf = self._merged_args()
405
	418
406	419	p = conf.pop("priority", None)
407	420	cherrypy.serving.request.hooks.attach('before_handler', self._wrapper,
408	421	priority=p, **conf)
409	422
410	423
411
412	424	class Toolbox(object):
	425
413	426	"""A collection of Tools.
414
	427
415	428	This object also functions as a config namespace handler for itself.
416	429	Custom toolboxes should be added to each Application's toolboxes dict.
417	430	"""
418
	431
419	432	def __init__(self, namespace):
420	433	self.namespace = namespace
421
	434
422	435	def __setattr__(self, name, value):
423	436	# If the Tool._name is None, supply it from the attribute name.
424	437	if isinstance(value, Tool):

426	439	value._name = name
427	440	value.namespace = self.namespace
428	441	object.__setattr__(self, name, value)
429
	442
430	443	def __enter__(self):
431	444	"""Populate request.toolmaps from tools specified in config."""
432	445	cherrypy.serving.request.toolmaps[self.namespace] = map = {}
	446
433	447	def populate(k, v):
434	448	toolname, arg = k.split(".", 1)
435	449	bucket = map.setdefault(toolname, {})
436	450	bucket[arg] = v
437	451	return populate
438
	452
439	453	def __exit__(self, exc_type, exc_val, exc_tb):
440	454	"""Run tool._setup() for each tool in our toolmap."""
441	455	map = cherrypy.serving.request.toolmaps.get(self.namespace)

447	461
448	462
449	463	class DeprecatedTool(Tool):
450
	464
451	465	_name = None
452	466	warnmsg = "This Tool is deprecated."
453
	467
454	468	def __init__(self, point, warnmsg=None):
455	469	self.point = point
456	470	if warnmsg is not None:
457	471	self.warnmsg = warnmsg
458
	472
459	473	def __call__(self, args, *kwargs):
460	474	warnings.warn(self.warnmsg)
	475
461	476	def tool_decorator(f):
462	477	return f
463	478	return tool_decorator
464
	479
465	480	def _setup(self):
466	481	warnings.warn(self.warnmsg)
467	482

486	501	_d.xmlrpc = ErrorTool(_xmlrpc.on_error)
487	502	_d.caching = CachingTool('before_handler', _caching.get, 'caching')
488	503	_d.expires = Tool('before_finalize', _caching.expires)
489		_d.tidy = DeprecatedTool('before_finalize',
490		"The tidy tool has been removed from the standard distribution of CherryPy. "
491		"The most recent version can be found at http://tools.cherrypy.org/browser.")
492		_d.nsgmls = DeprecatedTool('before_finalize',
493		"The nsgmls tool has been removed from the standard distribution of CherryPy. "
494		"The most recent version can be found at http://tools.cherrypy.org/browser.")
	504	_d.tidy = DeprecatedTool(
	505	'before_finalize',
	506	"The tidy tool has been removed from the standard distribution of "
	507	"CherryPy. The most recent version can be found at "
	508	"http://tools.cherrypy.org/browser.")
	509	_d.nsgmls = DeprecatedTool(
	510	'before_finalize',
	511	"The nsgmls tool has been removed from the standard distribution of "
	512	"CherryPy. The most recent version can be found at "
	513	"http://tools.cherrypy.org/browser.")
495	514	_d.ignore_headers = Tool('before_request_body', cptools.ignore_headers)
496	515	_d.referer = Tool('before_request_body', cptools.referer)
497	516	_d.basic_auth = Tool('on_start_resource', auth.basic_auth)

+78

-69

cherrypy/_cptree.py less more

0	0	"""CherryPy Application and Tree objects."""
1	1
2	2	import os
3		import sys
4	3
5	4	import cherrypy
6	5	from cherrypy._cpcompat import ntou, py3k

9	8
10	9
11	10	class Application(object):
	11
12	12	"""A CherryPy Application.
13
	13
14	14	Servers and gateways should not instantiate Request objects directly.
15	15	Instead, they should ask an Application object for a request object.
16
	16
17	17	An instance of this class may also be used as a WSGI callable
18	18	(WSGI application object) for itself.
19	19	"""
20
	20
21	21	root = None
22	22	"""The top-most container of page handlers for this app. Handlers should
23	23	be arranged in a hierarchy of attributes, matching the expected URI
24	24	hierarchy; the default dispatcher then searches this hierarchy for a
25	25	matching handler. When using a dispatcher other than the default,
26	26	this value may be None."""
27
	27
28	28	config = {}
29	29	"""A dict of {path: pathconf} pairs, where 'pathconf' is itself a dict
30	30	of {key: value} pairs."""
31
	31
32	32	namespaces = _cpconfig.NamespaceSet()
33	33	toolboxes = {'tools': cherrypy.tools}
34
	34
35	35	log = None
36	36	"""A LogManager instance. See _cplogging."""
37
	37
38	38	wsgiapp = None
39	39	"""A CPWSGIApp instance. See _cpwsgi."""
40
	40
41	41	request_class = _cprequest.Request
42	42	response_class = _cprequest.Response
43
	43
44	44	relative_urls = False
45
	45
46	46	def __init__(self, root, script_name="", config=None):
47	47	self.log = _cplogging.LogManager(id(self), cherrypy.log.logger_root)
48	48	self.root = root
49	49	self.script_name = script_name
50	50	self.wsgiapp = _cpwsgi.CPWSGIApp(self)
51
	51
52	52	self.namespaces = self.namespaces.copy()
53	53	self.namespaces["log"] = lambda k, v: setattr(self.log, k, v)
54	54	self.namespaces["wsgi"] = self.wsgiapp.namespace_handler
55
	55
56	56	self.config = self.__class__.config.copy()
57	57	if config:
58	58	self.merge(config)
59
	59
60	60	def __repr__(self):
61	61	return "%s.%s(%r, %r)" % (self.__module__, self.__class__.__name__,
62	62	self.root, self.script_name)
63
64		script_name_doc = """The URI "mount point" for this app. A mount point is that portion of
65		the URI which is constant for all URIs that are serviced by this
66		application; it does not include scheme, host, or proxy ("virtual host")
67		portions of the URI.
68
	63
	64	script_name_doc = """The URI "mount point" for this app. A mount point
	65	is that portion of the URI which is constant for all URIs that are
	66	serviced by this application; it does not include scheme, host, or proxy
	67	("virtual host") portions of the URI.
	68
69	69	For example, if script_name is "/my/cool/app", then the URL
70	70	"http://www.example.com/my/cool/app/page1" might be handled by a
71	71	"page1" method on the root object.
72
	72
73	73	The value of script_name MUST NOT end in a slash. If the script_name
74	74	refers to the root of the URI, it MUST be an empty string (not "/").
75
	75
76	76	If script_name is explicitly set to None, then the script_name will be
77	77	provided for each call from request.wsgi_environ['SCRIPT_NAME'].
78	78	"""
	79
79	80	def _get_script_name(self):
80		if self._script_name is None:
81		# None signals that the script name should be pulled from WSGI environ.
82		return cherrypy.serving.request.wsgi_environ['SCRIPT_NAME'].rstrip("/")
83		return self._script_name
	81	if self._script_name is not None:
	82	return self._script_name
	83
	84	# A `_script_name` with a value of None signals that the script name
	85	# should be pulled from WSGI environ.
	86	return cherrypy.serving.request.wsgi_environ['SCRIPT_NAME'].rstrip("/")
	87
84	88	def _set_script_name(self, value):
85	89	if value:
86	90	value = value.rstrip("/")
87	91	self._script_name = value
88	92	script_name = property(fget=_get_script_name, fset=_set_script_name,
89	93	doc=script_name_doc)
90
	94
91	95	def merge(self, config):
92	96	"""Merge the given config into self.config."""
93	97	_cpconfig.merge(self.config, config)
94
	98
95	99	# Handle namespaces specified in config.
96	100	self.namespaces(self.config.get("/", {}))
97
	101
98	102	def find_config(self, path, key, default=None):
99	103	"""Return the most-specific value for key along path, or default."""
100	104	trail = path or "/"
101	105	while trail:
102	106	nodeconf = self.config.get(trail, {})
103
	107
104	108	if key in nodeconf:
105	109	return nodeconf[key]
106
	110
107	111	lastslash = trail.rfind("/")
108	112	if lastslash == -1:
109	113	break

111	115	trail = "/"
112	116	else:
113	117	trail = trail[:lastslash]
114
	118
115	119	return default
116
	120
117	121	def get_serving(self, local, remote, scheme, sproto):
118	122	"""Create and return a Request and Response object."""
119	123	req = self.request_class(local, remote, scheme, sproto)
120	124	req.app = self
121
	125
122	126	for name, toolbox in self.toolboxes.items():
123	127	req.namespaces[name] = toolbox
124
	128
125	129	resp = self.response_class()
126	130	cherrypy.serving.load(req, resp)
127	131	cherrypy.engine.publish('acquire_thread')
128	132	cherrypy.engine.publish('before_request')
129
	133
130	134	return req, resp
131
	135
132	136	def release_serving(self):
133	137	"""Release the current serving (request and response)."""
134	138	req = cherrypy.serving.request
135
	139
136	140	cherrypy.engine.publish('after_request')
137
	141
138	142	try:
139	143	req.close()
140	144	except:
141	145	cherrypy.log(traceback=True, severity=40)
142
	146
143	147	cherrypy.serving.clear()
144
	148
145	149	def __call__(self, environ, start_response):
146	150	return self.wsgiapp(environ, start_response)
147	151
148	152
149	153	class Tree(object):
	154
150	155	"""A registry of CherryPy applications, mounted at diverse points.
151
	156
152	157	An instance of this class may also be used as a WSGI callable
153	158	(WSGI application object), in which case it dispatches to all
154	159	mounted apps.
155	160	"""
156
	161
157	162	apps = {}
158	163	"""
159	164	A dict of the form {script name: application}, where "script name"
160	165	is a string declaring the URI mount point (no trailing slash), and
161	166	"application" is an instance of cherrypy.Application (or an arbitrary
162	167	WSGI callable if you happen to be using a WSGI server)."""
163
	168
164	169	def __init__(self):
165	170	self.apps = {}
166
	171
167	172	def mount(self, root, script_name="", config=None):
168	173	"""Mount a new app from a root object, script_name, and config.
169
	174
170	175	root
171	176	An instance of a "controller class" (a collection of page
172	177	handler methods) which represents the root of the application.
173	178	This may also be an Application instance, or None if using
174	179	a dispatcher other than the default.
175
	180
176	181	script_name
177	182	A string containing the "mount point" of the application.
178	183	This should start with a slash, and be the path portion of the
179	184	URL at which to mount the given root. For example, if root.index()
180	185	will handle requests to "http://www.example.com:8080/dept/app1/",
181	186	then the script_name argument would be "/dept/app1".
182
	187
183	188	It MUST NOT end in a slash. If the script_name refers to the
184	189	root of the URI, it MUST be an empty string (not "/").
185
	190
186	191	config
187	192	A file or dict containing application config.
188	193	"""

193	198	"order to inpect the WSGI environ for SCRIPT_NAME upon each "
194	199	"request). You cannot mount such Applications on this Tree; "
195	200	"you must pass them to a WSGI server interface directly.")
196
	201
197	202	# Next line both 1) strips trailing slash and 2) maps "/" -> "".
198	203	script_name = script_name.rstrip("/")
199
	204
200	205	if isinstance(root, Application):
201	206	app = root
202	207	if script_name != "" and script_name != app.script_name:
203		raise ValueError("Cannot specify a different script name and "
204		"pass an Application instance to cherrypy.mount")
	208	raise ValueError(
	209	"Cannot specify a different script name and pass an "
	210	"Application instance to cherrypy.mount")
205	211	script_name = app.script_name
206	212	else:
207	213	app = Application(root, script_name)
208
	214
209	215	# If mounted at "", add favicon.ico
210	216	if (script_name == "" and root is not None
211	217	and not hasattr(root, "favicon_ico")):
212	218	favicon = os.path.join(os.getcwd(), os.path.dirname(__file__),
213	219	"favicon.ico")
214	220	root.favicon_ico = tools.staticfile.handler(favicon)
215
	221
216	222	if config:
217	223	app.merge(config)
218
	224
219	225	self.apps[script_name] = app
220
	226
221	227	return app
222
	228
223	229	def graft(self, wsgi_callable, script_name=""):
224	230	"""Mount a wsgi callable at the given script_name."""
225	231	# Next line both 1) strips trailing slash and 2) maps "/" -> "".
226	232	script_name = script_name.rstrip("/")
227	233	self.apps[script_name] = wsgi_callable
228
	234
229	235	def script_name(self, path=None):
230	236	"""The script_name of the app at the given path, or None.
231
	237
232	238	If path is None, cherrypy.request is used.
233	239	"""
234	240	if path is None:

238	244	request.path_info)
239	245	except AttributeError:
240	246	return None
241
	247
242	248	while True:
243	249	if path in self.apps:
244	250	return path
245
	251
246	252	if path == "":
247	253	return None
248
	254
249	255	# Move one node up the tree and try again.
250	256	path = path[:path.rfind("/")]
251
	257
252	258	def __call__(self, environ, start_response):
253	259	# If you're calling this, then you're probably setting SCRIPT_NAME
254	260	# to '' (some WSGI servers always set SCRIPT_NAME to '').

262	268	if sn is None:
263	269	start_response('404 Not Found', [])
264	270	return []
265
	271
266	272	app = self.apps[sn]
267
	273
268	274	# Correct the SCRIPT_NAME and PATH_INFO environ entries.
269	275	environ = environ.copy()
270	276	if not py3k:

272	278	# Python 2/WSGI u.0: all strings MUST be of type unicode
273	279	enc = environ[ntou('wsgi.url_encoding')]
274	280	environ[ntou('SCRIPT_NAME')] = sn.decode(enc)
275		environ[ntou('PATH_INFO')] = path[len(sn.rstrip("/")):].decode(enc)
	281	environ[ntou('PATH_INFO')] = path[
	282	len(sn.rstrip("/")):].decode(enc)
276	283	else:
277	284	# Python 2/WSGI 1.x: all strings MUST be of type str
278	285	environ['SCRIPT_NAME'] = sn

284	291	environ['PATH_INFO'] = path[len(sn.rstrip("/")):]
285	292	else:
286	293	# Python 3/WSGI 1.x: all strings MUST be ISO-8859-1 str
287		environ['SCRIPT_NAME'] = sn.encode('utf-8').decode('ISO-8859-1')
288		environ['PATH_INFO'] = path[len(sn.rstrip("/")):].encode('utf-8').decode('ISO-8859-1')
	294	environ['SCRIPT_NAME'] = sn.encode(
	295	'utf-8').decode('ISO-8859-1')
	296	environ['PATH_INFO'] = path[
	297	len(sn.rstrip("/")):].encode('utf-8').decode('ISO-8859-1')
289	298	return app(environ, start_response)

+86

-68

cherrypy/_cpwsgi.py less more

15	15
16	16
17	17	def downgrade_wsgi_ux_to_1x(environ):
18		"""Return a new environ dict for WSGI 1.x from the given WSGI u.x environ."""
	18	"""Return a new environ dict for WSGI 1.x from the given WSGI u.x environ.
	19	"""
19	20	env1x = {}
20
	21
21	22	url_encoding = environ[ntou('wsgi.url_encoding')]
22	23	for k, v in list(environ.items()):
23	24	if k in [ntou('PATH_INFO'), ntou('SCRIPT_NAME'), ntou('QUERY_STRING')]:

25	26	elif isinstance(v, unicodestr):
26	27	v = v.encode('ISO-8859-1')
27	28	env1x[k.encode('ISO-8859-1')] = v
28
	29
29	30	return env1x
30	31
31	32
32	33	class VirtualHost(object):
	34
33	35	"""Select a different WSGI application based on the Host header.
34
	36
35	37	This can be useful when running multiple sites within one CP server.
36	38	It allows several domains to point to different applications. For example::
37
	39
38	40	root = Root()
39	41	RootApp = cherrypy.Application(root)
40	42	Domain2App = cherrypy.Application(root)
41	43	SecureApp = cherrypy.Application(Secure())
42
	44
43	45	vhost = cherrypy._cpwsgi.VirtualHost(RootApp,
44	46	domains={'www.domain2.example': Domain2App,
45	47	'www.domain2.example:443': SecureApp,
46	48	})
47
	49
48	50	cherrypy.tree.graft(vhost)
49	51	"""
50	52	default = None
51	53	"""Required. The default WSGI application."""
52
	54
53	55	use_x_forwarded_host = True
54	56	"""If True (the default), any "X-Forwarded-Host"
55	57	request header will be used instead of the "Host" header. This
56	58	is commonly added by HTTP servers (such as Apache) when proxying."""
57
	59
58	60	domains = {}
59	61	"""A dict of {host header value: application} pairs.
60	62	The incoming "Host" request header is looked up in this dict,

63	65	separate entries for "example.com" and "www.example.com".
64	66	In addition, "Host" headers may contain the port number.
65	67	"""
66
	68
67	69	def __init__(self, default, domains=None, use_x_forwarded_host=True):
68	70	self.default = default
69	71	self.domains = domains or {}
70	72	self.use_x_forwarded_host = use_x_forwarded_host
71
	73
72	74	def __call__(self, environ, start_response):
73	75	domain = environ.get('HTTP_HOST', '')
74	76	if self.use_x_forwarded_host:
75	77	domain = environ.get("HTTP_X_FORWARDED_HOST", domain)
76
	78
77	79	nextapp = self.domains.get(domain)
78	80	if nextapp is None:
79	81	nextapp = self.default

81	83
82	84
83	85	class InternalRedirector(object):
	86
84	87	"""WSGI middleware that handles raised cherrypy.InternalRedirect."""
85
	88
86	89	def __init__(self, nextapp, recursive=False):
87	90	self.nextapp = nextapp
88	91	self.recursive = recursive
89
	92
90	93	def __call__(self, environ, start_response):
91	94	redirections = []
92	95	while True:

98	101	sn = environ.get('SCRIPT_NAME', '')
99	102	path = environ.get('PATH_INFO', '')
100	103	qs = environ.get('QUERY_STRING', '')
101
	104
102	105	# Add the previous path_info + qs to redirections.
103	106	old_uri = sn + path
104	107	if qs:
105	108	old_uri += "?" + qs
106	109	redirections.append(old_uri)
107
	110
108	111	if not self.recursive:
109		# Check to see if the new URI has been redirected to already
	112	# Check to see if the new URI has been redirected to
	113	# already
110	114	new_uri = sn + ir.path
111	115	if ir.query_string:
112	116	new_uri += "?" + ir.query_string

114	118	ir.request.close()
115	119	raise RuntimeError("InternalRedirector visited the "
116	120	"same URL twice: %r" % new_uri)
117
	121
118	122	# Munge the environment and try again.
119	123	environ['REQUEST_METHOD'] = "GET"
120	124	environ['PATH_INFO'] = ir.path

125	129
126	130
127	131	class ExceptionTrapper(object):
	132
128	133	"""WSGI middleware that traps exceptions."""
129
	134
130	135	def __init__(self, nextapp, throws=(KeyboardInterrupt, SystemExit)):
131	136	self.nextapp = nextapp
132	137	self.throws = throws
133
	138
134	139	def __call__(self, environ, start_response):
135		return _TrappedResponse(self.nextapp, environ, start_response, self.throws)
	140	return _TrappedResponse(
	141	self.nextapp,
	142	environ,
	143	start_response,
	144	self.throws
	145	)
136	146
137	147
138	148	class _TrappedResponse(object):
139
	149
140	150	response = iter([])
141
	151
142	152	def __init__(self, nextapp, environ, start_response, throws):
143	153	self.nextapp = nextapp
144	154	self.environ = environ
145	155	self.start_response = start_response
146	156	self.throws = throws
147	157	self.started_response = False
148		self.response = self.trap(self.nextapp, self.environ, self.start_response)
	158	self.response = self.trap(
	159	self.nextapp, self.environ, self.start_response)
149	160	self.iter_response = iter(self.response)
150
	161
151	162	def __iter__(self):
152	163	self.started_response = True
153	164	return self
154
	165
155	166	if py3k:
156	167	def __next__(self):
157	168	return self.trap(next, self.iter_response)
158	169	else:
159	170	def next(self):
160	171	return self.trap(self.iter_response.next)
161
	172
162	173	def close(self):
163	174	if hasattr(self.response, 'close'):
164	175	self.response.close()
165
	176
166	177	def trap(self, func, args, *kwargs):
167	178	try:
168	179	return func(args, *kwargs)

187	198	self.iter_response = iter([])
188	199	else:
189	200	self.iter_response = iter(b)
190
	201
191	202	try:
192	203	self.start_response(s, h, _sys.exc_info())
193	204	except:

198	209	# But we still log and call close() to clean up ourselves.
199	210	_cherrypy.log(traceback=True, severity=40)
200	211	raise
201
	212
202	213	if self.started_response:
203	214	return ntob("").join(b)
204	215	else:

209	220
210	221
211	222	class AppResponse(object):
	223
212	224	"""WSGI response iterable for CherryPy applications."""
213
	225
214	226	def __init__(self, environ, start_response, cpapp):
215	227	self.cpapp = cpapp
216	228	try:

225	237	outstatus = r.output_status
226	238	if not isinstance(outstatus, bytestr):
227	239	raise TypeError("response.output_status is not a byte string.")
228
	240
229	241	outheaders = []
230	242	for k, v in r.header_list:
231	243	if not isinstance(k, bytestr):
232		raise TypeError("response.header_list key %r is not a byte string." % k)
	244	raise TypeError(
	245	"response.header_list key %r is not a byte string." %
	246	k)
233	247	if not isinstance(v, bytestr):
234		raise TypeError("response.header_list value %r is not a byte string." % v)
	248	raise TypeError(
	249	"response.header_list value %r is not a byte string." %
	250	v)
235	251	outheaders.append((k, v))
236
	252
237	253	if py3k:
238		# According to PEP 3333, when using Python 3, the response status
239		# and headers must be bytes masquerading as unicode; that is, they
240		# must be of type "str" but are restricted to code points in the
241		# "latin-1" set.
	254	# According to PEP 3333, when using Python 3, the response
	255	# status and headers must be bytes masquerading as unicode;
	256	# that is, they must be of type "str" but are restricted to
	257	# code points in the "latin-1" set.
242	258	outstatus = outstatus.decode('ISO-8859-1')
243	259	outheaders = [(k.decode('ISO-8859-1'), v.decode('ISO-8859-1'))
244	260	for k, v in outheaders]

248	264	except:
249	265	self.close()
250	266	raise
251
	267
252	268	def __iter__(self):
253	269	return self
254
	270
255	271	if py3k:
256	272	def __next__(self):
257	273	return next(self.iter_response)
258	274	else:
259	275	def next(self):
260	276	return self.iter_response.next()
261
	277
262	278	def close(self):
263	279	"""Close and de-reference the current request and response. (Core)"""
264	280	self.cpapp.release_serving()
265
	281
266	282	def run(self):
267	283	"""Create a Request object using environ."""
268	284	env = self.environ.get
269
	285
270	286	local = httputil.Host('', int(env('SERVER_PORT', 80)),
271		env('SERVER_NAME', ''))
	287	env('SERVER_NAME', ''))
272	288	remote = httputil.Host(env('REMOTE_ADDR', ''),
273	289	int(env('REMOTE_PORT', -1) or -1),
274	290	env('REMOTE_HOST', ''))
275	291	scheme = env('wsgi.url_scheme')
276	292	sproto = env('ACTUAL_SERVER_PROTOCOL', "HTTP/1.1")
277	293	request, resp = self.cpapp.get_serving(local, remote, scheme, sproto)
278
	294
279	295	# LOGON_USER is served by IIS, and is the name of the
280	296	# user after having been mapped to a local account.
281	297	# Both IIS and Apache set REMOTE_USER, when possible.

284	300	request.multiprocess = self.environ['wsgi.multiprocess']
285	301	request.wsgi_environ = self.environ
286	302	request.prev = env('cherrypy.previous_request', None)
287
	303
288	304	meth = self.environ['REQUEST_METHOD']
289
	305
290	306	path = httputil.urljoin(self.environ.get('SCRIPT_NAME', ''),
291	307	self.environ.get('PATH_INFO', ''))
292	308	qs = self.environ.get('QUERY_STRING', '')
293	309
294	310	if py3k:
295		# This isn't perfect; if the given PATH_INFO is in the wrong encoding,
296		# it may fail to match the appropriate config section URI. But meh.
	311	# This isn't perfect; if the given PATH_INFO is in the
	312	# wrong encoding, it may fail to match the appropriate config
	313	# section URI. But meh.
297	314	old_enc = self.environ.get('wsgi.url_encoding', 'ISO-8859-1')
298	315	new_enc = self.cpapp.find_config(self.environ.get('PATH_INFO', ''),
299	316	"request.uri_encoding", 'utf-8')
300	317	if new_enc.lower() != old_enc.lower():
301		# Even though the path and qs are unicode, the WSGI server is
302		# required by PEP 3333 to coerce them to ISO-8859-1 masquerading
303		# as unicode. So we have to encode back to bytes and then decode
304		# again using the "correct" encoding.
	318	# Even though the path and qs are unicode, the WSGI server
	319	# is required by PEP 3333 to coerce them to ISO-8859-1
	320	# masquerading as unicode. So we have to encode back to
	321	# bytes and then decode again using the "correct" encoding.
305	322	try:
306	323	u_path = path.encode(old_enc).decode(new_enc)
307	324	u_qs = qs.encode(old_enc).decode(new_enc)

312	329	# Only set transcoded values if they both succeed.
313	330	path = u_path
314	331	qs = u_qs
315
	332
316	333	rproto = self.environ.get('SERVER_PROTOCOL')
317	334	headers = self.translate_headers(self.environ)
318	335	rfile = self.environ['wsgi.input']
319	336	request.run(meth, path, qs, rproto, headers, rfile)
320
	337
321	338	headerNames = {'HTTP_CGI_AUTHORIZATION': 'Authorization',
322	339	'CONTENT_LENGTH': 'Content-Length',
323	340	'CONTENT_TYPE': 'Content-Type',
324	341	'REMOTE_HOST': 'Remote-Host',
325	342	'REMOTE_ADDR': 'Remote-Addr',
326	343	}
327
	344
328	345	def translate_headers(self, environ):
329	346	"""Translate CGI-environ header names to HTTP header names."""
330	347	for cgiName in environ:

338	355
339	356
340	357	class CPWSGIApp(object):
	358
341	359	"""A WSGI application object for a CherryPy Application."""
342
	360
343	361	pipeline = [('ExceptionTrapper', ExceptionTrapper),
344	362	('InternalRedirector', InternalRedirector),
345	363	]

348	366	plus optional keyword arguments, and returns a WSGI application
349	367	(that takes environ and start_response arguments). The 'name' can
350	368	be any you choose, and will correspond to keys in self.config."""
351
	369
352	370	head = None
353	371	"""Rather than nest all apps in the pipeline on each call, it's only
354	372	done the first time, and the result is memoized into self.head. Set
355	373	this to None again if you change self.pipeline after calling self."""
356
	374
357	375	config = {}
358	376	"""A dict whose keys match names listed in the pipeline. Each
359	377	value is a further dict which will be passed to the corresponding
360	378	named WSGI callable (from the pipeline) as keyword arguments."""
361
	379
362	380	response_class = AppResponse
363		"""The class to instantiate and return as the next app in the WSGI chain."""
364
	381	"""The class to instantiate and return as the next app in the WSGI chain.
	382	"""
	383
365	384	def __init__(self, cpapp, pipeline=None):
366	385	self.cpapp = cpapp
367	386	self.pipeline = self.pipeline[:]
368	387	if pipeline:
369	388	self.pipeline.extend(pipeline)
370	389	self.config = self.config.copy()
371
	390
372	391	def tail(self, environ, start_response):
373	392	"""WSGI application callable for the actual CherryPy application.
374
	393
375	394	You probably shouldn't call this; call self.__call__ instead,
376	395	so that any WSGI middleware in self.pipeline can run first.
377	396	"""
378	397	return self.response_class(environ, start_response, self.cpapp)
379
	398
380	399	def __call__(self, environ, start_response):
381	400	head = self.head
382	401	if head is None:

388	407	head = callable(head, **conf)
389	408	self.head = head
390	409	return head(environ, start_response)
391
	410
392	411	def namespace_handler(self, k, v):
393	412	"""Config handler for the 'wsgi' namespace."""
394	413	if k == "pipeline":

404	423	name, arg = k.split(".", 1)
405	424	bucket = self.config.setdefault(name, {})
406	425	bucket[arg] = v
407

+18

-13

cherrypy/_cpwsgi_server.py less more

7	7
8	8
9	9	class CPWSGIServer(wsgiserver.CherryPyWSGIServer):
	10
10	11	"""Wrapper for wsgiserver.CherryPyWSGIServer.
11
	12
12	13	wsgiserver has been designed to not reference CherryPy in any way,
13	14	so that it can be used in other frameworks and applications. Therefore,
14	15	we wrap it here, so we can set our own mount points from cherrypy.tree
15	16	and apply some attributes from config -> cherrypy.server -> wsgiserver.
16	17	"""
17
	18
18	19	def __init__(self, server_adapter=cherrypy.server):
19	20	self.server_adapter = server_adapter
20		self.max_request_header_size = self.server_adapter.max_request_header_size or 0
21		self.max_request_body_size = self.server_adapter.max_request_body_size or 0
22
	21	self.max_request_header_size = (
	22	self.server_adapter.max_request_header_size or 0
	23	)
	24	self.max_request_body_size = (
	25	self.server_adapter.max_request_body_size or 0
	26	)
	27
23	28	server_name = (self.server_adapter.socket_host or
24	29	self.server_adapter.socket_file or
25	30	None)
26
	31
27	32	self.wsgi_version = self.server_adapter.wsgi_version
28	33	s = wsgiserver.CherryPyWSGIServer
29	34	s.__init__(self, server_adapter.bind_addr, cherrypy.tree,
30	35	self.server_adapter.thread_pool,
31	36	server_name,
32		max = self.server_adapter.thread_pool_max,
33		request_queue_size = self.server_adapter.socket_queue_size,
34		timeout = self.server_adapter.socket_timeout,
35		shutdown_timeout = self.server_adapter.shutdown_timeout,
	37	max=self.server_adapter.thread_pool_max,
	38	request_queue_size=self.server_adapter.socket_queue_size,
	39	timeout=self.server_adapter.socket_timeout,
	40	shutdown_timeout=self.server_adapter.shutdown_timeout,
36	41	)
37	42	self.protocol = self.server_adapter.protocol_version
38	43	self.nodelay = self.server_adapter.nodelay

54	59	self.server_adapter.ssl_certificate,
55	60	self.server_adapter.ssl_private_key,
56	61	self.server_adapter.ssl_certificate_chain)
57
58		self.stats['Enabled'] = getattr(self.server_adapter, 'statistics', False)
	62
	63	self.stats['Enabled'] = getattr(
	64	self.server_adapter, 'statistics', False)
59	65
60	66	def error_log(self, msg="", level=20, traceback=False):
61	67	cherrypy.engine.log(msg, level, traceback)
62

+15

-14

cherrypy/cherryd less more

6	6	from cherrypy.process import plugins, servers
7	7	from cherrypy import Application
8	8
	9
9	10	def start(configfiles=None, daemonize=False, environment=None,
10	11	fastcgi=False, scgi=False, pidfile=None, imports=None,
11	12	cgi=False):

13	14	sys.path = [''] + sys.path
14	15	for i in imports or []:
15	16	exec("import %s" % i)
16
	17
17	18	for c in configfiles or []:
18	19	cherrypy.config.update(c)
19	20	# If there's only one app mounted, merge config into it.

21	22	for app in cherrypy.tree.apps.values():
22	23	if isinstance(app, Application):
23	24	app.merge(c)
24
	25
25	26	engine = cherrypy.engine
26
	27
27	28	if environment is not None:
28	29	cherrypy.config.update({'environment': environment})
29
	30
30	31	# Only daemonize if asked to.
31	32	if daemonize:
32	33	# Don't print anything to stdout/sterr.
33	34	cherrypy.config.update({'log.screen': False})
34	35	plugins.Daemonizer(engine).subscribe()
35
	36
36	37	if pidfile:
37	38	plugins.PIDFile(engine, pidfile).subscribe()
38
	39
39	40	if hasattr(engine, "signal_handler"):
40	41	engine.signal_handler.subscribe()
41	42	if hasattr(engine, "console_control_handler"):
42	43	engine.console_control_handler.subscribe()
43
	44
44	45	if (fastcgi and (scgi or cgi)) or (scgi and cgi):
45	46	cherrypy.log.error("You may only specify one of the cgi, fastcgi, and "
46	47	"scgi options.", 'ENGINE')

50	51	cherrypy.config.update({'engine.autoreload_on': False})
51	52	# Turn off the default HTTP server (which is subscribed by default).
52	53	cherrypy.server.unsubscribe()
53
	54
54	55	addr = cherrypy.server.bind_addr
55	56	if fastcgi:
56	57	f = servers.FlupFCGIServer(application=cherrypy.tree,

63	64	bindAddress=addr)
64	65	s = servers.ServerAdapter(engine, httpserver=f, bind_addr=addr)
65	66	s.subscribe()
66
	67
67	68	# Always start the engine; this will start all other services
68	69	try:
69	70	engine.start()

76	77
77	78	if __name__ == '__main__':
78	79	from optparse import OptionParser
79
	80
80	81	p = OptionParser()
81	82	p.add_option('-c', '--config', action="append", dest='config',
82	83	help="specify config file(s)")

85	86	p.add_option('-e', '--environment', dest='environment', default=None,
86	87	help="apply the given config environment")
87	88	p.add_option('-f', action="store_true", dest='fastcgi',
88		help="start a fastcgi server instead of the default HTTP server")
	89	help="start a fastcgi server instead of the default HTTP "
	90	"server")
89	91	p.add_option('-s', action="store_true", dest='scgi',
90	92	help="start a scgi server instead of the default HTTP server")
91	93	p.add_option('-x', action="store_true", dest='cgi',

97	99	p.add_option('-P', '--Path', action="append", dest='Path',
98	100	help="add the given paths to sys.path")
99	101	options, args = p.parse_args()
100
	102
101	103	if options.Path:
102	104	for p in options.Path:
103	105	sys.path.insert(0, p)
104
	106
105	107	start(options.config, options.daemonize,
106	108	options.environment, options.fastcgi, options.scgi,
107	109	options.pidfile, options.imports, options.cgi)
108

+20

-3

cherrypy/lib/__init__.py less more

2	2	# Deprecated in CherryPy 3.2 -- remove in CherryPy 3.3
3	3	from cherrypy.lib.reprconf import unrepr, modules, attributes
4	4
	5	def is_iterator(obj):
	6	'''Returns a boolean indicating if the object provided implements
	7	the iterator protocol (i.e. like a generator). This will return
	8	false for objects which iterable, but not iterators themselves.'''
	9	from types import GeneratorType
	10	if isinstance(obj, GeneratorType):
	11	return True
	12	elif not hasattr(obj, '__iter__'):
	13	return False
	14	else:
	15	# Types which implement the protocol must return themselves when
	16	# invoking 'iter' upon them.
	17	return iter(obj) is obj
	18
5	19	class file_generator(object):
	20
6	21	"""Yield the given input (a file object) in chunks (default 64k). (Core)"""
7
	22
8	23	def __init__(self, input, chunkSize=65536):
9	24	self.input = input
10	25	self.chunkSize = chunkSize
11
	26
12	27	def __iter__(self):
13	28	return self
14
	29
15	30	def __next__(self):
16	31	chunk = self.input.read(self.chunkSize)
17	32	if chunk:

21	36	self.input.close()
22	37	raise StopIteration()
23	38	next = __next__
	39
24	40
25	41	def file_generator_limited(fileobj, count, chunk_size=65536):
26	42	"""Yield the given file object in chunks, stopping after `count`

35	51	remaining -= chunklen
36	52	yield chunk
37	53
	54
38	55	def set_vary_header(response, header_name):
39	56	"Add a Vary header to a response"
40	57	varies = response.headers.get("Vary", "")

+35

-25

cherrypy/lib/auth.py less more

2	2
3	3
4	4	def check_auth(users, encrypt=None, realm=None):
5		"""If an authorization header contains credentials, return True, else False."""
	5	"""If an authorization header contains credentials, return True or False.
	6	"""
6	7	request = cherrypy.serving.request
7	8	if 'authorization' in request.headers:
8	9	# make sure the provided credentials are correctly set
9	10	ah = httpauth.parseAuthorization(request.headers['authorization'])
10	11	if ah is None:
11	12	raise cherrypy.HTTPError(400, 'Bad Request')
12
	13
13	14	if not encrypt:
14	15	encrypt = httpauth.DIGEST_AUTH_ENCODERS[httpauth.MD5]
15
	16
16	17	if hasattr(users, '__call__'):
17	18	try:
18	19	# backward compatibility
19		users = users() # expect it to return a dictionary
20
	20	users = users() # expect it to return a dictionary
	21
21	22	if not isinstance(users, dict):
22		raise ValueError("Authentication users must be a dictionary")
23
	23	raise ValueError(
	24	"Authentication users must be a dictionary")
	25
24	26	# fetch the user password
25	27	password = users.get(ah["username"], None)
26	28	except TypeError:

29	31	else:
30	32	if not isinstance(users, dict):
31	33	raise ValueError("Authentication users must be a dictionary")
32
	34
33	35	# fetch the user password
34	36	password = users.get(ah["username"], None)
35
	37
36	38	# validate the authorization by re-computing it here
37	39	# and compare it with what the user-agent provided
38	40	if httpauth.checkResponse(ah, password, method=request.method,
39	41	encrypt=encrypt, realm=realm):
40	42	request.login = ah["username"]
41	43	return True
42
	44
43	45	request.login = False
44	46	return False
45	47
	48
46	49	def basic_auth(realm, users, encrypt=None, debug=False):
47	50	"""If auth fails, raise 401 with a basic authentication header.
48
	51
49	52	realm
50	53	A string containing the authentication realm.
51
	54
52	55	users
53		A dict of the form: {username: password} or a callable returning a dict.
54
	56	A dict of the form: {username: password} or a callable returning
	57	a dict.
	58
55	59	encrypt
56	60	callable used to encrypt the password returned from the user-agent.
57	61	if None it defaults to a md5 encryption.
58
	62
59	63	"""
60	64	if check_auth(users, encrypt):
61	65	if debug:
62	66	cherrypy.log('Auth successful', 'TOOLS.BASIC_AUTH')
63	67	return
64
	68
65	69	# inform the user-agent this path is protected
66		cherrypy.serving.response.headers['www-authenticate'] = httpauth.basicAuth(realm)
67
68		raise cherrypy.HTTPError(401, "You are not authorized to access that resource")
	70	cherrypy.serving.response.headers[
	71	'www-authenticate'] = httpauth.basicAuth(realm)
	72
	73	raise cherrypy.HTTPError(
	74	401, "You are not authorized to access that resource")
	75
69	76
70	77	def digest_auth(realm, users, debug=False):
71	78	"""If auth fails, raise 401 with a digest authentication header.
72
	79
73	80	realm
74	81	A string containing the authentication realm.
75	82	users
76		A dict of the form: {username: password} or a callable returning a dict.
	83	A dict of the form: {username: password} or a callable returning
	84	a dict.
77	85	"""
78	86	if check_auth(users, realm=realm):
79	87	if debug:
80	88	cherrypy.log('Auth successful', 'TOOLS.DIGEST_AUTH')
81	89	return
82
	90
83	91	# inform the user-agent this path is protected
84		cherrypy.serving.response.headers['www-authenticate'] = httpauth.digestAuth(realm)
85
86		raise cherrypy.HTTPError(401, "You are not authorized to access that resource")
	92	cherrypy.serving.response.headers[
	93	'www-authenticate'] = httpauth.digestAuth(realm)
	94
	95	raise cherrypy.HTTPError(
	96	401, "You are not authorized to access that resource")

+13

-10

cherrypy/lib/auth_basic.py less more

2	2	# vim:ts=4:sw=4:expandtab:fileencoding=utf-8
3	3
4	4	__doc__ = """This module provides a CherryPy 3.x tool which implements
5		the server-side of HTTP Basic Access Authentication, as described in :rfc:`2617`.
	5	the server-side of HTTP Basic Access Authentication, as described in
	6	:rfc:`2617`.
6	7
7	8	Example usage, using the built-in checkpassword_dict function which uses a dict
8	9	as the credentials store::

59	60	username and password are the values obtained from the request's
60	61	'authorization' header. If authentication succeeds, checkpassword
61	62	returns True, else it returns False.
62
	63
63	64	"""
64
	65
65	66	if '"' in realm:
66	67	raise ValueError('Realm cannot contain the " (quote) character.')
67	68	request = cherrypy.serving.request
68
	69
69	70	auth_header = request.headers.get('authorization')
70	71	if auth_header is not None:
71	72	try:

76	77	if debug:
77	78	cherrypy.log('Auth succeeded', 'TOOLS.AUTH_BASIC')
78	79	request.login = username
79		return # successful authentication
80		except (ValueError, binascii.Error): # split() error, base64.decodestring() error
	80	return # successful authentication
	81	# split() error, base64.decodestring() error
	82	except (ValueError, binascii.Error):
81	83	raise cherrypy.HTTPError(400, 'Bad Request')
82
	84
83	85	# Respond with 401 status and a WWW-Authenticate header
84		cherrypy.serving.response.headers['www-authenticate'] = 'Basic realm="%s"' % realm
85		raise cherrypy.HTTPError(401, "You are not authorized to access that resource")
86
	86	cherrypy.serving.response.headers[
	87	'www-authenticate'] = 'Basic realm="%s"' % realm
	88	raise cherrypy.HTTPError(
	89	401, "You are not authorized to access that resource")

+98

-73

cherrypy/lib/auth_digest.py less more

40	40
41	41	# Three helper functions for users of the tool, providing three variants
42	42	# of get_ha1() functions for three different kinds of credential stores.
	43
	44
43	45	def get_ha1_dict_plain(user_password_dict):
44	46	"""Returns a get_ha1 function which obtains a plaintext password from a
45	47	dictionary of the form: {username : password}.

56	58
57	59	return get_ha1
58	60
	61
59	62	def get_ha1_dict(user_ha1_dict):
60	63	"""Returns a get_ha1 function which obtains a HA1 password hash from a
61	64	dictionary of the form: {username : HA1}.

66	69	argument to digest_auth().
67	70	"""
68	71	def get_ha1(realm, username):
69		return user_ha1_dict.get(user)
	72	return user_ha1_dict.get(username)
70	73
71	74	return get_ha1
	75
72	76
73	77	def get_ha1_file_htdigest(filename):
74	78	"""Returns a get_ha1 function which obtains a HA1 password hash from a

98	102
99	103
100	104	def synthesize_nonce(s, key, timestamp=None):
101		"""Synthesize a nonce value which resists spoofing and can be checked for staleness.
102		Returns a string suitable as the value for 'nonce' in the www-authenticate header.
	105	"""Synthesize a nonce value which resists spoofing and can be checked
	106	for staleness. Returns a string suitable as the value for 'nonce' in
	107	the www-authenticate header.
103	108
104	109	s
105	110	A string related to the resource, such as the hostname of the server.
106	111
107	112	key
108	113	A secret string known only to the server.
109
	114
110	115	timestamp
111	116	An integer seconds-since-the-epoch timestamp
112
	117
113	118	"""
114	119	if timestamp is None:
115	120	timestamp = int(time.time())

124	129
125	130
126	131	class HttpDigestAuthorization (object):
	132
127	133	"""Class to parse a Digest Authorization header and perform re-calculation
128	134	of the digest.
129	135	"""

134	140	def __init__(self, auth_header, http_method, debug=False):
135	141	self.http_method = http_method
136	142	self.debug = debug
137		scheme, params = auth_header.split(" ", 1)
	143	scheme, params = auth_header.split(" ", 1)
138	144	self.scheme = scheme.lower()
139	145	if self.scheme != 'digest':
140	146	raise ValueError('Authorization scheme is not "Digest"')

150	156	self.nonce = paramsd.get('nonce')
151	157	self.uri = paramsd.get('uri')
152	158	self.method = paramsd.get('method')
153		self.response = paramsd.get('response') # the response digest
154		self.algorithm = paramsd.get('algorithm', 'MD5')
	159	self.response = paramsd.get('response') # the response digest
	160	self.algorithm = paramsd.get('algorithm', 'MD5').upper()
155	161	self.cnonce = paramsd.get('cnonce')
156	162	self.opaque = paramsd.get('opaque')
157		self.qop = paramsd.get('qop') # qop
158		self.nc = paramsd.get('nc') # nonce count
	163	self.qop = paramsd.get('qop') # qop
	164	self.nc = paramsd.get('nc') # nonce count
159	165
160	166	# perform some correctness checks
161	167	if self.algorithm not in valid_algorithms:
162		raise ValueError(self.errmsg("Unsupported value for algorithm: '%s'" % self.algorithm))
163
164		has_reqd = self.username and \
165		self.realm and \
166		self.nonce and \
167		self.uri and \
168		self.response
	168	raise ValueError(
	169	self.errmsg("Unsupported value for algorithm: '%s'" %
	170	self.algorithm))
	171
	172	has_reqd = (
	173	self.username and
	174	self.realm and
	175	self.nonce and
	176	self.uri and
	177	self.response
	178	)
169	179	if not has_reqd:
170		raise ValueError(self.errmsg("Not all required parameters are present."))
	180	raise ValueError(
	181	self.errmsg("Not all required parameters are present."))
171	182
172	183	if self.qop:
173	184	if self.qop not in valid_qops:
174		raise ValueError(self.errmsg("Unsupported value for qop: '%s'" % self.qop))
	185	raise ValueError(
	186	self.errmsg("Unsupported value for qop: '%s'" % self.qop))
175	187	if not (self.cnonce and self.nc):
176		raise ValueError(self.errmsg("If qop is sent then cnonce and nc MUST be present"))
	188	raise ValueError(
	189	self.errmsg("If qop is sent then "
	190	"cnonce and nc MUST be present"))
177	191	else:
178	192	if self.cnonce or self.nc:
179		raise ValueError(self.errmsg("If qop is not sent, neither cnonce nor nc can be present"))
180
	193	raise ValueError(
	194	self.errmsg("If qop is not sent, "
	195	"neither cnonce nor nc can be present"))
181	196
182	197	def __str__(self):
183	198	return 'authorization : %s' % self.auth_header
184	199
185	200	def validate_nonce(self, s, key):
186	201	"""Validate the nonce.
187		Returns True if nonce was generated by synthesize_nonce() and the timestamp
188		is not spoofed, else returns False.
	202	Returns True if nonce was generated by synthesize_nonce() and the
	203	timestamp is not spoofed, else returns False.
189	204
190	205	s
191		A string related to the resource, such as the hostname of the server.
192
	206	A string related to the resource, such as the hostname of
	207	the server.
	208
193	209	key
194	210	A secret string known only to the server.
195
196		Both s and key must be the same values which were used to synthesize the nonce
197		we are trying to validate.
	211
	212	Both s and key must be the same values which were used to synthesize
	213	the nonce we are trying to validate.
198	214	"""
199	215	try:
200	216	timestamp, hashpart = self.nonce.split(':', 1)
201		s_timestamp, s_hashpart = synthesize_nonce(s, key, timestamp).split(':', 1)
	217	s_timestamp, s_hashpart = synthesize_nonce(
	218	s, key, timestamp).split(':', 1)
202	219	is_valid = s_hashpart == hashpart
203	220	if self.debug:
204	221	TRACE('validate_nonce: %s' % is_valid)
205	222	return is_valid
206		except ValueError: # split() error
	223	except ValueError: # split() error
207	224	pass
208	225	return False
209	226
210
211	227	def is_nonce_stale(self, max_age_seconds=600):
212	228	"""Returns True if a validated nonce is stale. The nonce contains a
213		timestamp in plaintext and also a secure hash of the timestamp. You should
214		first validate the nonce to ensure the plaintext timestamp is not spoofed.
	229	timestamp in plaintext and also a secure hash of the timestamp.
	230	You should first validate the nonce to ensure the plaintext
	231	timestamp is not spoofed.
215	232	"""
216	233	try:
217	234	timestamp, hashpart = self.nonce.split(':', 1)
218	235	if int(timestamp) + max_age_seconds > int(time.time()):
219	236	return False
220		except ValueError: # int() error
	237	except ValueError: # int() error
221	238	pass
222	239	if self.debug:
223	240	TRACE("nonce is stale")
224	241	return True
225	242
226
227	243	def HA2(self, entity_body=''):
228	244	"""Returns the H(A2) string. See :rfc:`2617` section 3.2.2.3."""
229	245	# RFC 2617 3.2.2.3
230		# If the "qop" directive's value is "auth" or is unspecified, then A2 is:
	246	# If the "qop" directive's value is "auth" or is unspecified,
	247	# then A2 is:
231	248	# A2 = method ":" digest-uri-value
232	249	#
233	250	# If the "qop" value is "auth-int", then A2 is:

237	254	elif self.qop == "auth-int":
238	255	a2 = "%s:%s:%s" % (self.http_method, self.uri, H(entity_body))
239	256	else:
240		# in theory, this should never happen, since I validate qop in __init__()
	257	# in theory, this should never happen, since I validate qop in
	258	# __init__()
241	259	raise ValueError(self.errmsg("Unrecognized value for qop!"))
242	260	return H(a2)
243
244	261
245	262	def request_digest(self, ha1, entity_body=''):
246	263	"""Calculates the Request-Digest. See :rfc:`2617` section 3.2.2.1.

252	269	If 'qop' is set to 'auth-int', then A2 includes a hash
253	270	of the "entity body". The entity body is the part of the
254	271	message which follows the HTTP headers. See :rfc:`2617` section
255		4.3. This refers to the entity the user agent sent in the request which
256		has the Authorization header. Typically GET requests don't have an entity,
257		and POST requests do.
258
	272	4.3. This refers to the entity the user agent sent in the
	273	request which has the Authorization header. Typically GET
	274	requests don't have an entity, and POST requests do.
	275
259	276	"""
260	277	ha2 = self.HA2(entity_body)
261	278	# Request-Digest -- RFC 2617 3.2.2.1
262	279	if self.qop:
263		req = "%s:%s:%s:%s:%s" % (self.nonce, self.nc, self.cnonce, self.qop, ha2)
	280	req = "%s:%s:%s:%s:%s" % (
	281	self.nonce, self.nc, self.cnonce, self.qop, ha2)
264	282	else:
265	283	req = "%s:%s" % (self.nonce, ha2)
266	284
267	285	# RFC 2617 3.2.2.2
268	286	#
269		# If the "algorithm" directive's value is "MD5" or is unspecified, then A1 is:
270		# A1 = unq(username-value) ":" unq(realm-value) ":" passwd
	287	# If the "algorithm" directive's value is "MD5" or is unspecified,
	288	# then A1 is:
	289	# A1 = unq(username-value) ":" unq(realm-value) ":" passwd
271	290	#
272	291	# If the "algorithm" directive's value is "MD5-sess", then A1 is
273	292	# calculated only once - on the first request by the client following

281	300	return digest
282	301
283	302
284
285		def www_authenticate(realm, key, algorithm='MD5', nonce=None, qop=qop_auth, stale=False):
	303	def www_authenticate(realm, key, algorithm='MD5', nonce=None, qop=qop_auth,
	304	stale=False):
286	305	"""Constructs a WWW-Authenticate header for Digest authentication."""
287	306	if qop not in valid_qops:
288	307	raise ValueError("Unsupported value for qop: '%s'" % qop)

292	311	if nonce is None:
293	312	nonce = synthesize_nonce(realm, key)
294	313	s = 'Digest realm="%s", nonce="%s", algorithm="%s", qop="%s"' % (
295		realm, nonce, algorithm, qop)
	314	realm, nonce, algorithm, qop)
296	315	if stale:
297	316	s += ', stale="true"'
298	317	return s

301	320	def digest_auth(realm, get_ha1, key, debug=False):
302	321	"""A CherryPy tool which hooks at before_handler to perform
303	322	HTTP Digest Access Authentication, as specified in :rfc:`2617`.
304
305		If the request has an 'authorization' header with a 'Digest' scheme, this
306		tool authenticates the credentials supplied in that header. If
307		the request has no 'authorization' header, or if it does but the scheme is
308		not "Digest", or if authentication fails, the tool sends a 401 response with
309		a 'WWW-Authenticate' Digest header.
310
	323
	324	If the request has an 'authorization' header with a 'Digest' scheme,
	325	this tool authenticates the credentials supplied in that header.
	326	If the request has no 'authorization' header, or if it does but the
	327	scheme is not "Digest", or if authentication fails, the tool sends
	328	a 401 response with a 'WWW-Authenticate' Digest header.
	329
311	330	realm
312	331	A string containing the authentication realm.
313
	332
314	333	get_ha1
315	334	A callable which looks up a username in a credentials store
316	335	and returns the HA1 string, which is defined in the RFC to be

319	338	where username is obtained from the request's 'authorization' header.
320	339	If username is not found in the credentials store, get_ha1() returns
321	340	None.
322
	341
323	342	key
324		A secret string known only to the server, used in the synthesis of nonces.
325
	343	A secret string known only to the server, used in the synthesis
	344	of nonces.
	345
326	346	"""
327	347	request = cherrypy.serving.request
328
	348
329	349	auth_header = request.headers.get('authorization')
330	350	nonce_is_stale = False
331	351	if auth_header is not None:
332	352	try:
333		auth = HttpDigestAuthorization(auth_header, request.method, debug=debug)
	353	auth = HttpDigestAuthorization(
	354	auth_header, request.method, debug=debug)
334	355	except ValueError:
335		raise cherrypy.HTTPError(400, "The Authorization header could not be parsed.")
336
	356	raise cherrypy.HTTPError(
	357	400, "The Authorization header could not be parsed.")
	358
337	359	if debug:
338	360	TRACE(str(auth))
339
	361
340	362	if auth.validate_nonce(realm, key):
341	363	ha1 = get_ha1(realm, auth.username)
342	364	if ha1 is not None:
343		# note that for request.body to be available we need to hook in at
344		# before_handler, not on_start_resource like 3.1.x digest_auth does.
	365	# note that for request.body to be available we need to
	366	# hook in at before_handler, not on_start_resource like
	367	# 3.1.x digest_auth does.
345	368	digest = auth.request_digest(ha1, entity_body=request.body)
346		if digest == auth.response: # authenticated
	369	if digest == auth.response: # authenticated
347	370	if debug:
348	371	TRACE("digest matches auth.response")
349	372	# Now check if nonce is stale.
350		# The choice of ten minutes' lifetime for nonce is somewhat arbitrary
	373	# The choice of ten minutes' lifetime for nonce is somewhat
	374	# arbitrary
351	375	nonce_is_stale = auth.is_nonce_stale(max_age_seconds=600)
352	376	if not nonce_is_stale:
353	377	request.login = auth.username
354	378	if debug:
355		TRACE("authentication of %s successful" % auth.username)
	379	TRACE("authentication of %s successful" %
	380	auth.username)
356	381	return
357
	382
358	383	# Respond with 401 status and a WWW-Authenticate header
359	384	header = www_authenticate(realm, key, stale=nonce_is_stale)
360	385	if debug:
361	386	TRACE(header)
362	387	cherrypy.serving.response.headers['WWW-Authenticate'] = header
363		raise cherrypy.HTTPError(401, "You are not authorized to access that resource")
364
	388	raise cherrypy.HTTPError(
	389	401, "You are not authorized to access that resource")

+83

-78

cherrypy/lib/caching.py less more

0	0	"""
1		CherryPy implements a simple caching system as a pluggable Tool. This tool tries
2		to be an (in-process) HTTP/1.1-compliant cache. It's not quite there yet, but
3		it's probably good enough for most sites.
	1	CherryPy implements a simple caching system as a pluggable Tool. This tool
	2	tries to be an (in-process) HTTP/1.1-compliant cache. It's not quite there
	3	yet, but it's probably good enough for most sites.
4	4
5	5	In general, GET responses are cached (along with selecting headers) and, if
6	6	another request arrives for the same resource, the caching Tool will return 304

8	8	request.cached to True if serving a cached representation, and sets
9	9	request.cacheable to False (so it doesn't get cached again).
10	10
11		If POST, PUT, or DELETE requests are made for a cached resource, they invalidate
12		(delete) any cached response.
	11	If POST, PUT, or DELETE requests are made for a cached resource, they
	12	invalidate (delete) any cached response.
13	13
14	14	Usage
15	15	=====

38	38
39	39	import cherrypy
40	40	from cherrypy.lib import cptools, httputil
41		from cherrypy._cpcompat import copyitems, ntob, set_daemon, sorted
	41	from cherrypy._cpcompat import copyitems, ntob, set_daemon, sorted, Event
42	42
43	43
44	44	class Cache(object):
	45
45	46	"""Base class for Cache implementations."""
46
	47
47	48	def get(self):
48	49	"""Return the current variant if in the cache, else None."""
49	50	raise NotImplemented
50
	51
51	52	def put(self, obj, size):
52	53	"""Store the current variant in the cache."""
53	54	raise NotImplemented
54
	55
55	56	def delete(self):
56	57	"""Remove ALL cached variants of the current resource."""
57	58	raise NotImplemented
58
	59
59	60	def clear(self):
60	61	"""Reset the cache to its initial, empty state."""
61	62	raise NotImplemented
62	63
63	64
64
65		# ------------------------------- Memory Cache ------------------------------- #
66
67
	65	# ------------------------------ Memory Cache ------------------------------- #
68	66	class AntiStampedeCache(dict):
	67
69	68	"""A storage system for cached items which reduces stampede collisions."""
70
	69
71	70	def wait(self, key, timeout=5, debug=False):
72	71	"""Return the cached value for the given key, or None.
73
	72
74	73	If timeout is not None, and the value is already
75	74	being calculated by another thread, wait until the given timeout has
76	75	elapsed. If the value is available before the timeout expires, it is
77	76	returned. If not, None is returned, and a sentinel placed in the cache
78	77	to signal other threads to wait.
79
	78
80	79	If timeout is None, no waiting is performed nor sentinels used.
81	80	"""
82	81	value = self.get(key)
83		if isinstance(value, threading._Event):
	82	if isinstance(value, Event):
84	83	if timeout is None:
85	84	# Ignore the other thread and recalc it ourselves.
86	85	if debug:
87	86	cherrypy.log('No timeout', 'TOOLS.CACHING')
88	87	return None
89
	88
90	89	# Wait until it's done or times out.
91	90	if debug:
92		cherrypy.log('Waiting up to %s seconds' % timeout, 'TOOLS.CACHING')
	91	cherrypy.log('Waiting up to %s seconds' %
	92	timeout, 'TOOLS.CACHING')
93	93	value.wait(timeout)
94	94	if value.result is not None:
95	95	# The other thread finished its calculation. Use it.

103	103	e = threading.Event()
104	104	e.result = None
105	105	dict.__setitem__(self, key, e)
106
	106
107	107	return None
108	108	elif value is None:
109	109	# Stick an Event in the slot so other threads wait

114	114	e.result = None
115	115	dict.__setitem__(self, key, e)
116	116	return value
117
	117
118	118	def __setitem__(self, key, value):
119	119	"""Set the cached value for the given key."""
120	120	existing = self.get(key)
121	121	dict.__setitem__(self, key, value)
122		if isinstance(existing, threading._Event):
	122	if isinstance(existing, Event):
123	123	# Set Event.result so other threads waiting on it have
124	124	# immediate access without needing to poll the cache again.
125	125	existing.result = value

127	127
128	128
129	129	class MemoryCache(Cache):
	130
130	131	"""An in-memory cache for varying response content.
131
	132
132	133	Each key in self.store is a URI, and each value is an AntiStampedeCache.
133	134	The response for any given URI may vary based on the values of
134	135	"selecting request headers"; that is, those named in the Vary
135	136	response header. We assume the list of header names to be constant
136	137	for each URI throughout the lifetime of the application, and store
137	138	that list in ``self.store[uri].selecting_headers``.
138
	139
139	140	The items contained in ``self.store[uri]`` have keys which are tuples of
140	141	request header values (in the same order as the names in its
141	142	selecting_headers), and values which are the actual responses.
142	143	"""
143
	144
144	145	maxobjects = 1000
145	146	"""The maximum number of cached objects; defaults to 1000."""
146
	147
147	148	maxobj_size = 100000
148	149	"""The maximum size of each cached object in bytes; defaults to 100 KB."""
149
	150
150	151	maxsize = 10000000
151	152	"""The maximum size of the entire cache in bytes; defaults to 10 MB."""
152
	153
153	154	delay = 600
154		"""Seconds until the cached content expires; defaults to 600 (10 minutes)."""
155
	155	"""Seconds until the cached content expires; defaults to 600 (10 minutes).
	156	"""
	157
156	158	antistampede_timeout = 5
157	159	"""Seconds to wait for other threads to release a cache lock."""
158
	160
159	161	expire_freq = 0.1
160	162	"""Seconds to sleep between cache expiration sweeps."""
161
	163
162	164	debug = False
163
	165
164	166	def __init__(self):
165	167	self.clear()
166
	168
167	169	# Run self.expire_cache in a separate daemon thread.
168	170	t = threading.Thread(target=self.expire_cache, name='expire_cache')
169	171	self.expiration_thread = t
170	172	set_daemon(t, True)
171	173	t.start()
172
	174
173	175	def clear(self):
174	176	"""Reset the cache to its initial, empty state."""
175	177	self.store = {}

180	182	self.tot_expires = 0
181	183	self.tot_non_modified = 0
182	184	self.cursize = 0
183
	185
184	186	def expire_cache(self):
185	187	"""Continuously examine cached objects, expiring stale ones.
186
	188
187	189	This function is designed to be run in its own daemon thread,
188	190	referenced at ``self.expiration_thread``.
189	191	"""

206	208	pass
207	209	del self.expirations[expiration_time]
208	210	time.sleep(self.expire_freq)
209
	211
210	212	def get(self):
211	213	"""Return the current variant if in the cache, else None."""
212	214	request = cherrypy.serving.request
213	215	self.tot_gets += 1
214
	216
215	217	uri = cherrypy.url(qs=request.query_string)
216	218	uricache = self.store.get(uri)
217	219	if uricache is None:
218	220	return None
219
	221
220	222	header_values = [request.headers.get(h, '')
221	223	for h in uricache.selecting_headers]
222	224	variant = uricache.wait(key=tuple(sorted(header_values)),

225	227	if variant is not None:
226	228	self.tot_hist += 1
227	229	return variant
228
	230
229	231	def put(self, variant, size):
230	232	"""Store the current variant in the cache."""
231	233	request = cherrypy.serving.request
232	234	response = cherrypy.serving.response
233
	235
234	236	uri = cherrypy.url(qs=request.query_string)
235	237	uricache = self.store.get(uri)
236	238	if uricache is None:

238	240	uricache.selecting_headers = [
239	241	e.value for e in response.headers.elements('Vary')]
240	242	self.store[uri] = uricache
241
	243
242	244	if len(self.store) < self.maxobjects:
243	245	total_size = self.cursize + size
244
	246
245	247	# checks if there's space for the object
246	248	if (size < self.maxobj_size and total_size < self.maxsize):
247	249	# add to the expirations list
248	250	expiration_time = response.time + self.delay
249	251	bucket = self.expirations.setdefault(expiration_time, [])
250	252	bucket.append((size, uri, uricache.selecting_headers))
251
	253
252	254	# add to the cache
253	255	header_values = [request.headers.get(h, '')
254	256	for h in uricache.selecting_headers]
255	257	uricache[tuple(sorted(header_values))] = variant
256	258	self.tot_puts += 1
257	259	self.cursize = total_size
258
	260
259	261	def delete(self):
260	262	"""Remove ALL cached variants of the current resource."""
261	263	uri = cherrypy.url(qs=cherrypy.serving.request.query_string)

264	266
265	267	def get(invalid_methods=("POST", "PUT", "DELETE"), debug=False, **kwargs):
266	268	"""Try to obtain cached output. If fresh enough, raise HTTPError(304).
267
	269
268	270	If POST, PUT, or DELETE:
269	271	* invalidates (deletes) any cached response for this resource
270	272	* sets request.cached = False
271	273	* sets request.cacheable = False
272
	274
273	275	else if a cached copy exists:
274	276	* sets request.cached = True
275	277	* sets request.cacheable = False

279	281	if necessary.
280	282	* sets response.status and response.body to the cached values
281	283	* returns True
282
	284
283	285	otherwise:
284	286	* sets request.cached = False
285	287	* sets request.cacheable = True

287	289	"""
288	290	request = cherrypy.serving.request
289	291	response = cherrypy.serving.response
290
	292
291	293	if not hasattr(cherrypy, "_cache"):
292	294	# Make a process-wide Cache object.
293	295	cherrypy._cache = kwargs.pop("cache_class", MemoryCache)()
294
	296
295	297	# Take all remaining kwargs and set them on the Cache object.
296	298	for k, v in kwargs.items():
297	299	setattr(cherrypy._cache, k, v)
298	300	cherrypy._cache.debug = debug
299
	301
300	302	# POST, PUT, DELETE should invalidate (delete) the cached copy.
301	303	# See http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.10.
302	304	if request.method in invalid_methods:

307	309	request.cached = False
308	310	request.cacheable = False
309	311	return False
310
	312
311	313	if 'no-cache' in [e.value for e in request.headers.elements('Pragma')]:
312	314	request.cached = False
313	315	request.cacheable = True
314	316	return False
315
	317
316	318	cache_data = cherrypy._cache.get()
317	319	request.cached = bool(cache_data)
318	320	request.cacheable = not request.cached

324	326	directive = atoms.pop(0)
325	327	if directive == 'max-age':
326	328	if len(atoms) != 1 or not atoms[0].isdigit():
327		raise cherrypy.HTTPError(400, "Invalid Cache-Control header")
	329	raise cherrypy.HTTPError(
	330	400, "Invalid Cache-Control header")
328	331	max_age = int(atoms[0])
329	332	break
330	333	elif directive == 'no-cache':
331	334	if debug:
332		cherrypy.log('Ignoring cache due to Cache-Control: no-cache',
333		'TOOLS.CACHING')
	335	cherrypy.log(
	336	'Ignoring cache due to Cache-Control: no-cache',
	337	'TOOLS.CACHING')
334	338	request.cached = False
335	339	request.cacheable = True
336	340	return False
337
	341
338	342	if debug:
339	343	cherrypy.log('Reading response from cache', 'TOOLS.CACHING')
340	344	s, h, b, create_time = cache_data

346	350	request.cached = False
347	351	request.cacheable = True
348	352	return False
349
350		# Copy the response headers. See http://www.cherrypy.org/ticket/721.
	353
	354	# Copy the response headers. See
	355	# https://bitbucket.org/cherrypy/cherrypy/issue/721.
351	356	response.headers = rh = httputil.HeaderMap()
352	357	for k in h:
353	358	dict.__setitem__(rh, k, dict.__getitem__(h, k))
354
	359
355	360	# Add the required Age header
356	361	response.headers["Age"] = str(age)
357
	362
358	363	try:
359	364	# Note that validate_since depends on a Last-Modified header;
360	365	# this was put into the cached copy, and should have been

365	370	if x.status == 304:
366	371	cherrypy._cache.tot_non_modified += 1
367	372	raise
368
	373
369	374	# serve it & get out from the request
370	375	response.status = s
371	376	response.body = b

378	383	def tee_output():
379	384	"""Tee response output to cache storage. Internal."""
380	385	# Used by CachingTool by attaching to request.hooks
381
	386
382	387	request = cherrypy.serving.request
383	388	if 'no-store' in request.headers.values('Cache-Control'):
384	389	return
385
	390
386	391	def tee(body):
387	392	"""Tee response.body into a list."""
388	393	if ('no-cache' in response.headers.values('Pragma') or
389		'no-store' in response.headers.values('Cache-Control')):
	394	'no-store' in response.headers.values('Cache-Control')):
390	395	for chunk in body:
391	396	yield chunk
392	397	return
393
	398
394	399	output = []
395	400	for chunk in body:
396	401	output.append(chunk)
397	402	yield chunk
398
	403
399	404	# save the cache data
400	405	body = ntob('').join(output)
401	406	cherrypy._cache.put((response.status, response.headers or {},
402	407	body, response.time), len(body))
403
	408
404	409	response = cherrypy.serving.response
405	410	response.body = tee(response.body)
406	411

414	419	expire. The 'Expires' header will be set to response.time + secs.
415	420	If secs is zero, the 'Expires' header is set one year in the past, and
416	421	the following "cache prevention" headers are also set:
417
	422
418	423	* Pragma: no-cache
419	424	* Cache-Control': no-cache, must-revalidate
420	425
421	426	force
422	427	If False, the following headers are checked:
423
	428
424	429	* Etag
425	430	* Last-Modified
426	431	* Age
427	432	* Expires
428
	433
429	434	If any are already present, none of the above response headers are set.
430
	435
431	436	"""
432
	437
433	438	response = cherrypy.serving.response
434	439	headers = response.headers
435
	440
436	441	cacheable = False
437	442	if not force:
438	443	# some header names that indicate that the response can be cached

440	445	if indicator in headers:
441	446	cacheable = True
442	447	break
443
	448
444	449	if not cacheable and not force:
445	450	if debug:
446	451	cherrypy.log('request is not cacheable', 'TOOLS.EXPIRES')

449	454	cherrypy.log('request is cacheable', 'TOOLS.EXPIRES')
450	455	if isinstance(secs, datetime.timedelta):
451	456	secs = (86400 * secs.days) + secs.seconds
452
	457
453	458	if secs == 0:
454	459	if force or ("Pragma" not in headers):
455	460	headers["Pragma"] = "no-cache"

+61

-39

cherrypy/lib/covercp.py less more

0	0	"""Code-coverage tools for CherryPy.
1	1
2	2	To use this module, or the coverage tools in the test suite,
3		you need to download 'coverage.py', either Gareth Rees' `original
	3	you need to download 'coverage.py', either Gareth Rees' `original
4	4	implementation <http://www.garethrees.org/2001/12/04/python-coverage/>`_
5	5	or Ned Batchelder's `enhanced version:
6	6	<http://www.nedbatchelder.com/code/modules/coverage.html>`_

23	23	import sys
24	24	import cgi
25	25	from cherrypy._cpcompat import quote_plus
26		import os, os.path
	26	import os
	27	import os.path
27	28	localFile = os.path.join(os.path.dirname(__file__), "coverage.cache")
28	29
29	30	the_coverage = None
30	31	try:
31	32	from coverage import coverage
32	33	the_coverage = coverage(data_file=localFile)
	34
33	35	def start():
34	36	the_coverage.start()
35	37	except ImportError:
36	38	# Setting the_coverage to None will raise errors
37	39	# that need to be trapped downstream.
38	40	the_coverage = None
39
	41
40	42	import warnings
41		warnings.warn("No code coverage will be performed; coverage.py could not be imported.")
42
	43	warnings.warn(
	44	"No code coverage will be performed; "
	45	"coverage.py could not be imported.")
	46
43	47	def start():
44	48	pass
45	49	start.priority = 20

68	72	font-size: small;
69	73	font-weight: bold;
70	74	font-style: italic;
71		margin-top: 5px;
	75	margin-top: 5px;
72	76	}
73	77	input { border: 1px solid #ccc; padding: 2px; }
74	78	.directory {

117	121	<div id="options">
118	122	<form action='menu' method=GET>
119	123	<input type='hidden' name='base' value='%(base)s' />
120		Show percentages <input type='checkbox' %(showpct)s name='showpct' value='checked' /><br />
121		Hide files over <input type='text' id='pct' name='pct' value='%(pct)s' size='3' />%%<br />
	124	Show percentages
	125	<input type='checkbox' %(showpct)s name='showpct' value='checked' /><br />
	126	Hide files over
	127	<input type='text' id='pct' name='pct' value='%(pct)s' size='3' />%%<br />
122	128	Exclude files matching<br />
123		<input type='text' id='exclude' name='exclude' value='%(exclude)s' size='20' />
	129	<input type='text' id='exclude' name='exclude'
	130	value='%(exclude)s' size='20' />
124	131	<br />
125	132
126	133	<input type='submit' value='Change view' id="submit"/>
127	134	</form>
128		</div>"""
	135	</div>"""
129	136
130	137	TEMPLATE_FRAMESET = """<html>
131	138	<head><title>CherryPy coverage data</title></head>

172	179	<td>%s</td>
173	180	</tr>\n"""
174	181
175		TEMPLATE_ITEM = "%s%s<a class='file' href='report?name=%s' target='main'>%s</a>\n"
	182	TEMPLATE_ITEM = (
	183	"%s%s<a class='file' href='report?name=%s' target='main'>%s</a>\n"
	184	)
	185
176	186
177	187	def _percent(statements, missing):
178	188	s = len(statements)

181	191	return int(round(100.0 * e / s))
182	192	return 0
183	193
	194
184	195	def _show_branch(root, base, path, pct=0, showpct=False, exclude="",
185	196	coverage=the_coverage):
186
	197
187	198	# Show the directory name and any of our children
188	199	dirs = [k for k, v in root.items() if v]
189	200	dirs.sort()
190	201	for name in dirs:
191	202	newpath = os.path.join(path, name)
192
	203
193	204	if newpath.lower().startswith(base):
194	205	relpath = newpath[len(base):]
195	206	yield "\| " * relpath.count(os.sep)
196		yield "<a class='directory' href='menu?base=%s&exclude=%s'>%s</a>\n" % \
197		(newpath, quote_plus(exclude), name)
198
199		for chunk in _show_branch(root[name], base, newpath, pct, showpct, exclude, coverage=coverage):
	207	yield (
	208	"<a class='directory' "
	209	"href='menu?base=%s&exclude=%s'>%s</a>\n" %
	210	(newpath, quote_plus(exclude), name)
	211	)
	212
	213	for chunk in _show_branch(
	214	root[name], base, newpath, pct, showpct,
	215	exclude, coverage=coverage
	216	):
200	217	yield chunk
201
	218
202	219	# Now list the files
203	220	if path.lower().startswith(base):
204	221	relpath = path[len(base):]

206	223	files.sort()
207	224	for name in files:
208	225	newpath = os.path.join(path, name)
209
	226
210	227	pc_str = ""
211	228	if showpct:
212	229	try:

216	233	pass
217	234	else:
218	235	pc = _percent(statements, missing)
219		pc_str = ("%3d%% " % pc).replace(' ',' ')
	236	pc_str = ("%3d%% " % pc).replace(' ', ' ')
220	237	if pc < float(pct) or pc == -1:
221	238	pc_str = "<span class='fail'>%s</span>" % pc_str
222	239	else:
223	240	pc_str = "<span class='pass'>%s</span>" % pc_str
224
	241
225	242	yield TEMPLATE_ITEM % ("\| " * (relpath.count(os.sep) + 1),
226	243	pc_str, newpath, name)
	244
227	245
228	246	def _skip_file(path, exclude):
229	247	if exclude:
230	248	return bool(re.search(exclude, path))
231	249
	250
232	251	def _graft(path, tree):
233	252	d = tree
234
	253
235	254	p = path
236	255	atoms = []
237	256	while True:

242	261	atoms.append(p)
243	262	if p != "/":
244	263	atoms.append("/")
245
	264
246	265	atoms.reverse()
247	266	for node in atoms:
248	267	if node:
249	268	d = d.setdefault(node, {})
	269
250	270
251	271	def get_tree(base, exclude, coverage=the_coverage):
252	272	"""Return covered module names as a nested dict."""

257	277	_graft(path, tree)
258	278	return tree
259	279
	280
260	281	class CoverStats(object):
261
	282
262	283	def __init__(self, coverage, root=None):
263	284	self.coverage = coverage
264	285	if root is None:

267	288	import cherrypy
268	289	root = os.path.dirname(cherrypy.__file__)
269	290	self.root = root
270
	291
271	292	def index(self):
272	293	return TEMPLATE_FRAMESET % self.root.lower()
273	294	index.exposed = True
274
	295
275	296	def menu(self, base="/", pct="50", showpct="",
276	297	exclude=r'python\d\.\d\|test\|tut\d\|tutorial'):
277
	298
278	299	# The coverage module uses all-lower-case names.
279	300	base = base.lower().rstrip(os.sep)
280
	301
281	302	yield TEMPLATE_MENU
282	303	yield TEMPLATE_FORM % locals()
283
	304
284	305	# Start by showing links for parent paths
285	306	yield "<div id='crumbs'>"
286	307	path = ""

291	312	yield ("<a href='menu?base=%s&exclude=%s'>%s</a> %s"
292	313	% (path, quote_plus(exclude), atom, os.sep))
293	314	yield "</div>"
294
	315
295	316	yield "<div id='tree'>"
296
	317
297	318	# Then display the tree
298	319	tree = get_tree(base, exclude, self.coverage)
299	320	if not tree:
300	321	yield "<p>No modules covered.</p>"
301	322	else:
302	323	for chunk in _show_branch(tree, base, "/", pct,
303		showpct=='checked', exclude, coverage=self.coverage):
	324	showpct == 'checked', exclude,
	325	coverage=self.coverage):
304	326	yield chunk
305
	327
306	328	yield "</div>"
307	329	yield "</body></html>"
308	330	menu.exposed = True
309
	331
310	332	def annotated_file(self, filename, statements, excluded, missing):
311	333	source = open(filename, 'r')
312	334	buffer = []

328	350	yield template % (lno, cgi.escape(pastline))
329	351	buffer = []
330	352	yield template % (lineno, cgi.escape(line))
331
	353
332	354	def report(self, name):
333		filename, statements, excluded, missing, _ = self.coverage.analysis2(name)
	355	filename, statements, excluded, missing, _ = self.coverage.analysis2(
	356	name)
334	357	pc = _percent(statements, missing)
335	358	yield TEMPLATE_COVERAGE % dict(name=os.path.basename(name),
336	359	fullpath=name,

349	372	if coverage is None:
350	373	raise ImportError("The coverage module could not be imported.")
351	374	from coverage import coverage
352		cov = coverage(data_file = path)
	375	cov = coverage(data_file=path)
353	376	cov.load()
354
	377
355	378	import cherrypy
356	379	cherrypy.config.update({'server.socket_port': int(port),
357	380	'server.thread_pool': 10,

361	384
362	385	if __name__ == "__main__":
363	386	serve(*tuple(sys.argv[1:]))
364

+139

-114

cherrypy/lib/cpstats.py less more

20	20	re-use the `logging` module by adding a `statistics` object to it.
21	21
22	22	That `logging.statistics` object is a nested dict. It is not a custom class,
23		because that would 1) require libraries and applications to import a third-
24		party module in order to participate, 2) inhibit innovation in extrapolation
25		approaches and in reporting tools, and 3) be slow. There are, however, some
26		specifications regarding the structure of the dict.
27
28		{
29		+----"SQLAlchemy": {
30		\| "Inserts": 4389745,
31		\| "Inserts per Second":
32		\| lambda s: s["Inserts"] / (time() - s["Start"]),
33		\| C +---"Table Statistics": {
34		\| o \| "widgets": {-----------+
35		N \| l \| "Rows": 1.3M, \| Record
36		a \| l \| "Inserts": 400, \|
37		m \| e \| },---------------------+
38		e \| c \| "froobles": {
39		s \| t \| "Rows": 7845,
40		p \| i \| "Inserts": 0,
41		a \| o \| },
42		c \| n +---},
43		e \| "Slow Queries":
44		\| [{"Query": "SELECT * FROM widgets;",
45		\| "Processing Time": 47.840923343,
46		\| },
47		\| ],
48		+----},
49		}
	23	because that would:
	24
	25	1. require libraries and applications to import a third-party module in
	26	order to participate
	27	2. inhibit innovation in extrapolation approaches and in reporting tools, and
	28	3. be slow.
	29
	30	There are, however, some specifications regarding the structure of the dict.::
	31
	32	{
	33	+----"SQLAlchemy": {
	34	\| "Inserts": 4389745,
	35	\| "Inserts per Second":
	36	\| lambda s: s["Inserts"] / (time() - s["Start"]),
	37	\| C +---"Table Statistics": {
	38	\| o \| "widgets": {-----------+
	39	N \| l \| "Rows": 1.3M, \| Record
	40	a \| l \| "Inserts": 400, \|
	41	m \| e \| },---------------------+
	42	e \| c \| "froobles": {
	43	s \| t \| "Rows": 7845,
	44	p \| i \| "Inserts": 0,
	45	a \| o \| },
	46	c \| n +---},
	47	e \| "Slow Queries":
	48	\| [{"Query": "SELECT * FROM widgets;",
	49	\| "Processing Time": 47.840923343,
	50	\| },
	51	\| ],
	52	+----},
	53	}
50	54
51	55	The `logging.statistics` dict has four levels. The topmost level is nothing
52	56	more than a set of names to introduce modularity, usually along the lines of

64	68	good on a report: spaces and capitalization are just fine.
65	69
66	70	In addition to scalars, values in a namespace MAY be a (third-layer)
67		dict, or a list, called a "collection". For example, the CherryPy StatsTool
68		keeps track of what each request is doing (or has most recently done)
69		in a 'Requests' collection, where each key is a thread ID; each
	71	dict, or a list, called a "collection". For example, the CherryPy
	72	:class:`StatsTool` keeps track of what each request is doing (or has most
	73	recently done) in a 'Requests' collection, where each key is a thread ID; each
70	74	value in the subdict MUST be a fourth dict (whew!) of statistical data about
71	75	each thread. We call each subdict in the collection a "record". Similarly,
72		the StatsTool also keeps a list of slow queries, where each record contains
73		data about each slow query, in order.
	76	the :class:`StatsTool` also keeps a list of slow queries, where each record
	77	contains data about each slow query, in order.
74	78
75	79	Values in a namespace or record may also be functions, which brings us to:
76	80

85	89
86	90	When it comes time to report on the gathered data, however, we usually have
87	91	much more freedom in what we can calculate. Therefore, whenever reporting
88		tools (like the provided StatsPage CherryPy class) fetch the contents of
89		`logging.statistics` for reporting, they first call `extrapolate_statistics`
90		(passing the whole `statistics` dict as the only argument). This makes a
91		deep copy of the statistics dict so that the reporting tool can both iterate
92		over it and even change it without harming the original. But it also expands
93		any functions in the dict by calling them. For example, you might have a
94		'Current Time' entry in the namespace with the value "lambda scope: time.time()".
95		The "scope" parameter is the current namespace dict (or record, if we're
96		currently expanding one of those instead), allowing you access to existing
97		static entries. If you're truly evil, you can even modify more than one entry
98		at a time.
	92	tools (like the provided :class:`StatsPage` CherryPy class) fetch the contents
	93	of `logging.statistics` for reporting, they first call
	94	`extrapolate_statistics` (passing the whole `statistics` dict as the only
	95	argument). This makes a deep copy of the statistics dict so that the
	96	reporting tool can both iterate over it and even change it without harming
	97	the original. But it also expands any functions in the dict by calling them.
	98	For example, you might have a 'Current Time' entry in the namespace with the
	99	value "lambda scope: time.time()". The "scope" parameter is the current
	100	namespace dict (or record, if we're currently expanding one of those
	101	instead), allowing you access to existing static entries. If you're truly
	102	evil, you can even modify more than one entry at a time.
99	103
100	104	However, don't try to calculate an entry and then use its value in further
101	105	extrapolations; the order in which the functions are called is not guaranteed.

107	111	Reporting
108	112	---------
109	113
110		The StatsPage class grabs the `logging.statistics` dict, extrapolates it all,
111		and then transforms it to HTML for easy viewing. Each namespace gets its own
112		header and attribute table, plus an extra table for each collection. This is
113		NOT part of the statistics specification; other tools can format how they like.
	114	The :class:`StatsPage` class grabs the `logging.statistics` dict, extrapolates
	115	it all, and then transforms it to HTML for easy viewing. Each namespace gets
	116	its own header and attribute table, plus an extra table for each collection.
	117	This is NOT part of the statistics specification; other tools can format how
	118	they like.
114	119
115	120	You can control which columns are output and how they are formatted by updating
116	121	StatsPage.formatting, which is a dict that mirrors the keys and nesting of
117	122	`logging.statistics`. The difference is that, instead of data values, it has
118	123	formatting values. Use None for a given key to indicate to the StatsPage that a
119		given column should not be output. Use a string with formatting (such as '%.3f')
120		to interpolate the value(s), or use a callable (such as lambda v: v.isoformat())
121		for more advanced formatting. Any entry which is not mentioned in the formatting
122		dict is output unchanged.
	124	given column should not be output. Use a string with formatting
	125	(such as '%.3f') to interpolate the value(s), or use a callable (such as
	126	lambda v: v.isoformat()) for more advanced formatting. Any entry which is not
	127	mentioned in the formatting dict is output unchanged.
123	128
124	129	Monitoring
125	130	----------

144	149	Usage
145	150	=====
146	151
147		To collect statistics on CherryPy applications:
	152	To collect statistics on CherryPy applications::
148	153
149	154	from cherrypy.lib import cpstats
150	155	appconfig['/']['tools.cpstats.on'] = True
151	156
152		To collect statistics on your own code:
	157	To collect statistics on your own code::
153	158
154	159	import logging
155	160	# Initialize the repository

171	176	if mystats.get('Enabled', False):
172	177	mystats['Important Events'] += 1
173	178
174		To report statistics:
	179	To report statistics::
175	180
176	181	root.cpstats = cpstats.StatsPage()
177	182
178		To format statistics reports:
	183	To format statistics reports::
179	184
180	185	See 'Reporting', above.
181	186
182	187	"""
183	188
184		# -------------------------------- Statistics -------------------------------- #
	189	# ------------------------------- Statistics -------------------------------- #
185	190
186	191	import logging
187		if not hasattr(logging, 'statistics'): logging.statistics = {}
	192	if not hasattr(logging, 'statistics'):
	193	logging.statistics = {}
	194
188	195
189	196	def extrapolate_statistics(scope):
190	197	"""Return an extrapolated copy of the given scope."""

200	207	return c
201	208
202	209
203		# --------------------- CherryPy Applications Statistics --------------------- #
	210	# -------------------- CherryPy Applications Statistics --------------------- #
204	211
205	212	import threading
206	213	import time

210	217	appstats = logging.statistics.setdefault('CherryPy Applications', {})
211	218	appstats.update({
212	219	'Enabled': True,
213		'Bytes Read/Request': lambda s: (s['Total Requests'] and
214		(s['Total Bytes Read'] / float(s['Total Requests'])) or 0.0),
	220	'Bytes Read/Request': lambda s: (
	221	s['Total Requests'] and
	222	(s['Total Bytes Read'] / float(s['Total Requests'])) or
	223	0.0
	224	),
215	225	'Bytes Read/Second': lambda s: s['Total Bytes Read'] / s['Uptime'](s),
216		'Bytes Written/Request': lambda s: (s['Total Requests'] and
217		(s['Total Bytes Written'] / float(s['Total Requests'])) or 0.0),
218		'Bytes Written/Second': lambda s: s['Total Bytes Written'] / s['Uptime'](s),
	226	'Bytes Written/Request': lambda s: (
	227	s['Total Requests'] and
	228	(s['Total Bytes Written'] / float(s['Total Requests'])) or
	229	0.0
	230	),
	231	'Bytes Written/Second': lambda s: (
	232	s['Total Bytes Written'] / s['Uptime'](s)
	233	),
219	234	'Current Time': lambda s: time.time(),
220	235	'Current Requests': 0,
221	236	'Requests/Second': lambda s: float(s['Total Requests']) / s['Uptime'](s),

227	242	'Total Time': 0,
228	243	'Uptime': lambda s: time.time() - s['Start Time'],
229	244	'Requests': {},
230		})
	245	})
231	246
232	247	proc_time = lambda s: time.time() - s['Start Time']
233	248
234	249
235	250	class ByteCountWrapper(object):
	251
236	252	"""Wraps a file-like object, counting the number of bytes read."""
237
	253
238	254	def __init__(self, rfile):
239	255	self.rfile = rfile
240	256	self.bytes_read = 0
241
	257
242	258	def read(self, size=-1):
243	259	data = self.rfile.read(size)
244	260	self.bytes_read += len(data)
245	261	return data
246
	262
247	263	def readline(self, size=-1):
248	264	data = self.rfile.readline(size)
249	265	self.bytes_read += len(data)
250	266	return data
251
	267
252	268	def readlines(self, sizehint=0):
253	269	# Shamelessly stolen from StringIO
254	270	total = 0

261	277	break
262	278	line = self.readline()
263	279	return lines
264
	280
265	281	def close(self):
266	282	self.rfile.close()
267
	283
268	284	def __iter__(self):
269	285	return self
270
	286
271	287	def next(self):
272	288	data = self.rfile.next()
273	289	self.bytes_read += len(data)

278	294
279	295
280	296	class StatsTool(cherrypy.Tool):
	297
281	298	"""Record various information about the current request."""
282
	299
283	300	def __init__(self):
284	301	cherrypy.Tool.__init__(self, 'on_end_request', self.record_stop)
285
	302
286	303	def _setup(self):
287	304	"""Hook this tool into cherrypy.request.
288
	305
289	306	The standard CherryPy request object will automatically call this
290	307	method when the tool is "turned on" in config.
291	308	"""
292	309	if appstats.get('Enabled', False):
293	310	cherrypy.Tool._setup(self)
294	311	self.record_start()
295
	312
296	313	def record_start(self):
297	314	"""Record the beginning of a request."""
298	315	request = cherrypy.serving.request
299	316	if not hasattr(request.rfile, 'bytes_read'):
300	317	request.rfile = ByteCountWrapper(request.rfile)
301	318	request.body.fp = request.rfile
302
	319
303	320	r = request.remote
304
	321
305	322	appstats['Current Requests'] += 1
306	323	appstats['Total Requests'] += 1
307	324	appstats['Requests'][threading._get_ident()] = {

314	331	'Request-Line': request.request_line,
315	332	'Response Status': None,
316	333	'Start Time': time.time(),
317		}
318
319		def record_stop(self, uriset=None, slow_queries=1.0, slow_queries_count=100,
320		debug=False, **kwargs):
	334	}
	335
	336	def record_stop(
	337	self, uriset=None, slow_queries=1.0, slow_queries_count=100,
	338	debug=False, **kwargs):
321	339	"""Record the end of a request."""
322	340	resp = cherrypy.serving.response
323	341	w = appstats['Requests'][threading._get_ident()]
324
	342
325	343	r = cherrypy.request.rfile.bytes_read
326	344	w['Bytes Read'] = r
327	345	appstats['Total Bytes Read'] += r
328
	346
329	347	if resp.stream:
330	348	w['Bytes Written'] = 'chunked'
331	349	else:
332	350	cl = int(resp.headers.get('Content-Length', 0))
333	351	w['Bytes Written'] = cl
334	352	appstats['Total Bytes Written'] += cl
335
336		w['Response Status'] = getattr(resp, 'output_status', None) or resp.status
337
	353
	354	w['Response Status'] = getattr(
	355	resp, 'output_status', None) or resp.status
	356
338	357	w['End Time'] = time.time()
339	358	p = w['End Time'] - w['Start Time']
340	359	w['Processing Time'] = p
341	360	appstats['Total Time'] += p
342
	361
343	362	appstats['Current Requests'] -= 1
344
	363
345	364	if debug:
346	365	cherrypy.log('Stats recorded: %s' % repr(w), 'TOOLS.CPSTATS')
347
	366
348	367	if uriset:
349	368	rs = appstats.setdefault('URI Set Tracking', {})
350	369	r = rs.setdefault(uriset, {

356	375	r['Max'] = p
357	376	r['Count'] += 1
358	377	r['Sum'] += p
359
	378
360	379	if slow_queries and p > slow_queries:
361	380	sq = appstats.setdefault('Slow Queries', [])
362	381	sq.append(w.copy())

386	405
387	406	locale_date = lambda v: time.strftime('%c', time.gmtime(v))
388	407	iso_format = lambda v: time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(v))
	408
389	409
390	410	def pause_resume(ns):
391	411	def _pause_resume(enabled):

409	429
410	430
411	431	class StatsPage(object):
412
	432
413	433	formatting = {
414	434	'CherryPy Applications': {
415	435	'Enabled': pause_resume('CherryPy Applications'),

426	446	'End Time': None,
427	447	'Processing Time': '%.3f',
428	448	'Start Time': iso_format,
429		},
	449	},
430	450	'URI Set Tracking': {
431	451	'Avg': '%.3f',
432	452	'Max': '%.3f',
433	453	'Min': '%.3f',
434	454	'Sum': '%.3f',
435		},
	455	},
436	456	'Requests': {
437	457	'Bytes Read': '%s',
438	458	'Bytes Written': '%s',
439	459	'End Time': None,
440	460	'Processing Time': '%.3f',
441	461	'Start Time': None,
442		},
	462	},
443	463	},
444	464	'CherryPy WSGIServer': {
445	465	'Enabled': pause_resume('CherryPy WSGIServer'),

447	467	'Start time': iso_format,
448	468	},
449	469	}
450
451
	470
452	471	def index(self):
453	472	# Transform the raw data into pretty output for HTML
454	473	yield """

499	518	""" % title
500	519	for i, (key, value) in enumerate(scalars):
501	520	colnum = i % 3
502		if colnum == 0: yield """
	521	if colnum == 0:
	522	yield """
503	523	<tr>"""
	524	yield (
	525	"""
	526	<th>%(key)s</th><td id='%(title)s-%(key)s'>%(value)s</td>""" %
	527	vars()
	528	)
	529	if colnum == 2:
	530	yield """
	531	</tr>"""
	532
	533	if colnum == 0:
504	534	yield """
505		<th>%(key)s</th><td id='%(title)s-%(key)s'>%(value)s</td>""" % vars()
506		if colnum == 2: yield """
507		</tr>"""
508
509		if colnum == 0: yield """
510	535	<th></th><td></td>
511	536	<th></th><td></td>
512	537	</tr>"""
513		elif colnum == 1: yield """
	538	elif colnum == 1:
	539	yield """
514	540	<th></th><td></td>
515	541	</tr>"""
516	542	yield """

546	572	</html>
547	573	"""
548	574	index.exposed = True
549
	575
550	576	def get_namespaces(self):
551	577	"""Yield (title, scalars, collections) for each namespace."""
552	578	s = extrapolate_statistics(logging.statistics)

573	599	v = format % v
574	600	scalars.append((k, v))
575	601	yield title, scalars, collections
576
	602
577	603	def get_dict_collection(self, v, formatting):
578	604	"""Return ([headers], [rows]) for the given collection."""
579	605	# E.g., the 'Requests' dict.

587	613	if k3 not in headers:
588	614	headers.append(k3)
589	615	headers.sort()
590
	616
591	617	subrows = []
592	618	for k2, record in sorted(v.items()):
593	619	subrow = [k2]

603	629	v3 = format % v3
604	630	subrow.append(v3)
605	631	subrows.append(subrow)
606
	632
607	633	return headers, subrows
608
	634
609	635	def get_list_collection(self, v, formatting):
610	636	"""Return ([headers], [subrows]) for the given collection."""
611	637	# E.g., the 'Slow Queries' list.

619	645	if k3 not in headers:
620	646	headers.append(k3)
621	647	headers.sort()
622
	648
623	649	subrows = []
624	650	for record in v:
625	651	subrow = []

635	661	v3 = format % v3
636	662	subrow.append(v3)
637	663	subrows.append(subrow)
638
	664
639	665	return headers, subrows
640
	666
641	667	if json is not None:
642	668	def data(self):
643	669	s = extrapolate_statistics(logging.statistics)
644	670	cherrypy.response.headers['Content-Type'] = 'application/json'
645	671	return json.dumps(s, sort_keys=True, indent=4)
646	672	data.exposed = True
647
	673
648	674	def pause(self, namespace):
649	675	logging.statistics.get(namespace, {})['Enabled'] = False
650	676	raise cherrypy.HTTPRedirect('./')
651	677	pause.exposed = True
652	678	pause.cp_config = {'tools.allow.on': True,
653	679	'tools.allow.methods': ['POST']}
654
	680
655	681	def resume(self, namespace):
656	682	logging.statistics.get(namespace, {})['Enabled'] = True
657	683	raise cherrypy.HTTPRedirect('./')
658	684	resume.exposed = True
659	685	resume.cp_config = {'tools.allow.on': True,
660	686	'tools.allow.methods': ['POST']}
661

+105

-87

cherrypy/lib/cptools.py less more

3	3	import re
4	4
5	5	import cherrypy
6		from cherrypy._cpcompat import basestring, ntob, md5, set
	6	from cherrypy._cpcompat import basestring, md5, set, unicodestr
7	7	from cherrypy.lib import httputil as _httputil
	8	from cherrypy.lib import is_iterator
8	9
9	10
10	11	# Conditional HTTP request support #
11	12
12	13	def validate_etags(autotags=False, debug=False):
13	14	"""Validate the current ETag against If-Match, If-None-Match headers.
14
	15
15	16	If autotags is True, an ETag response-header value will be provided
16	17	from an MD5 hash of the response body (unless some other code has
17	18	already provided an ETag header). If False (the default), the ETag
18	19	will not be automatic.
19
	20
20	21	WARNING: the autotags feature is not designed for URL's which allow
21	22	methods other than GET. For example, if a POST to the same URL returns
22	23	no content, the automatic ETag will be incorrect, breaking a fundamental

26	27	See :rfc:`2616` Section 14.24.
27	28	"""
28	29	response = cherrypy.serving.response
29
	30
30	31	# Guard against being run twice.
31	32	if hasattr(response, "ETag"):
32	33	return
33
	34
34	35	status, reason, msg = _httputil.valid_status(response.status)
35
	36
36	37	etag = response.headers.get('ETag')
37
	38
38	39	# Automatic ETag generation. See warning in docstring.
39	40	if etag:
40	41	if debug:

51	52	if debug:
52	53	cherrypy.log('Setting ETag: %s' % etag, 'TOOLS.ETAGS')
53	54	response.headers['ETag'] = etag
54
	55
55	56	response.ETag = etag
56
	57
57	58	# "If the request would, without the If-Match header field, result in
58	59	# anything other than a 2xx or 412 status, then the If-Match header
59	60	# MUST be ignored."

61	62	cherrypy.log('Status: %s' % status, 'TOOLS.ETAGS')
62	63	if status >= 200 and status <= 299:
63	64	request = cherrypy.serving.request
64
	65
65	66	conditions = request.headers.elements('If-Match') or []
66	67	conditions = [str(x) for x in conditions]
67	68	if debug:

70	71	if conditions and not (conditions == ["*"] or etag in conditions):
71	72	raise cherrypy.HTTPError(412, "If-Match failed: ETag %r did "
72	73	"not match %r" % (etag, conditions))
73
	74
74	75	conditions = request.headers.elements('If-None-Match') or []
75	76	conditions = [str(x) for x in conditions]
76	77	if debug:

78	79	'TOOLS.ETAGS')
79	80	if conditions == ["*"] or etag in conditions:
80	81	if debug:
81		cherrypy.log('request.method: %s' % request.method, 'TOOLS.ETAGS')
	82	cherrypy.log('request.method: %s' %
	83	request.method, 'TOOLS.ETAGS')
82	84	if request.method in ("GET", "HEAD"):
83	85	raise cherrypy.HTTPRedirect([], 304)
84	86	else:
85	87	raise cherrypy.HTTPError(412, "If-None-Match failed: ETag %r "
86	88	"matched %r" % (etag, conditions))
87	89
	90
88	91	def validate_since():
89	92	"""Validate the current Last-Modified against If-Modified-Since headers.
90
	93
91	94	If no code has set the Last-Modified response header, then no validation
92	95	will be performed.
93	96	"""

95	98	lastmod = response.headers.get('Last-Modified')
96	99	if lastmod:
97	100	status, reason, msg = _httputil.valid_status(response.status)
98
	101
99	102	request = cherrypy.serving.request
100
	103
101	104	since = request.headers.get('If-Unmodified-Since')
102	105	if since and since != lastmod:
103	106	if (status >= 200 and status <= 299) or status == 412:
104	107	raise cherrypy.HTTPError(412)
105
	108
106	109	since = request.headers.get('If-Modified-Since')
107	110	if since and since == lastmod:
108	111	if (status >= 200 and status <= 299) or status == 304:

116	119
117	120	def allow(methods=None, debug=False):
118	121	"""Raise 405 if request.method not in methods (default ['GET', 'HEAD']).
119
	122
120	123	The given methods are case-insensitive, and may be in any order.
121	124	If only one method is allowed, you may supply a single string;
122	125	if more than one, supply a list of strings.
123
	126
124	127	Regardless of whether the current method is allowed or not, this
125	128	also emits an 'Allow' response header, containing the given methods.
126	129	"""

131	134	methods = ['GET', 'HEAD']
132	135	elif 'GET' in methods and 'HEAD' not in methods:
133	136	methods.append('HEAD')
134
	137
135	138	cherrypy.response.headers['Allow'] = ', '.join(methods)
136	139	if cherrypy.request.method not in methods:
137	140	if debug:

147	150	def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For',
148	151	scheme='X-Forwarded-Proto', debug=False):
149	152	"""Change the base URL (scheme://host[:port][/path]).
150
	153
151	154	For running a CP server behind Apache, lighttpd, or other HTTP server.
152
	155
153	156	For Apache and lighttpd, you should leave the 'local' argument at the
154	157	default value of 'X-Forwarded-Host'. For Squid, you probably want to set
155	158	tools.proxy.local = 'Origin'.
156
	159
157	160	If you want the new request.base to include path info (not just the host),
158	161	you must explicitly set base to the full base path, and ALSO set 'local'
159	162	to '', so that the X-Forwarded-Host request header (which never includes
160	163	path info) does not override it. Regardless, the value for 'base' MUST
161	164	NOT end in a slash.
162
	165
163	166	cherrypy.request.remote.ip (the IP address of the client) will be
164	167	rewritten if the header specified by the 'remote' arg is valid.
165	168	By default, 'remote' is set to 'X-Forwarded-For'. If you do not
166	169	want to rewrite remote.ip, set the 'remote' arg to an empty string.
167	170	"""
168
	171
169	172	request = cherrypy.serving.request
170
	173
171	174	if scheme:
172	175	s = request.headers.get(scheme, None)
173	176	if debug:

180	183	scheme = s
181	184	if not scheme:
182	185	scheme = request.base[:request.base.find("://")]
183
	186
184	187	if local:
185	188	lbase = request.headers.get(local, None)
186	189	if debug:

193	196	base = '127.0.0.1'
194	197	else:
195	198	base = '127.0.0.1:%s' % port
196
	199
197	200	if base.find("://") == -1:
198	201	# add http:// or https:// if needed
199	202	base = scheme + "://" + base
200
	203
201	204	request.base = base
202
	205
203	206	if remote:
204	207	xff = request.headers.get(remote)
205	208	if debug:
206	209	cherrypy.log('Testing remote %r:%r' % (remote, xff), 'TOOLS.PROXY')
207	210	if xff:
208	211	if remote == 'X-Forwarded-For':
209		# See http://bob.pythonmac.org/archives/2005/09/23/apache-x-forwarded-for-caveat/
210		xff = xff.split(',')[-1].strip()
	212	#Bug #1268
	213	xff = xff.split(',')[0].strip()
211	214	request.remote.ip = xff
212	215
213	216
214	217	def ignore_headers(headers=('Range',), debug=False):
215	218	"""Delete request headers whose field names are included in 'headers'.
216
	219
217	220	This is a useful tool for working behind certain HTTP servers;
218	221	for example, Apache duplicates the work that CP does for 'Range'
219	222	headers, and will doubly-truncate the response.

240	243	def referer(pattern, accept=True, accept_missing=False, error=403,
241	244	message='Forbidden Referer header.', debug=False):
242	245	"""Raise HTTPError if Referer header does/does not match the given pattern.
243
	246
244	247	pattern
245	248	A regular expression pattern to test against the Referer.
246
	249
247	250	accept
248	251	If True, the Referer must match the pattern; if False,
249	252	the Referer must NOT match the pattern.

253	256
254	257	error
255	258	The HTTP error code to return to the client on failure.
256
	259
257	260	message
258	261	A string to include in the response body on failure.
259
	262
260	263	"""
261	264	try:
262	265	ref = cherrypy.serving.request.headers['Referer']

271	274	cherrypy.log('No Referer header', 'TOOLS.REFERER')
272	275	if accept_missing:
273	276	return
274
	277
275	278	raise cherrypy.HTTPError(error, message)
276	279
277	280
278	281	class SessionAuth(object):
	282
279	283	"""Assert that the user is logged in."""
280
	284
281	285	session_key = "username"
282	286	debug = False
283
	287
284	288	def check_username_and_password(self, username, password):
285	289	pass
286
	290
287	291	def anonymous(self):
288	292	"""Provide a temporary user name for anonymous users."""
289	293	pass
290
	294
291	295	def on_login(self, username):
292	296	pass
293
	297
294	298	def on_logout(self, username):
295	299	pass
296
	300
297	301	def on_check(self, username):
298	302	pass
299
300		def login_screen(self, from_page='..', username='', error_msg='', **kwargs):
301		return ntob("""<html><body>
	303
	304	def login_screen(self, from_page='..', username='', error_msg='',
	305	**kwargs):
	306	return (unicodestr("""<html><body>
302	307	Message: %(error_msg)s
303	308	<form method="post" action="do_login">
304		Login: <input type="text" name="username" value="%(username)s" size="10" /><br />
305		Password: <input type="password" name="password" size="10" /><br />
306		<input type="hidden" name="from_page" value="%(from_page)s" /><br />
	309	Login: <input type="text" name="username" value="%(username)s" size="10" />
	310	<br />
	311	Password: <input type="password" name="password" size="10" />
	312	<br />
	313	<input type="hidden" name="from_page" value="%(from_page)s" />
	314	<br />
307	315	<input type="submit" />
308	316	</form>
309		</body></html>""" % {'from_page': from_page, 'username': username,
310		'error_msg': error_msg}, "utf-8")
311
	317	</body></html>""") % vars()).encode("utf-8")
	318
312	319	def do_login(self, username, password, from_page='..', **kwargs):
313	320	"""Login. May raise redirect, or return True if request handled."""
314	321	response = cherrypy.serving.response

325	332	cherrypy.session[self.session_key] = username
326	333	self.on_login(username)
327	334	raise cherrypy.HTTPRedirect(from_page or "/")
328
	335
329	336	def do_logout(self, from_page='..', **kwargs):
330	337	"""Logout. May raise redirect, or return True if request handled."""
331	338	sess = cherrypy.session

335	342	cherrypy.serving.request.login = None
336	343	self.on_logout(username)
337	344	raise cherrypy.HTTPRedirect(from_page)
338
	345
339	346	def do_check(self):
340		"""Assert username. May raise redirect, or return True if request handled."""
	347	"""Assert username. Raise redirect, or return True if request handled.
	348	"""
341	349	sess = cherrypy.session
342	350	request = cherrypy.serving.request
343	351	response = cherrypy.serving.response
344
	352
345	353	username = sess.get(self.session_key)
346	354	if not username:
347	355	sess[self.session_key] = username = self.anonymous()
348	356	if self.debug:
349		cherrypy.log('No session[username], trying anonymous', 'TOOLS.SESSAUTH')
	357	cherrypy.log(
	358	'No session[username], trying anonymous', 'TOOLS.SESSAUTH')
350	359	if not username:
351	360	url = cherrypy.url(qs=request.query_string)
352	361	if self.debug:

358	367	del response.headers["Content-Length"]
359	368	return True
360	369	if self.debug:
361		cherrypy.log('Setting request.login to %r' % username, 'TOOLS.SESSAUTH')
	370	cherrypy.log('Setting request.login to %r' %
	371	username, 'TOOLS.SESSAUTH')
362	372	request.login = username
363	373	self.on_check(username)
364
	374
365	375	def run(self):
366	376	request = cherrypy.serving.request
367	377	response = cherrypy.serving.response
368
	378
369	379	path = request.path_info
370	380	if path.endswith('login_screen'):
371	381	if self.debug:
372		cherrypy.log('routing %r to login_screen' % path, 'TOOLS.SESSAUTH')
	382	cherrypy.log('routing %r to login_screen' %
	383	path, 'TOOLS.SESSAUTH')
373	384	return self.login_screen(**request.params)
374	385	elif path.endswith('do_login'):
375	386	if request.method != 'POST':

385	396	response.headers['Allow'] = "POST"
386	397	raise cherrypy.HTTPError(405)
387	398	if self.debug:
388		cherrypy.log('routing %r to do_logout' % path, 'TOOLS.SESSAUTH')
	399	cherrypy.log('routing %r to do_logout' %
	400	path, 'TOOLS.SESSAUTH')
389	401	return self.do_logout(**request.params)
390	402	else:
391	403	if self.debug:
392		cherrypy.log('No special path, running do_check', 'TOOLS.SESSAUTH')
	404	cherrypy.log('No special path, running do_check',
	405	'TOOLS.SESSAUTH')
393	406	return self.do_check()
394	407
395	408

411	424	"""Write the last error's traceback to the cherrypy error log."""
412	425	cherrypy.log("", "HTTP", severity=severity, traceback=True)
413	426
	427
414	428	def log_request_headers(debug=False):
415	429	"""Write request headers to the cherrypy error log."""
416	430	h = [" %s: %s" % (k, v) for k, v in cherrypy.serving.request.header_list]
417	431	cherrypy.log('\nRequest Headers:\n' + '\n'.join(h), "HTTP")
418	432
	433
419	434	def log_hooks(debug=False):
420	435	"""Write request.hooks to the cherrypy error log."""
421	436	request = cherrypy.serving.request
422
	437
423	438	msg = []
424	439	# Sort by the standard points if possible.
425	440	from cherrypy import _cprequest

427	442	for k in request.hooks.keys():
428	443	if k not in points:
429	444	points.append(k)
430
	445
431	446	for k in points:
432	447	msg.append(" %s:" % k)
433	448	v = request.hooks.get(k, [])

436	451	msg.append(" %r" % h)
437	452	cherrypy.log('\nRequest Hooks for ' + cherrypy.url() +
438	453	':\n' + '\n'.join(msg), "HTTP")
	454
439	455
440	456	def redirect(url='', internal=True, debug=False):
441	457	"""Raise InternalRedirect or HTTPRedirect to the given url."""

448	464	else:
449	465	raise cherrypy.HTTPRedirect(url)
450	466
	467
451	468	def trailing_slash(missing=True, extra=False, status=None, debug=False):
452	469	"""Redirect if path_info has (missing\|extra) trailing slash."""
453	470	request = cherrypy.serving.request
454	471	pi = request.path_info
455
	472
456	473	if debug:
457	474	cherrypy.log('is_index: %r, missing: %r, extra: %r, path_info: %r' %
458	475	(request.is_index, missing, extra, pi),

469	486	new_url = cherrypy.url(pi[:-1], request.query_string)
470	487	raise cherrypy.HTTPRedirect(new_url, status=status or 301)
471	488
	489
472	490	def flatten(debug=False):
473	491	"""Wrap response.body in a generator that recursively iterates over body.
474
	492
475	493	This allows cherrypy.response.body to consist of 'nested generators';
476	494	that is, a set of generators that yield generators.
477	495	"""
478		import types
479	496	def flattener(input):
480	497	numchunks = 0
481	498	for x in input:
482		if not isinstance(x, types.GeneratorType):
	499	if not is_iterator(x):
483	500	numchunks += 1
484	501	yield x
485	502	else:

494	511
495	512	def accept(media=None, debug=False):
496	513	"""Return the client's preferred media-type (from the given Content-Types).
497
	514
498	515	If 'media' is None (the default), no test will be performed.
499
	516
500	517	If 'media' is provided, it should be the Content-Type value (as a string)
501	518	or values (as a list or tuple of strings) which the current resource
502	519	can emit. The client's acceptable media ranges (as declared in the

504	521	values; the first such string is returned. That is, the return value
505	522	will always be one of the strings provided in the 'media' arg (or None
506	523	if 'media' is None).
507
	524
508	525	If no match is found, then HTTPError 406 (Not Acceptable) is raised.
509	526	Note that most web browsers send / as a (low-quality) acceptable
510	527	media range, which should match any Content-Type. In addition, "...if
511	528	no Accept header field is present, then it is assumed that the client
512	529	accepts all media types."
513
	530
514	531	Matching types are checked in order of client preference first,
515	532	and then in the order of the given 'media' values.
516
	533
517	534	Note that this function does not honor accept-params (other than "q").
518	535	"""
519	536	if not media:

521	538	if isinstance(media, basestring):
522	539	media = [media]
523	540	request = cherrypy.serving.request
524
	541
525	542	# Parse the Accept request header, and try to match one
526	543	# of the requested media-ranges (in order of preference).
527	544	ranges = request.headers.elements('Accept')

555	572	cherrypy.log('Match due to %s' % element.value,
556	573	'TOOLS.ACCEPT')
557	574	return element.value
558
	575
559	576	# No suitable media-range found.
560	577	ah = request.headers.get('Accept')
561	578	if ah is None:

568	585
569	586
570	587	class MonitoredHeaderMap(_httputil.HeaderMap):
571
	588
572	589	def __init__(self):
573	590	self.accessed_headers = set()
574
	591
575	592	def __getitem__(self, key):
576	593	self.accessed_headers.add(key)
577	594	return _httputil.HeaderMap.__getitem__(self, key)
578
	595
579	596	def __contains__(self, key):
580	597	self.accessed_headers.add(key)
581	598	return _httputil.HeaderMap.__contains__(self, key)
582
	599
583	600	def get(self, key, default=None):
584	601	self.accessed_headers.add(key)
585	602	return _httputil.HeaderMap.get(self, key, default=default)
586
	603
587	604	if hasattr({}, 'has_key'):
588	605	# Python 2
589	606	def has_key(self, key):

592	609
593	610
594	611	def autovary(ignore=None, debug=False):
595		"""Auto-populate the Vary response header based on request.header access."""
	612	"""Auto-populate the Vary response header based on request.header access.
	613	"""
596	614	request = cherrypy.serving.request
597
	615
598	616	req_h = request.headers
599	617	request.headers = MonitoredHeaderMap()
600	618	request.headers.update(req_h)
601	619	if ignore is None:
602	620	ignore = set(['Content-Disposition', 'Content-Length', 'Content-Type'])
603
	621
604	622	def set_response_header():
605	623	resp_h = cherrypy.serving.response.headers
606	624	v = set([e.value for e in resp_h.elements('Vary')])
607	625	if debug:
608		cherrypy.log('Accessed headers: %s' % request.headers.accessed_headers,
609		'TOOLS.AUTOVARY')
	626	cherrypy.log(
	627	'Accessed headers: %s' % request.headers.accessed_headers,
	628	'TOOLS.AUTOVARY')
610	629	v = v.union(request.headers.accessed_headers)
611	630	v = v.difference(ignore)
612	631	v = list(v)
613	632	v.sort()
614	633	resp_h['Vary'] = ', '.join(v)
615	634	request.hooks.attach('before_finalize', set_response_header, 95)
616

+100

-72

cherrypy/lib/encoding.py less more

8	8
9	9	def decode(encoding=None, default_encoding='utf-8'):
10	10	"""Replace or extend the list of charsets used to decode a request entity.
11
	11
12	12	Either argument may be a single string or a list of strings.
13
	13
14	14	encoding
15	15	If not None, restricts the set of charsets attempted while decoding
16		a request entity to the given set (even if a different charset is given in
17		the Content-Type request header).
18
	16	a request entity to the given set (even if a different charset is
	17	given in the Content-Type request header).
	18
19	19	default_encoding
20	20	Only in effect if the 'encoding' argument is not given.
21		If given, the set of charsets attempted while decoding a request entity is
22		extended with the given value(s).
23
	21	If given, the set of charsets attempted while decoding a request
	22	entity is extended with the given value(s).
	23
24	24	"""
25	25	body = cherrypy.request.body
26	26	if encoding is not None:

31	31	if not isinstance(default_encoding, list):
32	32	default_encoding = [default_encoding]
33	33	body.attempt_charsets = body.attempt_charsets + default_encoding
	34
	35	class UTF8StreamEncoder:
	36	def __init__(self, iterator):
	37	self._iterator = iterator
	38
	39	def __iter__(self):
	40	return self
	41
	42	def next(self):
	43	return self.__next__()
	44
	45	def __next__(self):
	46	res = next(self._iterator)
	47	if isinstance(res, unicodestr):
	48	res = res.encode('utf-8')
	49	return res
	50
	51	def __getattr__(self, attr):
	52	if attr.startswith('__'):
	53	raise AttributeError(self, attr)
	54	return getattr(self._iterator, attr)
34	55
35	56
36	57	class ResponseEncoder:
37
	58
38	59	default_encoding = 'utf-8'
39	60	failmsg = "Response body could not be encoded with %r."
40	61	encoding = None

42	63	text_only = True
43	64	add_charset = True
44	65	debug = False
45
	66
46	67	def __init__(self, **kwargs):
47	68	for k, v in kwargs.items():
48	69	setattr(self, k, v)
49
	70
50	71	self.attempted_charsets = set()
51	72	request = cherrypy.serving.request
52	73	if request.handler is not None:

55	76	cherrypy.log('Replacing request.handler', 'TOOLS.ENCODE')
56	77	self.oldhandler = request.handler
57	78	request.handler = self
58
	79
59	80	def encode_stream(self, encoding):
60	81	"""Encode a streaming response body.
61
	82
62	83	Use a generator wrapper, and just pray it works as the stream is
63	84	being written out.
64	85	"""
65	86	if encoding in self.attempted_charsets:
66	87	return False
67	88	self.attempted_charsets.add(encoding)
68
	89
69	90	def encoder(body):
70	91	for chunk in body:
71	92	if isinstance(chunk, unicodestr):

73	94	yield chunk
74	95	self.body = encoder(self.body)
75	96	return True
76
	97
77	98	def encode_string(self, encoding):
78	99	"""Encode a buffered response body."""
79	100	if encoding in self.attempted_charsets:
80	101	return False
81	102	self.attempted_charsets.add(encoding)
82
83		try:
84		body = []
85		for chunk in self.body:
86		if isinstance(chunk, unicodestr):
	103	body = []
	104	for chunk in self.body:
	105	if isinstance(chunk, unicodestr):
	106	try:
87	107	chunk = chunk.encode(encoding, self.errors)
88		body.append(chunk)
89		self.body = body
90		except (LookupError, UnicodeError):
91		return False
92		else:
93		return True
94
	108	except (LookupError, UnicodeError):
	109	return False
	110	body.append(chunk)
	111	self.body = body
	112	return True
	113
95	114	def find_acceptable_charset(self):
96	115	request = cherrypy.serving.request
97	116	response = cherrypy.serving.response
98
	117
99	118	if self.debug:
100		cherrypy.log('response.stream %r' % response.stream, 'TOOLS.ENCODE')
	119	cherrypy.log('response.stream %r' %
	120	response.stream, 'TOOLS.ENCODE')
101	121	if response.stream:
102	122	encoder = self.encode_stream
103	123	else:

114	134	# >>> len(t.encode("utf7"))
115	135	# 8
116	136	del response.headers["Content-Length"]
117
	137
118	138	# Parse the Accept-Charset request header, and try to provide one
119	139	# of the requested charsets (in order of user preference).
120	140	encs = request.headers.elements('Accept-Charset')
121	141	charsets = [enc.value.lower() for enc in encs]
122	142	if self.debug:
123	143	cherrypy.log('charsets %s' % repr(charsets), 'TOOLS.ENCODE')
124
	144
125	145	if self.encoding is not None:
126	146	# If specified, force this encoding to be used, or fail.
127	147	encoding = self.encoding.lower()
128	148	if self.debug:
129		cherrypy.log('Specified encoding %r' % encoding, 'TOOLS.ENCODE')
	149	cherrypy.log('Specified encoding %r' %
	150	encoding, 'TOOLS.ENCODE')
130	151	if (not charsets) or "*" in charsets or encoding in charsets:
131	152	if self.debug:
132		cherrypy.log('Attempting encoding %r' % encoding, 'TOOLS.ENCODE')
	153	cherrypy.log('Attempting encoding %r' %
	154	encoding, 'TOOLS.ENCODE')
133	155	if encoder(encoding):
134	156	return encoding
135	157	else:

141	163	if encoder(self.default_encoding):
142	164	return self.default_encoding
143	165	else:
144		raise cherrypy.HTTPError(500, self.failmsg % self.default_encoding)
	166	raise cherrypy.HTTPError(500, self.failmsg %
	167	self.default_encoding)
145	168	else:
146	169	for element in encs:
147	170	if element.qvalue > 0:

159	182	'0)' % element, 'TOOLS.ENCODE')
160	183	if encoder(encoding):
161	184	return encoding
162
	185
163	186	if "*" not in charsets:
164	187	# If no "*" is present in an Accept-Charset field, then all
165	188	# character sets not explicitly mentioned get a quality

172	195	'TOOLS.ENCODE')
173	196	if encoder(iso):
174	197	return iso
175
	198
176	199	# No suitable encoding found.
177	200	ac = request.headers.get('Accept-Charset')
178	201	if ac is None:
179	202	msg = "Your client did not send an Accept-Charset header."
180	203	else:
181	204	msg = "Your client sent this Accept-Charset header: %s." % ac
182		msg += " We tried these charsets: %s." % ", ".join(self.attempted_charsets)
	205	_charsets = ", ".join(sorted(self.attempted_charsets))
	206	msg += " We tried these charsets: %s." % (_charsets,)
183	207	raise cherrypy.HTTPError(406, msg)
184
	208
185	209	def __call__(self, args, *kwargs):
186	210	response = cherrypy.serving.response
187	211	self.body = self.oldhandler(args, *kwargs)
188
	212
189	213	if isinstance(self.body, basestring):
190	214	# strings get wrapped in a list because iterating over a single
191	215	# item list is much faster than iterating over every character

199	223	self.body = file_generator(self.body)
200	224	elif self.body is None:
201	225	self.body = []
202
	226
203	227	ct = response.headers.elements("Content-Type")
204	228	if self.debug:
205		cherrypy.log('Content-Type: %r' % [str(h) for h in ct], 'TOOLS.ENCODE')
206		if ct:
	229	cherrypy.log('Content-Type: %r' % [str(h)
	230	for h in ct], 'TOOLS.ENCODE')
	231	if ct and self.add_charset:
207	232	ct = ct[0]
208	233	if self.text_only:
209	234	if ct.value.lower().startswith("text/"):
210	235	if self.debug:
211		cherrypy.log('Content-Type %s starts with "text/"' % ct,
212		'TOOLS.ENCODE')
	236	cherrypy.log(
	237	'Content-Type %s starts with "text/"' % ct,
	238	'TOOLS.ENCODE')
213	239	do_find = True
214	240	else:
215	241	if self.debug:
216		cherrypy.log('Not finding because Content-Type %s does '
217		'not start with "text/"' % ct,
	242	cherrypy.log('Not finding because Content-Type %s '
	243	'does not start with "text/"' % ct,
218	244	'TOOLS.ENCODE')
219	245	do_find = False
220	246	else:
221	247	if self.debug:
222		cherrypy.log('Finding because not text_only', 'TOOLS.ENCODE')
	248	cherrypy.log('Finding because not text_only',
	249	'TOOLS.ENCODE')
223	250	do_find = True
224
	251
225	252	if do_find:
226	253	# Set "charset=..." param on response Content-Type header
227	254	ct.params['charset'] = self.find_acceptable_charset()
228		if self.add_charset:
229		if self.debug:
230		cherrypy.log('Setting Content-Type %s' % ct,
231		'TOOLS.ENCODE')
232		response.headers["Content-Type"] = str(ct)
233
	255	if self.debug:
	256	cherrypy.log('Setting Content-Type %s' % ct,
	257	'TOOLS.ENCODE')
	258	response.headers["Content-Type"] = str(ct)
	259
234	260	return self.body
235	261
236	262	# GZIP
	263
237	264
238	265	def compress(body, compress_level):
239	266	"""Compress 'body' at the given compress_level."""
240	267	import zlib
241
	268
242	269	# See http://www.gzip.org/zlib/rfc-gzip.html
243	270	yield ntob('\x1f\x8b') # ID1 and ID2: gzip marker
244	271	yield ntob('\x08') # CM: compression method

247	274	yield struct.pack("<L", int(time.time()) & int('FFFFFFFF', 16))
248	275	yield ntob('\x02') # XFL: max compression, slowest algo
249	276	yield ntob('\xff') # OS: unknown
250
	277
251	278	crc = zlib.crc32(ntob(""))
252	279	size = 0
253	280	zobj = zlib.compressobj(compress_level,

258	285	crc = zlib.crc32(line, crc)
259	286	yield zobj.compress(line)
260	287	yield zobj.flush()
261
	288
262	289	# CRC32: 4 bytes
263	290	yield struct.pack("<L", crc & int('FFFFFFFF', 16))
264	291	# ISIZE: 4 bytes
265	292	yield struct.pack("<L", size & int('FFFFFFFF', 16))
266	293
	294
267	295	def decompress(body):
268	296	import gzip
269
	297
270	298	zbuf = BytesIO()
271	299	zbuf.write(body)
272	300	zbuf.seek(0)

276	304	return data
277	305
278	306
279		def gzip(compress_level=5, mime_types=['text/html', 'text/plain'], debug=False):
	307	def gzip(compress_level=5, mime_types=['text/html', 'text/plain'],
	308	debug=False):
280	309	"""Try to gzip the response body if Content-Type in mime_types.
281
	310
282	311	cherrypy.response.headers['Content-Type'] must be set to one of the
283	312	values in the mime_types arg before calling this function.
284	313

286	315	* type/subtype
287	316	* type/*
288	317	* type/*+subtype
289
	318
290	319	No compression is performed if any of the following hold:
291	320	* The client sends no Accept-Encoding request header
292	321	* No 'gzip' or 'x-gzip' is present in the Accept-Encoding header
293	322	* No 'gzip' or 'x-gzip' with a qvalue > 0 is present
294	323	* The 'identity' value is given with a qvalue > 0.
295
	324
296	325	"""
297	326	request = cherrypy.serving.request
298	327	response = cherrypy.serving.response
299
	328
300	329	set_vary_header(response, "Accept-Encoding")
301
	330
302	331	if not response.body:
303	332	# Response body is empty (might be a 304 for instance)
304	333	if debug:
305	334	cherrypy.log('No response body', context='TOOLS.GZIP')
306	335	return
307
	336
308	337	# If returning cached content (which should already have been gzipped),
309	338	# don't re-zip.
310	339	if getattr(request, "cached", False):
311	340	if debug:
312	341	cherrypy.log('Not gzipping cached response', context='TOOLS.GZIP')
313	342	return
314
	343
315	344	acceptable = request.headers.elements('Accept-Encoding')
316	345	if not acceptable:
317	346	# If no Accept-Encoding field is present in a request,

324	353	if debug:
325	354	cherrypy.log('No Accept-Encoding', context='TOOLS.GZIP')
326	355	return
327
	356
328	357	ct = response.headers.get('Content-Type', '').split(';')[0]
329	358	for coding in acceptable:
330	359	if coding.value == 'identity' and coding.qvalue != 0:

338	367	cherrypy.log('Zero gzip qvalue: %s' % coding,
339	368	context='TOOLS.GZIP')
340	369	return
341
	370
342	371	if ct not in mime_types:
343	372	# If the list of provided mime-types contains tokens
344	373	# such as 'text/' or 'application/+xml',

369	398	cherrypy.log('Content-Type %s not in mime_types %r' %
370	399	(ct, mime_types), context='TOOLS.GZIP')
371	400	return
372
	401
373	402	if debug:
374	403	cherrypy.log('Gzipping', context='TOOLS.GZIP')
375	404	# Return a generator that compresses the page

378	407	if "Content-Length" in response.headers:
379	408	# Delete Content-Length header so finalize() recalcs it.
380	409	del response.headers["Content-Length"]
381
	410
382	411	return
383
	412
384	413	if debug:
385	414	cherrypy.log('No acceptable encoding found.', context='GZIP')
386	415	cherrypy.HTTPError(406, "identity, gzip").set_response()
387

+19

-16

cherrypy/lib/gctools.py less more

2	2	import os
3	3	import sys
4	4	import time
5
	5
6	6	try:
7	7	import objgraph
8	8	except ImportError:

14	14
15	15
16	16	class ReferrerTree(object):
	17
17	18	"""An object which gathers all referrers of an object to a given depth."""
18	19
19	20	peek_length = 40

88	89	def format(self, tree):
89	90	"""Return a list of string reprs from a nested list of referrers."""
90	91	output = []
	92
91	93	def ascend(branch, depth=1):
92	94	for parent, grandparents in branch:
93	95	output.append((" " * depth) + self._format(parent))

102	104
103	105
104	106	class RequestCounter(SimplePlugin):
105
	107
106	108	def start(self):
107	109	self.count = 0
108
	110
109	111	def before_request(self):
110	112	self.count += 1
111
	113
112	114	def after_request(self):
113		self.count -=1
	115	self.count -= 1
114	116	request_counter = RequestCounter(cherrypy.engine)
115	117	request_counter.subscribe()
116	118

128	130
129	131
130	132	class GCRoot(object):
	133
131	134	"""A CherryPy page handler for testing reference leaks."""
132	135
133		classes = [(_cprequest.Request, 2, 2,
134		"Should be 1 in this request thread and 1 in the main thread."),
135		(_cprequest.Response, 2, 2,
136		"Should be 1 in this request thread and 1 in the main thread."),
137		(_cpwsgi.AppResponse, 1, 1,
138		"Should be 1 in this request thread only."),
139		]
	136	classes = [
	137	(_cprequest.Request, 2, 2,
	138	"Should be 1 in this request thread and 1 in the main thread."),
	139	(_cprequest.Response, 2, 2,
	140	"Should be 1 in this request thread and 1 in the main thread."),
	141	(_cpwsgi.AppResponse, 1, 1,
	142	"Should be 1 in this request thread only."),
	143	]
140	144
141	145	def index(self):
142	146	return "Hello, world!"

144	148
145	149	def stats(self):
146	150	output = ["Statistics:"]
147
	151
148	152	for trial in range(10):
149	153	if request_counter.count > 0:
150	154	break
151	155	time.sleep(0.5)
152	156	else:
153	157	output.append("\nNot all requests closed properly.")
154
	158
155	159	# gc_collect isn't perfectly synchronous, because it may
156	160	# break reference cycles that then take time to fully
157	161	# finalize. Call it thrice and hope for the best.

207	211	t = ReferrerTree(ignore=[objs], maxdepth=3)
208	212	tree = t.ascend(obj)
209	213	output.extend(t.format(tree))
210
	214
211	215	return "\n".join(output)
212	216	stats.exposed = True
213

-1

cherrypy/lib/http.py less more

3	3	DeprecationWarning)
4	4
5	5	from cherrypy.lib.httputil import *
6

+94

-81

cherrypy/lib/httpauth.py less more

0	0	"""
1		This module defines functions to implement HTTP Digest Authentication (:rfc:`2617`).
	1	This module defines functions to implement HTTP Digest Authentication
	2	(:rfc:`2617`).
2	3	This has full compliance with 'Digest' and 'Basic' authentication methods. In
3	4	'Digest' it supports both MD5 and MD5-sess algorithms.
4	5

6	7	First use 'doAuth' to request the client authentication for a
7	8	certain resource. You should send an httplib.UNAUTHORIZED response to the
8	9	client so he knows he has to authenticate itself.
9
	10
10	11	Then use 'parseAuthorization' to retrieve the 'auth_map' used in
11	12	'checkResponse'.
12	13
13		To use 'checkResponse' you must have already verified the password associated
14		with the 'username' key in 'auth_map' dict. Then you use the 'checkResponse'
15		function to verify if the password matches the one sent by the client.
	14	To use 'checkResponse' you must have already verified the password
	15	associated with the 'username' key in 'auth_map' dict. Then you use the
	16	'checkResponse' function to verify if the password matches the one sent
	17	by the client.
16	18
17	19	SUPPORTED_ALGORITHM - list of supported 'Digest' algorithms
18	20	SUPPORTED_QOP - list of supported 'Digest' 'qop'.

20	22	__version__ = 1, 0, 1
21	23	__author__ = "Tiago Cogumbreiro <cogumbreiro@users.sf.net>"
22	24	__credits__ = """
23		Peter van Kampen for its recipe which implement most of Digest authentication:
	25	Peter van Kampen for its recipe which implement most of Digest
	26	authentication:
24	27	http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/302378
25	28	"""
26	29

28	31	Copyright (c) 2005, Tiago Cogumbreiro <cogumbreiro@users.sf.net>
29	32	All rights reserved.
30	33
31		Redistribution and use in source and binary forms, with or without modification,
32		are permitted provided that the following conditions are met:
33
34		* Redistributions of source code must retain the above copyright notice,
	34	Redistribution and use in source and binary forms, with or without
	35	modification, are permitted provided that the following conditions are met:
	36
	37	* Redistributions of source code must retain the above copyright notice,
35	38	this list of conditions and the following disclaimer.
36		* Redistributions in binary form must reproduce the above copyright notice,
37		this list of conditions and the following disclaimer in the documentation
	39	* Redistributions in binary form must reproduce the above copyright notice,
	40	this list of conditions and the following disclaimer in the documentation
38	41	and/or other materials provided with the distribution.
39		* Neither the name of Sylvain Hellegouarch nor the names of his contributors
40		may be used to endorse or promote products derived from this software
41		without specific prior written permission.
42
43		THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
44		ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
45		WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
46		DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
47		FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48		DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
49		SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
50		CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
51		OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	42	* Neither the name of Sylvain Hellegouarch nor the names of his
	43	contributors may be used to endorse or promote products derived from
	44	this software without specific prior written permission.
	45
	46	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	47	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	48	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	49	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
	50	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	51	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	52	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	53	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	54	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
52	55	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
53	56	"""
54	57

56	59	"parseAuthorization", "SUPPORTED_ALGORITHM", "md5SessionKey",
57	60	"calculateNonce", "SUPPORTED_QOP")
58	61
59		################################################################################
	62	##########################################################################
60	63	import time
61	64	from cherrypy._cpcompat import base64_decode, ntob, md5
62	65	from cherrypy._cpcompat import parse_http_list, parse_keqv_list

69	72	SUPPORTED_ALGORITHM = (MD5, MD5_SESS)
70	73	SUPPORTED_QOP = (AUTH, AUTH_INT)
71	74
72		################################################################################
	75	##########################################################################
73	76	# doAuth
74	77	#
75	78	DIGEST_AUTH_ENCODERS = {
76	79	MD5: lambda val: md5(ntob(val)).hexdigest(),
77	80	MD5_SESS: lambda val: md5(ntob(val)).hexdigest(),
78		# SHA: lambda val: sha.new(ntob(val)).hexdigest (),
	81	# SHA: lambda val: sha.new(ntob(val)).hexdigest (),
79	82	}
80	83
81		def calculateNonce (realm, algorithm = MD5):
	84
	85	def calculateNonce(realm, algorithm=MD5):
82	86	"""This is an auxaliary function that calculates 'nonce' value. It is used
83	87	to handle sessions."""
84	88

88	92	try:
89	93	encoder = DIGEST_AUTH_ENCODERS[algorithm]
90	94	except KeyError:
91		raise NotImplementedError ("The chosen algorithm (%s) does not have "\
92		"an implementation yet" % algorithm)
93
94		return encoder ("%d:%s" % (time.time(), realm))
95
96		def digestAuth (realm, algorithm = MD5, nonce = None, qop = AUTH):
	95	raise NotImplementedError("The chosen algorithm (%s) does not have "
	96	"an implementation yet" % algorithm)
	97
	98	return encoder("%d:%s" % (time.time(), realm))
	99
	100
	101	def digestAuth(realm, algorithm=MD5, nonce=None, qop=AUTH):
97	102	"""Challenges the client for a Digest authentication."""
98	103	global SUPPORTED_ALGORITHM, DIGEST_AUTH_ENCODERS, SUPPORTED_QOP
99	104	assert algorithm in SUPPORTED_ALGORITHM
100	105	assert qop in SUPPORTED_QOP
101	106
102	107	if nonce is None:
103		nonce = calculateNonce (realm, algorithm)
	108	nonce = calculateNonce(realm, algorithm)
104	109
105	110	return 'Digest realm="%s", nonce="%s", algorithm="%s", qop="%s"' % (
106	111	realm, nonce, algorithm, qop
107	112	)
108	113
109		def basicAuth (realm):
	114
	115	def basicAuth(realm):
110	116	"""Challengenes the client for a Basic authentication."""
111	117	assert '"' not in realm, "Realms cannot contain the \" (quote) character."
112	118
113	119	return 'Basic realm="%s"' % realm
114	120
115		def doAuth (realm):
	121
	122	def doAuth(realm):
116	123	"""'doAuth' function returns the challenge string b giving priority over
117	124	Digest and fallback to Basic authentication when the browser doesn't
118	125	support the first one.
119
	126
120	127	This should be set in the HTTP header under the key 'WWW-Authenticate'."""
121	128
122		return digestAuth (realm) + " " + basicAuth (realm)
123
124
125		################################################################################
	129	return digestAuth(realm) + " " + basicAuth(realm)
	130
	131
	132	##########################################################################
126	133	# Parse authorization parameters
127	134	#
128		def _parseDigestAuthorization (auth_params):
	135	def _parseDigestAuthorization(auth_params):
129	136	# Convert the auth params to a dict
130	137	items = parse_http_list(auth_params)
131	138	params = parse_keqv_list(items)

139	146	return None
140	147
141	148	# If qop is sent then cnonce and nc MUST be present
142		if "qop" in params and not ("cnonce" in params \
143		and "nc" in params):
	149	if "qop" in params and not ("cnonce" in params
	150	and "nc" in params):
144	151	return None
145	152
146	153	# If qop is not sent, neither cnonce nor nc can be present

151	158	return params
152	159
153	160
154		def _parseBasicAuthorization (auth_params):
	161	def _parseBasicAuthorization(auth_params):
155	162	username, password = base64_decode(auth_params).split(":", 1)
156	163	return {"username": username, "password": password}
157	164

160	167	"digest": _parseDigestAuthorization,
161	168	}
162	169
163		def parseAuthorization (credentials):
	170
	171	def parseAuthorization(credentials):
164	172	"""parseAuthorization will convert the value of the 'Authorization' key in
165	173	the HTTP header to a map itself. If the parsing fails 'None' is returned.
166	174	"""
167	175
168	176	global AUTH_SCHEMES
169	177
170		auth_scheme, auth_params = credentials.split(" ", 1)
171		auth_scheme = auth_scheme.lower ()
	178	auth_scheme, auth_params = credentials.split(" ", 1)
	179	auth_scheme = auth_scheme.lower()
172	180
173	181	parser = AUTH_SCHEMES[auth_scheme]
174		params = parser (auth_params)
	182	params = parser(auth_params)
175	183
176	184	if params is None:
177	185	return

181	189	return params
182	190
183	191
184		################################################################################
	192	##########################################################################
185	193	# Check provided response for a valid password
186	194	#
187		def md5SessionKey (params, password):
188		"""
189		If the "algorithm" directive's value is "MD5-sess", then A1
	195	def md5SessionKey(params, password):
	196	"""
	197	If the "algorithm" directive's value is "MD5-sess", then A1
190	198	[the session key] is calculated only once - on the first request by the
191	199	client following receipt of a WWW-Authenticate challenge from the server.
192	200

209	217	params_copy[key] = params[key]
210	218
211	219	params_copy["algorithm"] = MD5_SESS
212		return _A1 (params_copy, password)
	220	return _A1(params_copy, password)
	221
213	222
214	223	def _A1(params, password):
215		algorithm = params.get ("algorithm", MD5)
	224	algorithm = params.get("algorithm", MD5)
216	225	H = DIGEST_AUTH_ENCODERS[algorithm]
217	226
218	227	if algorithm == MD5:

226	235	# This is A1 if qop is set
227	236	# A1 = H( unq(username-value) ":" unq(realm-value) ":" passwd )
228	237	# ":" unq(nonce-value) ":" unq(cnonce-value)
229		h_a1 = H ("%s:%s:%s" % (params["username"], params["realm"], password))
	238	h_a1 = H("%s:%s:%s" % (params["username"], params["realm"], password))
230	239	return "%s:%s:%s" % (h_a1, params["nonce"], params["cnonce"])
231	240
232	241

234	243	# If the "qop" directive's value is "auth" or is unspecified, then A2 is:
235	244	# A2 = Method ":" digest-uri-value
236	245
237		qop = params.get ("qop", "auth")
	246	qop = params.get("qop", "auth")
238	247	if qop == "auth":
239	248	return method + ":" + params["uri"]
240	249	elif qop == "auth-int":
241	250	# If the "qop" value is "auth-int", then A2 is:
242	251	# A2 = Method ":" digest-uri-value ":" H(entity-body)
243		entity_body = kwargs.get ("entity_body", "")
	252	entity_body = kwargs.get("entity_body", "")
244	253	H = kwargs["H"]
245	254
246	255	return "%s:%s:%s" % (

250	259	)
251	260
252	261	else:
253		raise NotImplementedError ("The 'qop' method is unknown: %s" % qop)
254
255		def _computeDigestResponse(auth_map, password, method = "GET", A1 = None,**kwargs):
	262	raise NotImplementedError("The 'qop' method is unknown: %s" % qop)
	263
	264
	265	def _computeDigestResponse(auth_map, password, method="GET", A1=None,
	266	**kwargs):
256	267	"""
257	268	Generates a response respecting the algorithm defined in RFC 2617
258	269	"""
259	270	params = auth_map
260	271
261		algorithm = params.get ("algorithm", MD5)
	272	algorithm = params.get("algorithm", MD5)
262	273
263	274	H = DIGEST_AUTH_ENCODERS[algorithm]
264	275	KD = lambda secret, data: H(secret + ":" + data)
265	276
266		qop = params.get ("qop", None)
	277	qop = params.get("qop", None)
267	278
268	279	H_A2 = H(_A2(params, method, kwargs))
269	280

296	307
297	308	return KD(H_A1, request)
298	309
299		def _checkDigestResponse(auth_map, password, method = "GET", A1 = None, **kwargs):
	310
	311	def _checkDigestResponse(auth_map, password, method="GET", A1=None, **kwargs):
300	312	"""This function is used to verify the response given by the client when
301	313	he tries to authenticate.
302	314	Optional arguments:

311	323	if auth_map['realm'] != kwargs.get('realm', None):
312	324	return False
313	325
314		response = _computeDigestResponse(auth_map, password, method, A1,**kwargs)
	326	response = _computeDigestResponse(
	327	auth_map, password, method, A1, **kwargs)
315	328
316	329	return response == auth_map["response"]
317	330
318		def _checkBasicResponse (auth_map, password, method='GET', encrypt=None, **kwargs):
	331
	332	def _checkBasicResponse(auth_map, password, method='GET', encrypt=None,
	333	**kwargs):
319	334	# Note that the Basic response doesn't provide the realm value so we cannot
320	335	# test it
321	336	try:

328	343	"digest": _checkDigestResponse,
329	344	}
330	345
331		def checkResponse (auth_map, password, method = "GET", encrypt=None, **kwargs):
	346
	347	def checkResponse(auth_map, password, method="GET", encrypt=None, **kwargs):
332	348	"""'checkResponse' compares the auth_map with the password and optionally
333	349	other arguments that each implementation might need.
334
	350
335	351	If the response is of type 'Basic' then the function has the following
336	352	signature::
337
338		checkBasicResponse (auth_map, password) -> bool
339
	353
	354	checkBasicResponse(auth_map, password) -> bool
	355
340	356	If the response is of type 'Digest' then the function has the following
341	357	signature::
342
343		checkDigestResponse (auth_map, password, method = 'GET', A1 = None) -> bool
344
	358
	359	checkDigestResponse(auth_map, password, method='GET', A1=None) -> bool
	360
345	361	The 'A1' argument is only used in MD5_SESS algorithm based responses.
346	362	Check md5SessionKey() for more info.
347	363	"""
348	364	checker = AUTH_RESPONSES[auth_map["auth_scheme"]]
349		return checker (auth_map, password, method=method, encrypt=encrypt, **kwargs)
350
351
352
353
	365	return checker(auth_map, password, method=method, encrypt=encrypt,
	366	**kwargs)

+121

-98

cherrypy/lib/httputil.py less more

7	7	"""
8	8
9	9	from binascii import b2a_base64
10		from cherrypy._cpcompat import BaseHTTPRequestHandler, HTTPDate, ntob, ntou, reversed, sorted
11		from cherrypy._cpcompat import basestring, bytestr, iteritems, nativestr, unicodestr, unquote_qs
	10	from cherrypy._cpcompat import BaseHTTPRequestHandler, HTTPDate, ntob, ntou
	11	from cherrypy._cpcompat import basestring, bytestr, iteritems, nativestr
	12	from cherrypy._cpcompat import reversed, sorted, unicodestr, unquote_qs
12	13	response_codes = BaseHTTPRequestHandler.responses.copy()
13	14
14		# From http://www.cherrypy.org/ticket/361
	15	# From https://bitbucket.org/cherrypy/cherrypy/issue/361
15	16	response_codes[500] = ('Internal Server Error',
16		'The server encountered an unexpected condition '
17		'which prevented it from fulfilling the request.')
	17	'The server encountered an unexpected condition '
	18	'which prevented it from fulfilling the request.')
18	19	response_codes[503] = ('Service Unavailable',
19		'The server is currently unable to handle the '
20		'request due to a temporary overloading or '
21		'maintenance of the server.')
	20	'The server is currently unable to handle the '
	21	'request due to a temporary overloading or '
	22	'maintenance of the server.')
22	23
23	24	import re
24	25	import urllib
25	26
26	27
27
28	28	def urljoin(*atoms):
29	29	"""Return the given path \*atoms, joined into a single URL.
30
	30
31	31	This will correctly join a SCRIPT_NAME and PATH_INFO into the
32	32	original URL, even if either atom is blank.
33	33	"""

37	37	# Special-case the final url of "", and return "/" instead.
38	38	return url or "/"
39	39
	40
40	41	def urljoin_bytes(*atoms):
41	42	"""Return the given path *atoms, joined into a single URL.
42
	43
43	44	This will correctly join a SCRIPT_NAME and PATH_INFO into the
44	45	original URL, even if either atom is blank.
45	46	"""

49	50	# Special-case the final url of "", and return "/" instead.
50	51	return url or ntob("/")
51	52
	53
52	54	def protocol_from_http(protocol_str):
53	55	"""Return a protocol tuple from the given 'HTTP/x.y' string."""
54	56	return int(protocol_str[5]), int(protocol_str[7])
55	57
	58
56	59	def get_ranges(headervalue, content_length):
57	60	"""Return a list of (start, stop) indices from a Range header, or None.
58
	61
59	62	Each (start, stop) tuple will be composed of two ints, which are suitable
60	63	for use in a slicing operation. That is, the header "Range: bytes=3-6",
61	64	if applied against a Python string, is requesting resource[3:7]. This
62	65	function will return the list [(3, 7)].
63
	66
64	67	If this function returns an empty list, you should return HTTP 416.
65	68	"""
66
	69
67	70	if not headervalue:
68	71	return None
69
	72
70	73	result = []
71	74	bytesunit, byteranges = headervalue.split("=", 1)
72	75	for brange in byteranges.split(","):

100	103	return None
101	104	# Negative subscript (last N bytes)
102	105	result.append((content_length - int(stop), content_length))
103
	106
104	107	return result
105	108
106	109
107	110	class HeaderElement(object):
	111
108	112	"""An element (with parameters) from an HTTP header's element list."""
109
	113
110	114	def __init__(self, value, params=None):
111	115	self.value = value
112	116	if params is None:
113	117	params = {}
114	118	self.params = params
115
	119
116	120	def __cmp__(self, other):
117	121	return cmp(self.value, other.value)
118
	122
119	123	def __lt__(self, other):
120	124	return self.value < other.value
121
	125
122	126	def __str__(self):
123	127	p = [";%s=%s" % (k, v) for k, v in iteritems(self.params)]
124		return "%s%s" % (self.value, "".join(p))
125
	128	return str("%s%s" % (self.value, "".join(p)))
	129
126	130	def __bytes__(self):
127	131	return ntob(self.__str__())
128	132
129	133	def __unicode__(self):
130	134	return ntou(self.__str__())
131
	135
132	136	def parse(elementstr):
133	137	"""Transform 'token;key=val' to ('token', {'key': 'val'})."""
134	138	# Split the element into a value and parameters. The 'value' may

149	153	params[key] = val
150	154	return initial_value, params
151	155	parse = staticmethod(parse)
152
	156
153	157	def from_str(cls, elementstr):
154	158	"""Construct an instance from a string of the form 'token;key=val'."""
155	159	ival, params = cls.parse(elementstr)

159	163
160	164	q_separator = re.compile(r'; q =')
161	165
	166
162	167	class AcceptElement(HeaderElement):
	168
163	169	"""An element (with parameters) from an Accept* header's element list.
164
	170
165	171	AcceptElement objects are comparable; the more-preferred object will be
166	172	"less than" the less-preferred object. They are also therefore sortable;
167	173	if you sort a list of AcceptElement objects, they will be listed in
168	174	priority order; the most preferred value will be first. Yes, it should
169	175	have been the other way around, but it's too late to fix now.
170	176	"""
171
	177
172	178	def from_str(cls, elementstr):
173	179	qvalue = None
174	180	# The first "q" parameter (if any) separates the initial

179	185	# The qvalue for an Accept header can have extensions. The other
180	186	# headers cannot, but it's easier to parse them as if they did.
181	187	qvalue = HeaderElement.from_str(atoms[0].strip())
182
	188
183	189	media_type, params = cls.parse(media_range)
184	190	if qvalue is not None:
185	191	params["q"] = qvalue
186	192	return cls(media_type, params)
187	193	from_str = classmethod(from_str)
188
	194
189	195	def qvalue(self):
190	196	val = self.params.get("q", "1")
191	197	if isinstance(val, HeaderElement):
192	198	val = val.value
193	199	return float(val)
194	200	qvalue = property(qvalue, doc="The qvalue, or priority, of this value.")
195
	201
196	202	def __cmp__(self, other):
197	203	diff = cmp(self.qvalue, other.qvalue)
198	204	if diff == 0:
199	205	diff = cmp(str(self), str(other))
200	206	return diff
201
	207
202	208	def __lt__(self, other):
203	209	if self.qvalue == other.qvalue:
204	210	return str(self) < str(other)
205	211	else:
206	212	return self.qvalue < other.qvalue
207	213
208
	214	RE_HEADER_SPLIT = re.compile(',(?=(?:[^"]"[^"]")[^"]$)')
209	215	def header_elements(fieldname, fieldvalue):
210		"""Return a sorted HeaderElement list from a comma-separated header string."""
	216	"""Return a sorted HeaderElement list from a comma-separated header string.
	217	"""
211	218	if not fieldvalue:
212	219	return []
213
	220
214	221	result = []
215		for element in fieldvalue.split(","):
	222	for element in RE_HEADER_SPLIT.split(fieldvalue):
216	223	if fieldname.startswith("Accept") or fieldname == 'TE':
217	224	hv = AcceptElement.from_str(element)
218	225	else:
219	226	hv = HeaderElement.from_str(element)
220	227	result.append(hv)
221
	228
222	229	return list(reversed(sorted(result)))
	230
223	231
224	232	def decode_TEXT(value):
225	233	r"""Decode :rfc:`2047` TEXT (e.g. "=?utf-8?q?f=C3=BCr?=" -> "f\xfcr")."""

236	244	decodedvalue += atom
237	245	return decodedvalue
238	246
	247
239	248	def valid_status(status):
240	249	"""Return legal HTTP status Code, Reason-phrase and Message.
241
	250
242	251	The status arg must be an int, or a str that begins with an int.
243
	252
244	253	If status is an int, or a str and no reason-phrase is supplied,
245	254	a default reason-phrase will be provided.
246	255	"""
247
	256
248	257	if not status:
249	258	status = 200
250
	259
251	260	status = str(status)
252	261	parts = status.split(" ", 1)
253	262	if len(parts) == 1:

257	266	else:
258	267	code, reason = parts
259	268	reason = reason.strip()
260
	269
261	270	try:
262	271	code = int(code)
263	272	except ValueError:
264	273	raise ValueError("Illegal response status from server "
265	274	"(%s is non-numeric)." % repr(code))
266
	275
267	276	if code < 100 or code > 599:
268	277	raise ValueError("Illegal response status from server "
269	278	"(%s is out of range)." % repr(code))
270
	279
271	280	if code not in response_codes:
272	281	# code is unknown but not illegal
273	282	default_reason, message = "", ""
274	283	else:
275	284	default_reason, message = response_codes[code]
276
	285
277	286	if reason is None:
278	287	reason = default_reason
279
	288
280	289	return code, reason, message
281	290
282	291

286	295
287	296	def _parse_qs(qs, keep_blank_values=0, strict_parsing=0, encoding='utf-8'):
288	297	"""Parse a query given as a string argument.
289
	298
290	299	Arguments:
291
	300
292	301	qs: URL-encoded query string to be parsed
293
	302
294	303	keep_blank_values: flag indicating whether blank values in
295	304	URL encoded queries should be treated as blank strings. A
296	305	true value indicates that blanks should be retained as blank
297	306	strings. The default false value indicates that blank values
298	307	are to be ignored and treated as if they were not included.
299
	308
300	309	strict_parsing: flag indicating what to do with parsing errors. If
301	310	false (the default), errors are silently ignored. If true,
302	311	errors raise a ValueError exception.
303
	312
304	313	Returns a dict, as G-d intended.
305	314	"""
306	315	pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]

331	340
332	341	image_map_pattern = re.compile(r"[0-9]+,[0-9]+")
333	342
	343
334	344	def parse_query_string(query_string, keep_blank_values=True, encoding='utf-8'):
335	345	"""Build a params dictionary from a query_string.
336
	346
337	347	Duplicate key/value pairs in the provided query_string will be
338	348	returned as {'key': [val1, val2, ...]}. Single key/values will
339	349	be returned as strings: {'key': 'value'}.

349	359
350	360
351	361	class CaseInsensitiveDict(dict):
	362
352	363	"""A case-insensitive dict subclass.
353
	364
354	365	Each key is changed on entry to str(key).title().
355	366	"""
356
	367
357	368	def __getitem__(self, key):
358	369	return dict.__getitem__(self, str(key).title())
359
	370
360	371	def __setitem__(self, key, value):
361	372	dict.__setitem__(self, str(key).title(), value)
362
	373
363	374	def __delitem__(self, key):
364	375	dict.__delitem__(self, str(key).title())
365
	376
366	377	def __contains__(self, key):
367	378	return dict.__contains__(self, str(key).title())
368
	379
369	380	def get(self, key, default=None):
370	381	return dict.get(self, str(key).title(), default)
371
	382
372	383	if hasattr({}, 'has_key'):
373	384	def has_key(self, key):
374		return dict.has_key(self, str(key).title())
375
	385	return str(key).title() in self
	386
376	387	def update(self, E):
377	388	for k in E.keys():
378	389	self[str(k).title()] = E[k]
379
	390
380	391	def fromkeys(cls, seq, value=None):
381	392	newdict = cls()
382	393	for k in seq:
383	394	newdict[str(k).title()] = value
384	395	return newdict
385	396	fromkeys = classmethod(fromkeys)
386
	397
387	398	def setdefault(self, key, x=None):
388	399	key = str(key).title()
389	400	try:

391	402	except KeyError:
392	403	self[key] = x
393	404	return x
394
	405
395	406	def pop(self, key, default):
396	407	return dict.pop(self, str(key).title(), default)
397	408

403	414	# replaced with a single SP before interpretation of the TEXT value."
404	415	if nativestr == bytestr:
405	416	header_translate_table = ''.join([chr(i) for i in xrange(256)])
406		header_translate_deletechars = ''.join([chr(i) for i in xrange(32)]) + chr(127)
	417	header_translate_deletechars = ''.join(
	418	[chr(i) for i in xrange(32)]) + chr(127)
407	419	else:
408	420	header_translate_table = None
409	421	header_translate_deletechars = bytes(range(32)) + bytes([127])
410	422
411	423
412	424	class HeaderMap(CaseInsensitiveDict):
	425
413	426	"""A dict subclass for HTTP request and response headers.
414
	427
415	428	Each key is changed on entry to str(key).title(). This allows headers
416	429	to be case-insensitive and avoid duplicates.
417
	430
418	431	Values are header values (decoded according to :rfc:`2047` if necessary).
419	432	"""
420
421		protocol=(1, 1)
	433
	434	protocol = (1, 1)
422	435	encodings = ["ISO-8859-1"]
423
	436
424	437	# Someday, when http-bis is done, this will probably get dropped
425	438	# since few servers, clients, or intermediaries do it. But until then,
426	439	# we're going to obey the spec as is.
427	440	# "Words of *TEXT MAY contain characters from character sets other than
428	441	# ISO-8859-1 only when encoded according to the rules of RFC 2047."
429	442	use_rfc_2047 = True
430
	443
431	444	def elements(self, key):
432	445	"""Return a sorted list of HeaderElements for the given header."""
433	446	key = str(key).title()
434	447	value = self.get(key)
435	448	return header_elements(key, value)
436
	449
437	450	def values(self, key):
438	451	"""Return a sorted list of HeaderElement.value for the given header."""
439	452	return [e.value for e in self.elements(key)]
440
	453
441	454	def output(self):
442	455	"""Transform self into a list of (name, value) tuples."""
443		header_list = []
444		for k, v in self.items():
	456	return list(self.encode_header_items(self.items()))
	457
	458	def encode_header_items(cls, header_items):
	459	"""
	460	Prepare the sequence of name, value tuples into a form suitable for
	461	transmitting on the wire for HTTP.
	462	"""
	463	for k, v in header_items:
445	464	if isinstance(k, unicodestr):
446		k = self.encode(k)
447
	465	k = cls.encode(k)
	466
448	467	if not isinstance(v, basestring):
449	468	v = str(v)
450
	469
451	470	if isinstance(v, unicodestr):
452		v = self.encode(v)
453
	471	v = cls.encode(v)
	472
454	473	# See header_translate_* constants above.
455	474	# Replace only if you really know what you're doing.
456		k = k.translate(header_translate_table, header_translate_deletechars)
457		v = v.translate(header_translate_table, header_translate_deletechars)
458
459		header_list.append((k, v))
460		return header_list
461
462		def encode(self, v):
	475	k = k.translate(header_translate_table,
	476	header_translate_deletechars)
	477	v = v.translate(header_translate_table,
	478	header_translate_deletechars)
	479
	480	yield (k, v)
	481	encode_header_items = classmethod(encode_header_items)
	482
	483	def encode(cls, v):
463	484	"""Return the given header name or value, encoded for HTTP output."""
464		for enc in self.encodings:
	485	for enc in cls.encodings:
465	486	try:
466	487	return v.encode(enc)
467	488	except UnicodeEncodeError:
468	489	continue
469
470		if self.protocol == (1, 1) and self.use_rfc_2047:
471		# Encode RFC-2047 TEXT
472		# (e.g. u"\u8200" -> "=?utf-8?b?6IiA?=").
	490
	491	if cls.protocol == (1, 1) and cls.use_rfc_2047:
	492	# Encode RFC-2047 TEXT
	493	# (e.g. u"\u8200" -> "=?utf-8?b?6IiA?=").
473	494	# We do our own here instead of using the email module
474	495	# because we never want to fold lines--folding has
475	496	# been deprecated by the HTTP working group.
476	497	v = b2a_base64(v.encode('utf-8'))
477	498	return (ntob('=?utf-8?b?') + v.strip(ntob('\n')) + ntob('?='))
478
	499
479	500	raise ValueError("Could not encode header part %r using "
480	501	"any of the encodings %r." %
481		(v, self.encodings))
	502	(v, cls.encodings))
	503	encode = classmethod(encode)
482	504
483	505
484	506	class Host(object):
	507
485	508	"""An internet address.
486
	509
487	510	name
488	511	Should be the client's host name. If not available (because no DNS
489	512	lookup is performed), the IP address should be used instead.
490
491		"""
492
	513
	514	"""
	515
493	516	ip = "0.0.0.0"
494	517	port = 80
495	518	name = "unknown.tld"
496
	519
497	520	def __init__(self, ip, port, name=None):
498	521	self.ip = ip
499	522	self.port = port
500	523	if name is None:
501	524	name = ip
502	525	self.name = name
503
	526
504	527	def __repr__(self):
505	528	return "httputil.Host(%r, %r, %r)" % (self.ip, self.port, self.name)

+22

-13

cherrypy/lib/jsontools.py less more

0		import sys
1	0	import cherrypy
2		from cherrypy._cpcompat import basestring, ntou, json, json_encode, json_decode
	1	from cherrypy._cpcompat import basestring, ntou, json_encode, json_decode
	2
3	3
4	4	def json_processor(entity):
5	5	"""Read application/json data into request.json."""
6	6	if not entity.headers.get(ntou("Content-Length"), ntou("")):
7	7	raise cherrypy.HTTPError(411)
8
	8
9	9	body = entity.fp.read()
10	10	try:
11	11	cherrypy.serving.request.json = json_decode(body.decode('utf-8'))
12	12	except ValueError:
13	13	raise cherrypy.HTTPError(400, 'Invalid JSON document')
14	14
	15
15	16	def json_in(content_type=[ntou('application/json'), ntou('text/javascript')],
16		force=True, debug=False, processor = json_processor):
	17	force=True, debug=False, processor=json_processor):
17	18	"""Add a processor to parse JSON request entities:
18	19	The default processor places the parsed data into request.json.
19	20

21	22	be deserialized from JSON to the Python equivalent, and the result
22	23	stored at cherrypy.request.json. The 'content_type' argument may
23	24	be a Content-Type string or a list of allowable Content-Type strings.
24
	25
25	26	If the 'force' argument is True (the default), then entities of other
26	27	content types will not be allowed; "415 Unsupported Media Type" is
27	28	raised instead.
28
	29
29	30	Supply your own processor to use a custom decoder, or to handle the parsed
30	31	data differently. The processor can be configured via
31	32	tools.json_in.processor or via the decorator method.

34	35	request header, or it will raise "411 Length Required". If for any
35	36	other reason the request entity cannot be deserialized from JSON,
36	37	it will raise "400 Bad Request: Invalid JSON document".
37
	38
38	39	You must be using Python 2.6 or greater, or have the 'simplejson'
39	40	package importable; otherwise, ValueError is raised during processing.
40	41	"""
41	42	request = cherrypy.serving.request
42	43	if isinstance(content_type, basestring):
43	44	content_type = [content_type]
44
	45
45	46	if force:
46	47	if debug:
47	48	cherrypy.log('Removing body processors %s' %

50	51	request.body.default_proc = cherrypy.HTTPError(
51	52	415, 'Expected an entity of content type %s' %
52	53	', '.join(content_type))
53
	54
54	55	for ct in content_type:
55	56	if debug:
56	57	cherrypy.log('Adding body processor for %s' % ct, 'TOOLS.JSON_IN')
57	58	request.body.processors[ct] = processor
58	59
	60
59	61	def json_handler(args, *kwargs):
60	62	value = cherrypy.serving.request._json_inner_handler(args, *kwargs)
61	63	return json_encode(value)
62	64
63		def json_out(content_type='application/json', debug=False, handler=json_handler):
	65
	66	def json_out(content_type='application/json', debug=False,
	67	handler=json_handler):
64	68	"""Wrap request.handler to serialize its output to JSON. Sets Content-Type.
65
	69
66	70	If the given content_type is None, the Content-Type response header
67	71	is not set.
68	72

74	78	package importable; otherwise, ValueError is raised during processing.
75	79	"""
76	80	request = cherrypy.serving.request
	81	# request.handler may be set to None by e.g. the caching tool
	82	# to signal to all components that a response body has already
	83	# been attached, in which case we don't need to wrap anything.
	84	if request.handler is None:
	85	return
77	86	if debug:
78	87	cherrypy.log('Replacing %s with JSON handler' % request.handler,
79	88	'TOOLS.JSON_OUT')

81	90	request.handler = handler
82	91	if content_type is not None:
83	92	if debug:
84		cherrypy.log('Setting Content-Type to %s' % content_type, 'TOOLS.JSON_OUT')
	93	cherrypy.log('Setting Content-Type to %s' %
	94	content_type, 'TOOLS.JSON_OUT')
85	95	cherrypy.serving.response.headers['Content-Type'] = content_type
86

+147

-0

cherrypy/lib/lockfile.py less more

	0	"""
	1	Platform-independent file locking. Inspired by and modeled after zc.lockfile.
	2	"""
	3
	4	import os
	5
	6	try:
	7	import msvcrt
	8	except ImportError:
	9	pass
	10
	11	try:
	12	import fcntl
	13	except ImportError:
	14	pass
	15
	16
	17	class LockError(Exception):
	18
	19	"Could not obtain a lock"
	20
	21	msg = "Unable to lock %r"
	22
	23	def __init__(self, path):
	24	super(LockError, self).__init__(self.msg % path)
	25
	26
	27	class UnlockError(LockError):
	28
	29	"Could not release a lock"
	30
	31	msg = "Unable to unlock %r"
	32
	33
	34	# first, a default, naive locking implementation
	35	class LockFile(object):
	36
	37	"""
	38	A default, naive locking implementation. Always fails if the file
	39	already exists.
	40	"""
	41
	42	def __init__(self, path):
	43	self.path = path
	44	try:
	45	fd = os.open(path, os.O_CREAT \| os.O_WRONLY \| os.O_EXCL)
	46	except OSError:
	47	raise LockError(self.path)
	48	os.close(fd)
	49
	50	def release(self):
	51	os.remove(self.path)
	52
	53	def remove(self):
	54	pass
	55
	56
	57	class SystemLockFile(object):
	58
	59	"""
	60	An abstract base class for platform-specific locking.
	61	"""
	62
	63	def __init__(self, path):
	64	self.path = path
	65
	66	try:
	67	# Open lockfile for writing without truncation:
	68	self.fp = open(path, 'r+')
	69	except IOError:
	70	# If the file doesn't exist, IOError is raised; Use a+ instead.
	71	# Note that there may be a race here. Multiple processes
	72	# could fail on the r+ open and open the file a+, but only
	73	# one will get the the lock and write a pid.
	74	self.fp = open(path, 'a+')
	75
	76	try:
	77	self._lock_file()
	78	except:
	79	self.fp.seek(1)
	80	self.fp.close()
	81	del self.fp
	82	raise
	83
	84	self.fp.write(" %s\n" % os.getpid())
	85	self.fp.truncate()
	86	self.fp.flush()
	87
	88	def release(self):
	89	if not hasattr(self, 'fp'):
	90	return
	91	self._unlock_file()
	92	self.fp.close()
	93	del self.fp
	94
	95	def remove(self):
	96	"""
	97	Attempt to remove the file
	98	"""
	99	try:
	100	os.remove(self.path)
	101	except:
	102	pass
	103
	104	#@abc.abstract_method
	105	# def _lock_file(self):
	106	# """Attempt to obtain the lock on self.fp. Raise LockError if not
	107	# acquired."""
	108
	109	def _unlock_file(self):
	110	"""Attempt to obtain the lock on self.fp. Raise UnlockError if not
	111	released."""
	112
	113
	114	class WindowsLockFile(SystemLockFile):
	115
	116	def _lock_file(self):
	117	# Lock just the first byte
	118	try:
	119	msvcrt.locking(self.fp.fileno(), msvcrt.LK_NBLCK, 1)
	120	except IOError:
	121	raise LockError(self.fp.name)
	122
	123	def _unlock_file(self):
	124	try:
	125	self.fp.seek(0)
	126	msvcrt.locking(self.fp.fileno(), msvcrt.LK_UNLCK, 1)
	127	except IOError:
	128	raise UnlockError(self.fp.name)
	129
	130	if 'msvcrt' in globals():
	131	LockFile = WindowsLockFile
	132
	133
	134	class UnixLockFile(SystemLockFile):
	135
	136	def _lock_file(self):
	137	flags = fcntl.LOCK_EX \| fcntl.LOCK_NB
	138	try:
	139	fcntl.flock(self.fp.fileno(), flags)
	140	except IOError:
	141	raise LockError(self.fp.name)
	142
	143	# no need to implement _unlock_file, it will be unlocked on close()
	144
	145	if 'fcntl' in globals():
	146	LockFile = UnixLockFile

+47

-0

cherrypy/lib/locking.py less more

	0	import datetime
	1
	2
	3	class NeverExpires(object):
	4	def expired(self):
	5	return False
	6
	7
	8	class Timer(object):
	9	"""
	10	A simple timer that will indicate when an expiration time has passed.
	11	"""
	12	def __init__(self, expiration):
	13	"Create a timer that expires at `expiration` (UTC datetime)"
	14	self.expiration = expiration
	15
	16	@classmethod
	17	def after(cls, elapsed):
	18	"""
	19	Return a timer that will expire after `elapsed` passes.
	20	"""
	21	return cls(datetime.datetime.utcnow() + elapsed)
	22
	23	def expired(self):
	24	return datetime.datetime.utcnow() >= self.expiration
	25
	26
	27	class LockTimeout(Exception):
	28	"An exception when a lock could not be acquired before a timeout period"
	29
	30
	31	class LockChecker(object):
	32	"""
	33	Keep track of the time and detect if a timeout has expired
	34	"""
	35	def __init__(self, session_id, timeout):
	36	self.session_id = session_id
	37	if timeout:
	38	self.timer = Timer.after(timeout)
	39	else:
	40	self.timer = NeverExpires()
	41
	42	def expired(self):
	43	if self.timer.expired():
	44	raise LockTimeout(
	45	"Timeout acquiring lock for %(session_id)s" % vars(self))
	46	return False

+41

-33

cherrypy/lib/profiler.py less more

5	5	You can profile any of your pages as follows::
6	6
7	7	from cherrypy.lib import profiler
8
	8
9	9	class Root:
10	10	p = profile.Profiler("/path/to/profile/dir")
11
	11
12	12	def index(self):
13	13	self.p.run(self._index)
14	14	index.exposed = True
15
	15
16	16	def _index(self):
17	17	return "Hello, world!"
18
	18
19	19	cherrypy.tree.mount(Root())
20	20
21	21	You can also turn on profiling for all requests

34	34
35	35
36	36	def new_func_strip_path(func_name):
37		"""Make profiler output more readable by adding ``__init__`` modules' parents"""
	37	"""Make profiler output more readable by adding `__init__` modules' parents
	38	"""
38	39	filename, line, name = func_name
39	40	if filename.endswith("__init__.py"):
40	41	return os.path.basename(filename[:-12]) + filename[-12:], line, name

48	49	profile = None
49	50	pstats = None
50	51
51		import os, os.path
	52	import os
	53	import os.path
52	54	import sys
53	55	import warnings
54	56
55		from cherrypy._cpcompat import BytesIO
	57	from cherrypy._cpcompat import StringIO
56	58
57	59	_count = 0
58	60
	61
59	62	class Profiler(object):
60
	63
61	64	def __init__(self, path=None):
62	65	if not path:
63	66	path = os.path.join(os.path.dirname(__file__), "profile")
64	67	self.path = path
65	68	if not os.path.exists(path):
66	69	os.makedirs(path)
67
	70
68	71	def run(self, func, args, *params):
69	72	"""Dump profile data into self.path."""
70	73	global _count

74	77	result = prof.runcall(func, args, *params)
75	78	prof.dump_stats(path)
76	79	return result
77
	80
78	81	def statfiles(self):
79	82	""":rtype: list of available profiles.
80	83	"""
81	84	return [f for f in os.listdir(self.path)
82	85	if f.startswith("cp_") and f.endswith(".prof")]
83
	86
84	87	def stats(self, filename, sortby='cumulative'):
85	88	""":rtype stats(index): output of print_stats() for the given profile.
86	89	"""
87		sio = BytesIO()
	90	sio = StringIO()
88	91	if sys.version_info >= (2, 5):
89	92	s = pstats.Stats(os.path.join(self.path, filename), stream=sio)
90	93	s.strip_dirs()

105	108	response = sio.getvalue()
106	109	sio.close()
107	110	return response
108
	111
109	112	def index(self):
110	113	return """<html>
111	114	<head><title>CherryPy profile data</title></head>

116	119	</html>
117	120	"""
118	121	index.exposed = True
119
	122
120	123	def menu(self):
121	124	yield "<h2>Profiling runs</h2>"
122	125	yield "<p>Click on one of the runs below to see profiling data.</p>"
123	126	runs = self.statfiles()
124	127	runs.sort()
125	128	for i in runs:
126		yield "<a href='report?filename=%s' target='main'>%s</a><br />" % (i, i)
	129	yield "<a href='report?filename=%s' target='main'>%s</a><br />" % (
	130	i, i)
127	131	menu.exposed = True
128
	132
129	133	def report(self, filename):
130	134	import cherrypy
131	135	cherrypy.response.headers['Content-Type'] = 'text/plain'

134	138
135	139
136	140	class ProfileAggregator(Profiler):
137
	141
138	142	def __init__(self, path=None):
139	143	Profiler.__init__(self, path)
140	144	global _count
141	145	self.count = _count = _count + 1
142	146	self.profiler = profile.Profile()
143
144		def run(self, func, *args):
	147
	148	def run(self, func, args, *params):
145	149	path = os.path.join(self.path, "cp_%04d.prof" % self.count)
146		result = self.profiler.runcall(func, *args)
	150	result = self.profiler.runcall(func, args, *params)
147	151	self.profiler.dump_stats(path)
148	152	return result
149	153
150	154
151	155	class make_app:
	156
152	157	def __init__(self, nextapp, path=None, aggregate=False):
153	158	"""Make a WSGI middleware app which wraps 'nextapp' with profiling.
154
	159
155	160	nextapp
156	161	the WSGI application to wrap, usually an instance of
157	162	cherrypy.Application.
158
	163
159	164	path
160	165	where to dump the profiling output.
161
	166
162	167	aggregate
163	168	if True, profile data for all HTTP requests will go in
164	169	a single file. If False (the default), each HTTP request will
165	170	dump its profile data into a separate file.
166
	171
167	172	"""
168	173	if profile is None or pstats is None:
169		msg = ("Your installation of Python does not have a profile module. "
170		"If you're on Debian, try `sudo apt-get install python-profiler`. "
171		"See http://www.cherrypy.org/wiki/ProfilingOnDebian for details.")
	174	msg = ("Your installation of Python does not have a profile "
	175	"module. If you're on Debian, try "
	176	"`sudo apt-get install python-profiler`. "
	177	"See http://www.cherrypy.org/wiki/ProfilingOnDebian "
	178	"for details.")
172	179	warnings.warn(msg)
173
	180
174	181	self.nextapp = nextapp
175	182	self.aggregate = aggregate
176	183	if aggregate:
177	184	self.profiler = ProfileAggregator(path)
178	185	else:
179	186	self.profiler = Profiler(path)
180
	187
181	188	def __call__(self, environ, start_response):
182	189	def gather():
183	190	result = []

190	197	def serve(path=None, port=8080):
191	198	if profile is None or pstats is None:
192	199	msg = ("Your installation of Python does not have a profile module. "
193		"If you're on Debian, try `sudo apt-get install python-profiler`. "
194		"See http://www.cherrypy.org/wiki/ProfilingOnDebian for details.")
	200	"If you're on Debian, try "
	201	"`sudo apt-get install python-profiler`. "
	202	"See http://www.cherrypy.org/wiki/ProfilingOnDebian "
	203	"for details.")
195	204	warnings.warn(msg)
196
	205
197	206	import cherrypy
198	207	cherrypy.config.update({'server.socket_port': int(port),
199	208	'server.thread_pool': 10,

204	213
205	214	if __name__ == "__main__":
206	215	serve(*tuple(sys.argv[1:]))
207

+98

-80

cherrypy/lib/reprconf.py less more

42	42
43	43	import operator as _operator
44	44	import sys
	45
45	46
46	47	def as_dict(config):
47	48	"""Return a dict from 'config' whether it is a dict, file, or filename."""

53	54
54	55
55	56	class NamespaceSet(dict):
	57
56	58	"""A dict of config namespace names and handlers.
57
	59
58	60	Each config entry should begin with a namespace name; the corresponding
59	61	namespace handler will be called once for each config entry in that
60	62	namespace, and will be passed two arguments: the config key (with the
61	63	namespace removed) and the config value.
62
	64
63	65	Namespace handlers may be any Python callable; they may also be
64	66	Python 2.5-style 'context managers', in which case their __enter__
65	67	method should return a callable to be used as the handler.
66	68	See cherrypy.tools (the Toolbox class) for an example.
67	69	"""
68
	70
69	71	def __call__(self, config):
70	72	"""Iterate through config and pass it to each namespace handler.
71
	73
72	74	config
73	75	A flat dict, where keys use dots to separate
74	76	namespaces, and values are arbitrary.
75
	77
76	78	The first name in each config key is used to look up the corresponding
77	79	namespace handler. For example, a config entry of {'tools.gzip.on': v}
78	80	will call the 'tools' namespace handler with the args: ('gzip.on', v)

84	86	ns, name = k.split(".", 1)
85	87	bucket = ns_confs.setdefault(ns, {})
86	88	bucket[name] = config[k]
87
	89
88	90	# I chose __enter__ and __exit__ so someday this could be
89	91	# rewritten using Python 2.5's 'with' statement:
90	92	# for ns, handler in self.iteritems():

115	117	else:
116	118	for k, v in ns_confs.get(ns, {}).items():
117	119	handler(k, v)
118
	120
119	121	def __repr__(self):
120	122	return "%s.%s(%s)" % (self.__module__, self.__class__.__name__,
121	123	dict.__repr__(self))
122
	124
123	125	def __copy__(self):
124	126	newobj = self.__class__()
125	127	newobj.update(self)

128	130
129	131
130	132	class Config(dict):
	133
131	134	"""A dict-like set of configuration data, with defaults and namespaces.
132
	135
133	136	May take a file, filename, or dict.
134	137	"""
135
	138
136	139	defaults = {}
137	140	environments = {}
138	141	namespaces = NamespaceSet()
139
	142
140	143	def __init__(self, file=None, **kwargs):
141	144	self.reset()
142	145	if file is not None:
143	146	self.update(file)
144	147	if kwargs:
145	148	self.update(kwargs)
146
	149
147	150	def reset(self):
148	151	"""Reset self to default values."""
149	152	self.clear()
150	153	dict.update(self, self.defaults)
151
	154
152	155	def update(self, config):
153	156	"""Update self from a dict, file or filename."""
154	157	if isinstance(config, basestring):

160	163	else:
161	164	config = config.copy()
162	165	self._apply(config)
163
	166
164	167	def _apply(self, config):
165	168	"""Update self from a dict."""
166	169	which_env = config.get('environment')

169	172	for k in env:
170	173	if k not in config:
171	174	config[k] = env[k]
172
	175
173	176	dict.update(self, config)
174	177	self.namespaces(config)
175
	178
176	179	def __setitem__(self, k, v):
177	180	dict.__setitem__(self, k, v)
178	181	self.namespaces({k: v})
179	182
180	183
181	184	class Parser(ConfigParser):
182		"""Sub-class of ConfigParser that keeps the case of options and that
	185
	186	"""Sub-class of ConfigParser that keeps the case of options and that
183	187	raises an exception if the file cannot be read.
184	188	"""
185
	189
186	190	def optionxform(self, optionstr):
187	191	return optionstr
188
	192
189	193	def read(self, filenames):
190	194	if isinstance(filenames, basestring):
191	195	filenames = [filenames]

199	203	self._read(fp, filename)
200	204	finally:
201	205	fp.close()
202
	206
203	207	def as_dict(self, raw=False, vars=None):
204	208	"""Convert an INI file to a dictionary"""
205	209	# Load INI file into a dict

219	223	raise ValueError(msg, x.__class__.__name__, x.args)
220	224	result[section][option] = value
221	225	return result
222
	226
223	227	def dict_from_file(self, file):
224	228	if hasattr(file, 'read'):
225	229	self.readfp(file)

232	236
233	237
234	238	class _Builder2:
235
	239
236	240	def build(self, o):
237	241	m = getattr(self, 'build_' + o.__class__.__name__, None)
238	242	if m is None:
239	243	raise TypeError("unrepr does not recognize %s" %
240	244	repr(o.__class__.__name__))
241	245	return m(o)
242
	246
243	247	def astnode(self, s):
244	248	"""Return a Python2 ast Node compiled from a string."""
245	249	try:

248	252	# Fallback to eval when compiler package is not available,
249	253	# e.g. IronPython 1.0.
250	254	return eval(s)
251
	255
252	256	p = compiler.parse("__tempvalue__ = " + s)
253	257	return p.getChildren()[1].getChildren()[0].getChildren()[1]
254
	258
255	259	def build_Subscript(self, o):
256	260	expr, flags, subs = o.getChildren()
257	261	expr = self.build(expr)
258	262	subs = self.build(subs)
259	263	return expr[subs]
260
	264
261	265	def build_CallFunc(self, o):
262		children = map(self.build, o.getChildren())
263		callee = children.pop(0)
264		kwargs = children.pop() or {}
265		starargs = children.pop() or ()
266		args = tuple(children) + tuple(starargs)
	266	children = o.getChildren()
	267	# Build callee from first child
	268	callee = self.build(children[0])
	269	# Build args and kwargs from remaining children
	270	args = []
	271	kwargs = {}
	272	for child in children[1:]:
	273	class_name = child.__class__.__name__
	274	# None is ignored
	275	if class_name == 'NoneType':
	276	continue
	277	# Keywords become kwargs
	278	if class_name == 'Keyword':
	279	kwargs.update(self.build(child))
	280	# Everything else becomes args
	281	else :
	282	args.append(self.build(child))
267	283	return callee(args, *kwargs)
268
	284
	285	def build_Keyword(self, o):
	286	key, value_obj = o.getChildren()
	287	value = self.build(value_obj)
	288	kw_dict = {key: value}
	289	return kw_dict
	290
269	291	def build_List(self, o):
270	292	return map(self.build, o.getChildren())
271
	293
272	294	def build_Const(self, o):
273	295	return o.value
274
	296
275	297	def build_Dict(self, o):
276	298	d = {}
277	299	i = iter(map(self.build, o.getChildren()))
278	300	for el in i:
279	301	d[el] = i.next()
280	302	return d
281
	303
282	304	def build_Tuple(self, o):
283	305	return tuple(self.build_List(o))
284
	306
285	307	def build_Name(self, o):
286	308	name = o.name
287	309	if name == 'None':

290	312	return True
291	313	if name == 'False':
292	314	return False
293
	315
294	316	# See if the Name is a package or module. If it is, import it.
295	317	try:
296	318	return modules(name)
297	319	except ImportError:
298	320	pass
299
	321
300	322	# See if the Name is in builtins.
301	323	try:
302	324	return getattr(builtins, name)
303	325	except AttributeError:
304	326	pass
305
	327
306	328	raise TypeError("unrepr could not resolve the name %s" % repr(name))
307
	329
308	330	def build_Add(self, o):
309	331	left, right = map(self.build, o.getChildren())
310	332	return left + right

312	334	def build_Mul(self, o):
313	335	left, right = map(self.build, o.getChildren())
314	336	return left * right
315
	337
316	338	def build_Getattr(self, o):
317	339	parent = self.build(o.expr)
318	340	return getattr(parent, o.attrname)
319
	341
320	342	def build_NoneType(self, o):
321	343	return None
322
	344
323	345	def build_UnarySub(self, o):
324	346	return -self.build(o.getChildren()[0])
325
	347
326	348	def build_UnaryAdd(self, o):
327	349	return self.build(o.getChildren()[0])
328	350
329	351
330	352	class _Builder3:
331
	353
332	354	def build(self, o):
333	355	m = getattr(self, 'build_' + o.__class__.__name__, None)
334	356	if m is None:
335	357	raise TypeError("unrepr does not recognize %s" %
336	358	repr(o.__class__.__name__))
337	359	return m(o)
338
	360
339	361	def astnode(self, s):
340	362	"""Return a Python3 ast Node compiled from a string."""
341	363	try:

350	372
351	373	def build_Subscript(self, o):
352	374	return self.build(o.value)[self.build(o.slice)]
353
	375
354	376	def build_Index(self, o):
355	377	return self.build(o.value)
356
	378
357	379	def build_Call(self, o):
358	380	callee = self.build(o.func)
359
	381
360	382	if o.args is None:
361	383	args = ()
362		else:
363		args = tuple([self.build(a) for a in o.args])
364
	384	else:
	385	args = tuple([self.build(a) for a in o.args])
	386
365	387	if o.starargs is None:
366	388	starargs = ()
367	389	else:
368	390	starargs = self.build(o.starargs)
369
	391
370	392	if o.kwargs is None:
371	393	kwargs = {}
372	394	else:
373	395	kwargs = self.build(o.kwargs)
374
	396
375	397	return callee((args + starargs), *kwargs)
376
	398
377	399	def build_List(self, o):
378	400	return list(map(self.build, o.elts))
379
	401
380	402	def build_Str(self, o):
381	403	return o.s
382
	404
383	405	def build_Num(self, o):
384	406	return o.n
385
	407
386	408	def build_Dict(self, o):
387	409	return dict([(self.build(k), self.build(v))
388	410	for k, v in zip(o.keys, o.values)])
389
	411
390	412	def build_Tuple(self, o):
391	413	return tuple(self.build_List(o))
392
	414
393	415	def build_Name(self, o):
394	416	name = o.id
395	417	if name == 'None':

398	420	return True
399	421	if name == 'False':
400	422	return False
401
	423
402	424	# See if the Name is a package or module. If it is, import it.
403	425	try:
404	426	return modules(name)
405	427	except ImportError:
406	428	pass
407
	429
408	430	# See if the Name is in builtins.
409	431	try:
410	432	import builtins
411	433	return getattr(builtins, name)
412	434	except AttributeError:
413	435	pass
414
	436
415	437	raise TypeError("unrepr could not resolve the name %s" % repr(name))
416
	438
	439	def build_NameConstant(self, o):
	440	return o.value
	441
417	442	def build_UnaryOp(self, o):
418	443	op, operand = map(self.build, [o.op, o.operand])
419	444	return op(operand)
420
	445
421	446	def build_BinOp(self, o):
422		left, op, right = map(self.build, [o.left, o.op, o.right])
	447	left, op, right = map(self.build, [o.left, o.op, o.right])
423	448	return op(left, right)
424	449
425	450	def build_Add(self, o):

427	452
428	453	def build_Mult(self, o):
429	454	return _operator.mul
430
	455
431	456	def build_USub(self, o):
432	457	return _operator.neg
433	458

453	478
454	479	def modules(modulePath):
455	480	"""Load a module and retrieve a reference to that module."""
456		try:
457		mod = sys.modules[modulePath]
458		if mod is None:
459		raise KeyError()
460		except KeyError:
461		# The last [''] is important.
462		mod = __import__(modulePath, globals(), locals(), [''])
463		return mod
	481	__import__(modulePath)
	482	return sys.modules[modulePath]
	483
464	484
465	485	def attributes(full_attribute_name):
466	486	"""Load a module and retrieve an attribute of that module."""
467
	487
468	488	# Parse out the path, module, and attribute
469	489	last_dot = full_attribute_name.rfind(".")
470	490	attr_name = full_attribute_name[last_dot + 1:]
471	491	mod_path = full_attribute_name[:last_dot]
472
	492
473	493	mod = modules(mod_path)
474	494	# Let an AttributeError propagate outward.
475	495	try:

477	497	except AttributeError:
478	498	raise AttributeError("'%s' object has no attribute '%s'"
479	499	% (mod_path, attr_name))
480
	500
481	501	# Return a reference to the attribute.
482	502	return attr
483
484

+267

-174

cherrypy/lib/sessions.py less more

7	7	tools.sessions.storage_path = "/home/site/sessions"
8	8	tools.sessions.timeout = 60
9	9
10		This sets the session to be stored in files in the directory /home/site/sessions,
11		and the session timeout to 60 minutes. If you omit ``storage_type`` the sessions
12		will be saved in RAM. ``tools.sessions.on`` is the only required line for
13		working sessions, the rest are optional.
	10	This sets the session to be stored in files in the directory
	11	/home/site/sessions, and the session timeout to 60 minutes. If you omit
	12	``storage_type`` the sessions will be saved in RAM.
	13	``tools.sessions.on`` is the only required line for working sessions,
	14	the rest are optional.
14	15
15	16	By default, the session ID is passed in a cookie, so the client's browser must
16	17	have cookies enabled for your site.

24	25	================
25	26
26	27	By default, the ``'locking'`` mode of sessions is ``'implicit'``, which means
27		the session is locked early and unlocked late. If you want to control when the
28		session data is locked and unlocked, set ``tools.sessions.locking = 'explicit'``.
29		Then call ``cherrypy.session.acquire_lock()`` and ``cherrypy.session.release_lock()``.
	28	the session is locked early and unlocked late. Be mindful of this default mode
	29	for any requests that take a long time to process (streaming responses,
	30	expensive calculations, database lookups, API calls, etc), as other concurrent
	31	requests that also utilize sessions will hang until the session is unlocked.
	32
	33	If you want to control when the session data is locked and unlocked,
	34	set ``tools.sessions.locking = 'explicit'``. Then call
	35	``cherrypy.session.acquire_lock()`` and ``cherrypy.session.release_lock()``.
30	36	Regardless of which mode you use, the session is guaranteed to be unlocked when
31	37	the request is complete.
32	38

82	88	expiration date, although this was on a system with an inaccurate system time.
83	89	Maybe FF doesn't trust system time.
84	90	"""
85
	91	import sys
86	92	import datetime
87	93	import os
88		import random
89	94	import time
90	95	import threading
91	96	import types
92		from warnings import warn
93	97
94	98	import cherrypy
95	99	from cherrypy._cpcompat import copyitems, pickle, random20, unicodestr
96	100	from cherrypy.lib import httputil
97
	101	from cherrypy.lib import lockfile
	102	from cherrypy.lib import locking
	103	from cherrypy.lib import is_iterator
98	104
99	105	missing = object()
100	106
	107
101	108	class Session(object):
	109
102	110	"""A CherryPy dict-like Session object (one per request)."""
103
	111
104	112	_id = None
105
	113
106	114	id_observers = None
107	115	"A list of callbacks to which to pass new id's."
108
	116
109	117	def _get_id(self):
110	118	return self._id
	119
111	120	def _set_id(self, value):
112	121	self._id = value
113	122	for o in self.id_observers:
114	123	o(value)
115	124	id = property(_get_id, _set_id, doc="The current session ID.")
116
	125
117	126	timeout = 60
118	127	"Number of minutes after which to delete session data."
119
	128
120	129	locked = False
121	130	"""
122	131	If True, this session instance has exclusive read/write access
123	132	to session data."""
124
	133
125	134	loaded = False
126	135	"""
127	136	If True, data has been retrieved from storage. This should happen
128	137	automatically on the first attempt to access session data."""
129
	138
130	139	clean_thread = None
131	140	"Class-level Monitor which calls self.clean_up."
132
	141
133	142	clean_freq = 5
134	143	"The poll rate for expired session cleanup in minutes."
135
	144
136	145	originalid = None
137	146	"The session id passed by the client. May be missing or unsafe."
138
	147
139	148	missing = False
140	149	"True if the session requested by the client did not exist."
141
	150
142	151	regenerated = False
143	152	"""
144	153	True if the application called session.regenerate(). This is not set by
145	154	internal calls to regenerate the session id."""
146
147		debug=False
148
	155
	156	debug = False
	157	"If True, log debug information."
	158
	159	# --------------------- Session management methods --------------------- #
	160
149	161	def __init__(self, id=None, **kwargs):
150	162	self.id_observers = []
151	163	self._data = {}
152
	164
153	165	for k, v in kwargs.items():
154	166	setattr(self, k, v)
155
	167
156	168	self.originalid = id
157	169	self.missing = False
158	170	if id is None:

161	173	self._regenerate()
162	174	else:
163	175	self.id = id
164		if not self._exists():
	176	if self._exists():
	177	if self.debug:
	178	cherrypy.log('Set id to %s.' % id, 'TOOLS.SESSIONS')
	179	else:
165	180	if self.debug:
166	181	cherrypy.log('Expired or malicious session %r; '
167	182	'making a new one' % id, 'TOOLS.SESSIONS')
168	183	# Expired or malicious session. Make a new one.
169		# See http://www.cherrypy.org/ticket/709.
	184	# See https://bitbucket.org/cherrypy/cherrypy/issue/709.
170	185	self.id = None
171	186	self.missing = True
172	187	self._regenerate()

183	198	"""Replace the current session (with a new id)."""
184	199	self.regenerated = True
185	200	self._regenerate()
186
	201
187	202	def _regenerate(self):
188	203	if self.id is not None:
	204	if self.debug:
	205	cherrypy.log(
	206	'Deleting the existing session %r before '
	207	'regeneration.' % self.id,
	208	'TOOLS.SESSIONS')
189	209	self.delete()
190
	210
191	211	old_session_was_locked = self.locked
192	212	if old_session_was_locked:
193	213	self.release_lock()
194
	214	if self.debug:
	215	cherrypy.log('Old lock released.', 'TOOLS.SESSIONS')
	216
195	217	self.id = None
196	218	while self.id is None:
197	219	self.id = self.generate_id()
198	220	# Assert that the generated id is not already stored.
199	221	if self._exists():
200	222	self.id = None
201
	223	if self.debug:
	224	cherrypy.log('Set id to generated %s.' % self.id,
	225	'TOOLS.SESSIONS')
	226
202	227	if old_session_was_locked:
203	228	self.acquire_lock()
204
	229	if self.debug:
	230	cherrypy.log('Regenerated lock acquired.', 'TOOLS.SESSIONS')
	231
205	232	def clean_up(self):
206	233	"""Clean up expired sessions."""
207	234	pass
208
	235
209	236	def generate_id(self):
210	237	"""Return a new session id."""
211	238	return random20()
212
	239
213	240	def save(self):
214	241	"""Save session data."""
215	242	try:
216	243	# If session data has never been loaded then it's never been
217	244	# accessed: no need to save it
218	245	if self.loaded:
219		t = datetime.timedelta(seconds = self.timeout * 60)
	246	t = datetime.timedelta(seconds=self.timeout * 60)
220	247	expiration_time = self.now() + t
221	248	if self.debug:
222		cherrypy.log('Saving with expiry %s' % expiration_time,
	249	cherrypy.log('Saving session %r with expiry %s' %
	250	(self.id, expiration_time),
223	251	'TOOLS.SESSIONS')
224	252	self._save(expiration_time)
225
	253	else:
	254	if self.debug:
	255	cherrypy.log(
	256	'Skipping save of session %r (no session loaded).' %
	257	self.id, 'TOOLS.SESSIONS')
226	258	finally:
227	259	if self.locked:
228	260	# Always release the lock if the user didn't release it
229	261	self.release_lock()
230
	262	if self.debug:
	263	cherrypy.log('Lock released after save.', 'TOOLS.SESSIONS')
	264
231	265	def load(self):
232	266	"""Copy stored session data into this session instance."""
233	267	data = self._load()
234	268	# data is either None or a tuple (session_data, expiration_time)
235	269	if data is None or data[1] < self.now():
236	270	if self.debug:
237		cherrypy.log('Expired session, flushing data', 'TOOLS.SESSIONS')
	271	cherrypy.log('Expired session %r, flushing data.' % self.id,
	272	'TOOLS.SESSIONS')
238	273	self._data = {}
239	274	else:
	275	if self.debug:
	276	cherrypy.log('Data loaded for session %r.' % self.id,
	277	'TOOLS.SESSIONS')
240	278	self._data = data[0]
241	279	self.loaded = True
242
	280
243	281	# Stick the clean_thread in the class, not the instance.
244	282	# The instances are created and destroyed per-request.
245	283	cls = self.__class__
246	284	if self.clean_freq and not cls.clean_thread:
247		# clean_up is in instancemethod and not a classmethod,
	285	# clean_up is an instancemethod and not a classmethod,
248	286	# so that tool config can be accessed inside the method.
249	287	t = cherrypy.process.plugins.Monitor(
250	288	cherrypy.engine, self.clean_up, self.clean_freq * 60,

252	290	t.subscribe()
253	291	cls.clean_thread = t
254	292	t.start()
255
	293	if self.debug:
	294	cherrypy.log('Started cleanup thread.', 'TOOLS.SESSIONS')
	295
256	296	def delete(self):
257	297	"""Delete stored session data."""
258	298	self._delete()
259
	299	if self.debug:
	300	cherrypy.log('Deleted session %s.' % self.id,
	301	'TOOLS.SESSIONS')
	302
	303	# -------------------- Application accessor methods -------------------- #
	304
260	305	def __getitem__(self, key):
261		if not self.loaded: self.load()
	306	if not self.loaded:
	307	self.load()
262	308	return self._data[key]
263
	309
264	310	def __setitem__(self, key, value):
265		if not self.loaded: self.load()
	311	if not self.loaded:
	312	self.load()
266	313	self._data[key] = value
267
	314
268	315	def __delitem__(self, key):
269		if not self.loaded: self.load()
	316	if not self.loaded:
	317	self.load()
270	318	del self._data[key]
271
	319
272	320	def pop(self, key, default=missing):
273	321	"""Remove the specified key and return the corresponding value.
274	322	If key is not found, default is returned if given,
275	323	otherwise KeyError is raised.
276	324	"""
277		if not self.loaded: self.load()
	325	if not self.loaded:
	326	self.load()
278	327	if default is missing:
279	328	return self._data.pop(key)
280	329	else:
281	330	return self._data.pop(key, default)
282
	331
283	332	def __contains__(self, key):
284		if not self.loaded: self.load()
	333	if not self.loaded:
	334	self.load()
285	335	return key in self._data
286
	336
287	337	if hasattr({}, 'has_key'):
288	338	def has_key(self, key):
289	339	"""D.has_key(k) -> True if D has a key k, else False."""
290		if not self.loaded: self.load()
	340	if not self.loaded:
	341	self.load()
291	342	return key in self._data
292
	343
293	344	def get(self, key, default=None):
294	345	"""D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None."""
295		if not self.loaded: self.load()
	346	if not self.loaded:
	347	self.load()
296	348	return self._data.get(key, default)
297
	349
298	350	def update(self, d):
299	351	"""D.update(E) -> None. Update D from E: for k in E: D[k] = E[k]."""
300		if not self.loaded: self.load()
	352	if not self.loaded:
	353	self.load()
301	354	self._data.update(d)
302
	355
303	356	def setdefault(self, key, default=None):
304	357	"""D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D."""
305		if not self.loaded: self.load()
	358	if not self.loaded:
	359	self.load()
306	360	return self._data.setdefault(key, default)
307
	361
308	362	def clear(self):
309	363	"""D.clear() -> None. Remove all items from D."""
310		if not self.loaded: self.load()
	364	if not self.loaded:
	365	self.load()
311	366	self._data.clear()
312
	367
313	368	def keys(self):
314	369	"""D.keys() -> list of D's keys."""
315		if not self.loaded: self.load()
	370	if not self.loaded:
	371	self.load()
316	372	return self._data.keys()
317
	373
318	374	def items(self):
319	375	"""D.items() -> list of D's (key, value) pairs, as 2-tuples."""
320		if not self.loaded: self.load()
	376	if not self.loaded:
	377	self.load()
321	378	return self._data.items()
322
	379
323	380	def values(self):
324	381	"""D.values() -> list of D's values."""
325		if not self.loaded: self.load()
	382	if not self.loaded:
	383	self.load()
326	384	return self._data.values()
327	385
328	386
329	387	class RamSession(Session):
330
	388
331	389	# Class-level objects. Don't rebind these!
332	390	cache = {}
333	391	locks = {}
334
	392
335	393	def clean_up(self):
336	394	"""Clean up expired sessions."""
337	395	now = self.now()

345	403	del self.locks[id]
346	404	except KeyError:
347	405	pass
348
	406
349	407	# added to remove obsolete lock objects
350	408	for id in list(self.locks):
351	409	if id not in self.cache:
352	410	self.locks.pop(id, None)
353
	411
354	412	def _exists(self):
355	413	return self.id in self.cache
356
	414
357	415	def _load(self):
358	416	return self.cache.get(self.id)
359
	417
360	418	def _save(self, expiration_time):
361	419	self.cache[self.id] = (self._data, expiration_time)
362
	420
363	421	def _delete(self):
364	422	self.cache.pop(self.id, None)
365
	423
366	424	def acquire_lock(self):
367	425	"""Acquire an exclusive lock on the currently-loaded session data."""
368	426	self.locked = True
369	427	self.locks.setdefault(self.id, threading.RLock()).acquire()
370
	428
371	429	def release_lock(self):
372	430	"""Release the lock on the currently-loaded session data."""
373	431	self.locks[self.id].release()
374	432	self.locked = False
375
	433
376	434	def __len__(self):
377	435	"""Return the number of active sessions."""
378	436	return len(self.cache)
379	437
380	438
381	439	class FileSession(Session):
	440
382	441	"""Implementation of the File backend for sessions
383
	442
384	443	storage_path
385	444	The folder where session data will be saved. Each session
386	445	will be saved as pickle.dump(data, expiration_time) in its own file;
387	446	the filename will be self.SESSION_PREFIX + self.id.
388
	447
	448	lock_timeout
	449	A timedelta or numeric seconds indicating how long
	450	to block acquiring a lock. If None (default), acquiring a lock
	451	will block indefinitely.
389	452	"""
390
	453
391	454	SESSION_PREFIX = 'session-'
392	455	LOCK_SUFFIX = '.lock'
393	456	pickle_protocol = pickle.HIGHEST_PROTOCOL
394
	457
395	458	def __init__(self, id=None, **kwargs):
396	459	# The 'storage_path' arg is required for file-based sessions.
397	460	kwargs['storage_path'] = os.path.abspath(kwargs['storage_path'])
	461	kwargs.setdefault('lock_timeout', None)
	462
398	463	Session.__init__(self, id=id, **kwargs)
399
	464
	465	# validate self.lock_timeout
	466	if isinstance(self.lock_timeout, (int, float)):
	467	self.lock_timeout = datetime.timedelta(seconds=self.lock_timeout)
	468	if not isinstance(self.lock_timeout, (datetime.timedelta, type(None))):
	469	raise ValueError("Lock timeout must be numeric seconds or "
	470	"a timedelta instance.")
	471
400	472	def setup(cls, **kwargs):
401	473	"""Set up the storage system for file-based sessions.
402
	474
403	475	This should only be called once per process; this will be done
404	476	automatically when using sessions.init (as the built-in Tool does).
405	477	"""
406	478	# The 'storage_path' arg is required for file-based sessions.
407	479	kwargs['storage_path'] = os.path.abspath(kwargs['storage_path'])
408
	480
409	481	for k, v in kwargs.items():
410	482	setattr(cls, k, v)
411
412		# Warn if any lock files exist at startup.
413		lockfiles = [fname for fname in os.listdir(cls.storage_path)
414		if (fname.startswith(cls.SESSION_PREFIX)
415		and fname.endswith(cls.LOCK_SUFFIX))]
416		if lockfiles:
417		plural = ('', 's')[len(lockfiles) > 1]
418		warn("%s session lockfile%s found at startup. If you are "
419		"only running one process, then you may need to "
420		"manually delete the lockfiles found at %r."
421		% (len(lockfiles), plural, cls.storage_path))
422	483	setup = classmethod(setup)
423
	484
424	485	def _get_file_path(self):
425	486	f = os.path.join(self.storage_path, self.SESSION_PREFIX + self.id)
426	487	if not os.path.abspath(f).startswith(self.storage_path):
427	488	raise cherrypy.HTTPError(400, "Invalid session id in cookie.")
428	489	return f
429
	490
430	491	def _exists(self):
431	492	path = self._get_file_path()
432	493	return os.path.exists(path)
433
	494
434	495	def _load(self, path=None):
	496	assert self.locked, ("The session load without being locked. "
	497	"Check your tools' priority levels.")
435	498	if path is None:
436	499	path = self._get_file_path()
437	500	try:

441	504	finally:
442	505	f.close()
443	506	except (IOError, EOFError):
	507	e = sys.exc_info()[1]
	508	if self.debug:
	509	cherrypy.log("Error loading the session pickle: %s" %
	510	e, 'TOOLS.SESSIONS')
444	511	return None
445
	512
446	513	def _save(self, expiration_time):
	514	assert self.locked, ("The session was saved without being locked. "
	515	"Check your tools' priority levels.")
447	516	f = open(self._get_file_path(), "wb")
448	517	try:
449	518	pickle.dump((self._data, expiration_time), f, self.pickle_protocol)
450	519	finally:
451	520	f.close()
452
	521
453	522	def _delete(self):
	523	assert self.locked, ("The session deletion without being locked. "
	524	"Check your tools' priority levels.")
454	525	try:
455	526	os.unlink(self._get_file_path())
456	527	except OSError:
457	528	pass
458
	529
459	530	def acquire_lock(self, path=None):
460	531	"""Acquire an exclusive lock on the currently-loaded session data."""
461	532	if path is None:
462	533	path = self._get_file_path()
463	534	path += self.LOCK_SUFFIX
464		while True:
	535	checker = locking.LockChecker(self.id, self.lock_timeout)
	536	while not checker.expired():
465	537	try:
466		lockfd = os.open(path, os.O_CREAT\|os.O_WRONLY\|os.O_EXCL)
467		except OSError:
	538	self.lock = lockfile.LockFile(path)
	539	except lockfile.LockError:
468	540	time.sleep(0.1)
469	541	else:
470		os.close(lockfd)
471	542	break
472	543	self.locked = True
473
	544	if self.debug:
	545	cherrypy.log('Lock acquired.', 'TOOLS.SESSIONS')
	546
474	547	def release_lock(self, path=None):
475	548	"""Release the lock on the currently-loaded session data."""
476		if path is None:
477		path = self._get_file_path()
478		os.unlink(path + self.LOCK_SUFFIX)
	549	self.lock.release()
	550	self.lock.remove()
479	551	self.locked = False
480
	552
481	553	def clean_up(self):
482	554	"""Clean up expired sessions."""
483	555	now = self.now()
484	556	# Iterate over all session files in self.storage_path
485	557	for fname in os.listdir(self.storage_path):
486	558	if (fname.startswith(self.SESSION_PREFIX)
487		and not fname.endswith(self.LOCK_SUFFIX)):
	559	and not fname.endswith(self.LOCK_SUFFIX)):
488	560	# We have a session file: lock and load it and check
489	561	# if it's expired. If it fails, nevermind.
490	562	path = os.path.join(self.storage_path, fname)
491	563	self.acquire_lock(path)
	564	if self.debug:
	565	# This is a bit of a hack, since we're calling clean_up
	566	# on the first instance rather than the entire class,
	567	# so depending on whether you have "debug" set on the
	568	# path of the first session called, this may not run.
	569	cherrypy.log('Cleanup lock acquired.', 'TOOLS.SESSIONS')
	570
492	571	try:
493	572	contents = self._load(path)
494	573	# _load returns None on IOError

499	578	os.unlink(path)
500	579	finally:
501	580	self.release_lock(path)
502
	581
503	582	def __len__(self):
504	583	"""Return the number of active sessions."""
505	584	return len([fname for fname in os.listdir(self.storage_path)

508	587
509	588
510	589	class PostgresqlSession(Session):
	590
511	591	""" Implementation of the PostgreSQL backend for sessions. It assumes
512	592	a table like this::
513	593

516	596	data text,
517	597	expiration_time timestamp
518	598	)
519
	599
520	600	You must provide your own get_db function.
521	601	"""
522
	602
523	603	pickle_protocol = pickle.HIGHEST_PROTOCOL
524
	604
525	605	def __init__(self, id=None, **kwargs):
526	606	Session.__init__(self, id, **kwargs)
527	607	self.cursor = self.db.cursor()
528
	608
529	609	def setup(cls, **kwargs):
530	610	"""Set up the storage system for Postgres-based sessions.
531
	611
532	612	This should only be called once per process; this will be done
533	613	automatically when using sessions.init (as the built-in Tool does).
534	614	"""
535	615	for k, v in kwargs.items():
536	616	setattr(cls, k, v)
537
	617
538	618	self.db = self.get_db()
539	619	setup = classmethod(setup)
540
	620
541	621	def __del__(self):
542	622	if self.cursor:
543	623	self.cursor.close()
544	624	self.db.commit()
545
	625
546	626	def _exists(self):
547	627	# Select session data from table
548	628	self.cursor.execute('select data, expiration_time from session '
549	629	'where id=%s', (self.id,))
550	630	rows = self.cursor.fetchall()
551	631	return bool(rows)
552
	632
553	633	def _load(self):
554	634	# Select session data from table
555	635	self.cursor.execute('select data, expiration_time from session '

557	637	rows = self.cursor.fetchall()
558	638	if not rows:
559	639	return None
560
	640
561	641	pickled_data, expiration_time = rows[0]
562	642	data = pickle.loads(pickled_data)
563	643	return data, expiration_time
564
	644
565	645	def _save(self, expiration_time):
566	646	pickled_data = pickle.dumps(self._data, self.pickle_protocol)
567	647	self.cursor.execute('update session set data = %s, '
568	648	'expiration_time = %s where id = %s',
569	649	(pickled_data, expiration_time, self.id))
570
	650
571	651	def _delete(self):
572	652	self.cursor.execute('delete from session where id=%s', (self.id,))
573
	653
574	654	def acquire_lock(self):
575	655	"""Acquire an exclusive lock on the currently-loaded session data."""
576	656	# We use the "for update" clause to lock the row
577	657	self.locked = True
578	658	self.cursor.execute('select id from session where id=%s for update',
579	659	(self.id,))
580
	660	if self.debug:
	661	cherrypy.log('Lock acquired.', 'TOOLS.SESSIONS')
	662
581	663	def release_lock(self):
582	664	"""Release the lock on the currently-loaded session data."""
583	665	# We just close the cursor and that will remove the lock
584	666	# introduced by the "for update" clause
585	667	self.cursor.close()
586	668	self.locked = False
587
	669
588	670	def clean_up(self):
589	671	"""Clean up expired sessions."""
590	672	self.cursor.execute('delete from session where expiration_time < %s',

592	674
593	675
594	676	class MemcachedSession(Session):
595
	677
596	678	# The most popular memcached client for Python isn't thread-safe.
597	679	# Wrap all .get and .set operations in a single lock.
598	680	mc_lock = threading.RLock()
599
	681
600	682	# This is a seperate set of locks per session id.
601	683	locks = {}
602
	684
603	685	servers = ['127.0.0.1:11211']
604
	686
605	687	def setup(cls, **kwargs):
606	688	"""Set up the storage system for memcached-based sessions.
607
	689
608	690	This should only be called once per process; this will be done
609	691	automatically when using sessions.init (as the built-in Tool does).
610	692	"""
611	693	for k, v in kwargs.items():
612	694	setattr(cls, k, v)
613
	695
614	696	import memcache
615	697	cls.cache = memcache.Client(cls.servers)
616	698	setup = classmethod(setup)
617
	699
618	700	def _get_id(self):
619	701	return self._id
	702
620	703	def _set_id(self, value):
621	704	# This encode() call is where we differ from the superclass.
622	705	# Memcache keys MUST be byte strings, not unicode.

627	710	for o in self.id_observers:
628	711	o(value)
629	712	id = property(_get_id, _set_id, doc="The current session ID.")
630
	713
631	714	def _exists(self):
632	715	self.mc_lock.acquire()
633	716	try:
634	717	return bool(self.cache.get(self.id))
635	718	finally:
636	719	self.mc_lock.release()
637
	720
638	721	def _load(self):
639	722	self.mc_lock.acquire()
640	723	try:
641	724	return self.cache.get(self.id)
642	725	finally:
643	726	self.mc_lock.release()
644
	727
645	728	def _save(self, expiration_time):
646	729	# Send the expiration time as "Unix time" (seconds since 1/1/1970)
647	730	td = int(time.mktime(expiration_time.timetuple()))
648	731	self.mc_lock.acquire()
649	732	try:
650	733	if not self.cache.set(self.id, (self._data, expiration_time), td):
651		raise AssertionError("Session data for id %r not set." % self.id)
	734	raise AssertionError(
	735	"Session data for id %r not set." % self.id)
652	736	finally:
653	737	self.mc_lock.release()
654
	738
655	739	def _delete(self):
656	740	self.cache.delete(self.id)
657
	741
658	742	def acquire_lock(self):
659	743	"""Acquire an exclusive lock on the currently-loaded session data."""
660	744	self.locked = True
661	745	self.locks.setdefault(self.id, threading.RLock()).acquire()
662
	746	if self.debug:
	747	cherrypy.log('Lock acquired.', 'TOOLS.SESSIONS')
	748
663	749	def release_lock(self):
664	750	"""Release the lock on the currently-loaded session data."""
665	751	self.locks[self.id].release()
666	752	self.locked = False
667
	753
668	754	def __len__(self):
669	755	"""Return the number of active sessions."""
670	756	raise NotImplementedError

674	760
675	761	def save():
676	762	"""Save any changed session data."""
677
	763
678	764	if not hasattr(cherrypy.serving, "session"):
679	765	return
680	766	request = cherrypy.serving.request
681	767	response = cherrypy.serving.response
682
	768
683	769	# Guard against running twice
684	770	if hasattr(request, "_sessionsaved"):
685	771	return
686	772	request._sessionsaved = True
687
	773
688	774	if response.stream:
689	775	# If the body is being streamed, we have to save the data
690	776	# after the response has been written out

692	778	else:
693	779	# If the body is not being streamed, we save the data now
694	780	# (so we can release the lock).
695		if isinstance(response.body, types.GeneratorType):
	781	if is_iterator(response.body):
696	782	response.collapse_body()
697	783	cherrypy.session.save()
698	784	save.failsafe = True
	785
699	786
700	787	def close():
701	788	"""Close the session object for this request."""

703	790	if getattr(sess, "locked", False):
704	791	# If the session is still locked we release the lock
705	792	sess.release_lock()
	793	if sess.debug:
	794	cherrypy.log('Lock released on close.', 'TOOLS.SESSIONS')
706	795	close.failsafe = True
707	796	close.priority = 90
708	797

711	800	timeout=60, domain=None, secure=False, clean_freq=5,
712	801	persistent=True, httponly=False, debug=False, **kwargs):
713	802	"""Initialize session object (using cookies).
714
	803
715	804	storage_type
716	805	One of 'ram', 'file', 'postgresql', 'memcached'. This will be
717	806	used to look up the corresponding class in cherrypy.lib.sessions
718	807	globals. For example, 'file' will use the FileSession class.
719
	808
720	809	path
721	810	The 'path' value to stick in the response cookie metadata.
722
	811
723	812	path_header
724	813	If 'path' is None (the default), then the response
725	814	cookie 'path' will be pulled from request.headers[path_header].
726
	815
727	816	name
728	817	The name of the cookie.
729
	818
730	819	timeout
731	820	The expiration timeout (in minutes) for the stored session data.
732	821	If 'persistent' is True (the default), this is also the timeout
733	822	for the cookie.
734
	823
735	824	domain
736	825	The cookie domain.
737
	826
738	827	secure
739	828	If False (the default) the cookie 'secure' value will not
740	829	be set. If True, the cookie 'secure' value will be set (to 1).
741
	830
742	831	clean_freq (minutes)
743	832	The poll rate for expired session cleanup.
744
	833
745	834	persistent
746	835	If True (the default), the 'timeout' argument will be used
747	836	to expire the cookie. If False, the cookie will not have an expiry,
748	837	and the cookie will be a "session cookie" which expires when the
749	838	browser is closed.
750
	839
751	840	httponly
752	841	If False (the default) the cookie 'httponly' value will not be set.
753	842	If True, the cookie 'httponly' value will be set (to 1).
754
	843
755	844	Any additional kwargs will be bound to the new Session instance,
756	845	and may be specific to the storage type. See the subclass of Session
757	846	you're using for more information.
758	847	"""
759
	848
760	849	request = cherrypy.serving.request
761
	850
762	851	# Guard against running twice
763	852	if hasattr(request, "_session_init_flag"):
764	853	return
765	854	request._session_init_flag = True
766
	855
767	856	# Check if request came with a session ID
768	857	id = None
769	858	if name in request.cookie:

771	860	if debug:
772	861	cherrypy.log('ID obtained from request.cookie: %r' % id,
773	862	'TOOLS.SESSIONS')
774
	863
775	864	# Find the storage class and call setup (first time only).
776	865	storage_class = storage_type.title() + 'Session'
777	866	storage_class = globals()[storage_class]
778	867	if not hasattr(cherrypy, "session"):
779	868	if hasattr(storage_class, "setup"):
780	869	storage_class.setup(**kwargs)
781
	870
782	871	# Create and attach a new Session instance to cherrypy.serving.
783	872	# It will possess a reference to (and lock, and lazily load)
784	873	# the requested session data.

786	875	kwargs['clean_freq'] = clean_freq
787	876	cherrypy.serving.session = sess = storage_class(id, **kwargs)
788	877	sess.debug = debug
	878
789	879	def update_cookie(id):
790	880	"""Update the cookie every time the session id changes."""
791	881	cherrypy.serving.response.cookie[name] = id
792	882	sess.id_observers.append(update_cookie)
793
	883
794	884	# Create cherrypy.session which will proxy to cherrypy.serving.session
795	885	if not hasattr(cherrypy, "session"):
796	886	cherrypy.session = cherrypy._ThreadLocalProxy('session')
797
	887
798	888	if persistent:
799	889	cookie_timeout = timeout
800	890	else:

809	899	def set_response_cookie(path=None, path_header=None, name='session_id',
810	900	timeout=60, domain=None, secure=False, httponly=False):
811	901	"""Set a response cookie for the client.
812
	902
813	903	path
814	904	the 'path' value to stick in the response cookie metadata.
815	905

840	930	# Set response cookie
841	931	cookie = cherrypy.serving.response.cookie
842	932	cookie[name] = cherrypy.serving.session.id
843		cookie[name]['path'] = (path or cherrypy.serving.request.headers.get(path_header)
844		or '/')
845
	933	cookie[name]['path'] = (
	934	path or
	935	cherrypy.serving.request.headers.get(path_header) or
	936	'/'
	937	)
	938
846	939	# We'd like to use the "max-age" param as indicated in
847	940	# http://www.faqs.org/rfcs/rfc2109.html but IE doesn't
848	941	# save it to disk and the session is lost if people close

860	953	raise ValueError("The httponly cookie token is not supported.")
861	954	cookie[name]['httponly'] = 1
862	955
	956
863	957	def expire():
864	958	"""Expire the current session cookie."""
865		name = cherrypy.serving.request.config.get('tools.sessions.name', 'session_id')
	959	name = cherrypy.serving.request.config.get(
	960	'tools.sessions.name', 'session_id')
866	961	one_year = 60 * 60 * 24 * 365
867	962	e = time.time() - one_year
868	963	cherrypy.serving.response.cookie[name]['expires'] = httputil.HTTPDate(e)
869
870

+72

-57

cherrypy/lib/static.py less more

4	4	import logging
5	5	import mimetypes
6	6	mimetypes.init()
7		mimetypes.types_map['.dwg']='image/x-dwg'
8		mimetypes.types_map['.ico']='image/x-icon'
9		mimetypes.types_map['.bz2']='application/x-bzip2'
10		mimetypes.types_map['.gz']='application/x-gzip'
	7	mimetypes.types_map['.dwg'] = 'image/x-dwg'
	8	mimetypes.types_map['.ico'] = 'image/x-icon'
	9	mimetypes.types_map['.bz2'] = 'application/x-bzip2'
	10	mimetypes.types_map['.gz'] = 'application/x-gzip'
11	11
12	12	import os
13	13	import re

19	19	from cherrypy.lib import cptools, httputil, file_generator_limited
20	20
21	21
22		def serve_file(path, content_type=None, disposition=None, name=None, debug=False):
	22	def serve_file(path, content_type=None, disposition=None, name=None,
	23	debug=False):
23	24	"""Set status, headers, and body in order to serve the given path.
24
	25
25	26	The Content-Type header will be set to the content_type arg, if provided.
26	27	If not provided, the Content-Type will be guessed by the file extension
27	28	of the 'path' argument.
28
	29
29	30	If disposition is not None, the Content-Disposition header will be set
30	31	to "<disposition>; filename=<name>". If name is None, it will be set
31	32	to the basename of path. If disposition is None, no Content-Disposition
32	33	header will be written.
33	34	"""
34
	35
35	36	response = cherrypy.serving.response
36
	37
37	38	# If path is relative, users should fix it by making path absolute.
38	39	# That is, CherryPy should not guess where the application root is.
39	40	# It certainly should not use cwd (since CP may be invoked from a

44	45	if debug:
45	46	cherrypy.log(msg, 'TOOLS.STATICFILE')
46	47	raise ValueError(msg)
47
	48
48	49	try:
49	50	st = os.stat(path)
50	51	except OSError:
51	52	if debug:
52	53	cherrypy.log('os.stat(%r) failed' % path, 'TOOLS.STATIC')
53	54	raise cherrypy.NotFound()
54
	55
55	56	# Check if path is a directory.
56	57	if stat.S_ISDIR(st.st_mode):
57	58	# Let the caller deal with it as they like.
58	59	if debug:
59	60	cherrypy.log('%r is a directory' % path, 'TOOLS.STATIC')
60	61	raise cherrypy.NotFound()
61
	62
62	63	# Set the Last-Modified response header, so that
63	64	# modified-since validation code can work.
64	65	response.headers['Last-Modified'] = httputil.HTTPDate(st.st_mtime)
65	66	cptools.validate_since()
66
	67
67	68	if content_type is None:
68	69	# Set content-type based on filename extension
69	70	ext = ""

75	76	response.headers['Content-Type'] = content_type
76	77	if debug:
77	78	cherrypy.log('Content-Type: %r' % content_type, 'TOOLS.STATIC')
78
	79
79	80	cd = None
80	81	if disposition is not None:
81	82	if name is None:

84	85	response.headers["Content-Disposition"] = cd
85	86	if debug:
86	87	cherrypy.log('Content-Disposition: %r' % cd, 'TOOLS.STATIC')
87
	88
88	89	# Set Content-Length and use an iterable (file object)
89	90	# this way CP won't load the whole file in memory
90	91	content_length = st.st_size
91	92	fileobj = open(path, 'rb')
92	93	return _serve_fileobj(fileobj, content_type, content_length, debug=debug)
93	94
	95
94	96	def serve_fileobj(fileobj, content_type=None, disposition=None, name=None,
95	97	debug=False):
96	98	"""Set status, headers, and body in order to serve the given file object.
97
	99
98	100	The Content-Type header will be set to the content_type arg, if provided.
99
	101
100	102	If disposition is not None, the Content-Disposition header will be set
101	103	to "<disposition>; filename=<name>". If name is None, 'filename' will
102	104	not be set. If disposition is None, no Content-Disposition header will

109	111	serve_fileobj(), expecting that the data would be served starting from that
110	112	position.
111	113	"""
112
	114
113	115	response = cherrypy.serving.response
114
	116
115	117	try:
116	118	st = os.fstat(fileobj.fileno())
117	119	except AttributeError:

126	128	response.headers['Last-Modified'] = httputil.HTTPDate(st.st_mtime)
127	129	cptools.validate_since()
128	130	content_length = st.st_size
129
	131
130	132	if content_type is not None:
131	133	response.headers['Content-Type'] = content_type
132	134	if debug:
133	135	cherrypy.log('Content-Type: %r' % content_type, 'TOOLS.STATIC')
134
	136
135	137	cd = None
136	138	if disposition is not None:
137	139	if name is None:

141	143	response.headers["Content-Disposition"] = cd
142	144	if debug:
143	145	cherrypy.log('Content-Disposition: %r' % cd, 'TOOLS.STATIC')
144
	146
145	147	return _serve_fileobj(fileobj, content_type, content_length, debug=debug)
	148
146	149
147	150	def _serve_fileobj(fileobj, content_type, content_length, debug=False):
148	151	"""Internal. Set response.body to the given file object, perhaps ranged."""
149	152	response = cherrypy.serving.response
150
	153
151	154	# HTTP/1.0 didn't have Range/Accept-Ranges headers, or the 206 code
152	155	request = cherrypy.serving.request
153	156	if request.protocol >= (1, 1):

155	158	r = httputil.get_ranges(request.headers.get('Range'), content_length)
156	159	if r == []:
157	160	response.headers['Content-Range'] = "bytes */%s" % content_length
158		message = "Invalid Range (first-byte-pos greater than Content-Length)"
	161	message = ("Invalid Range (first-byte-pos greater than "
	162	"Content-Length)")
159	163	if debug:
160	164	cherrypy.log(message, 'TOOLS.STATIC')
161	165	raise cherrypy.HTTPError(416, message)
162
	166
163	167	if r:
164	168	if len(r) == 1:
165	169	# Return a single-part response.

168	172	stop = content_length
169	173	r_len = stop - start
170	174	if debug:
171		cherrypy.log('Single part; start: %r, stop: %r' % (start, stop),
172		'TOOLS.STATIC')
	175	cherrypy.log(
	176	'Single part; start: %r, stop: %r' % (start, stop),
	177	'TOOLS.STATIC')
173	178	response.status = "206 Partial Content"
174	179	response.headers['Content-Range'] = (
175	180	"bytes %s-%s/%s" % (start, stop - 1, content_length))

181	186	response.status = "206 Partial Content"
182	187	try:
183	188	# Python 3
184		from email.generator import _make_boundary as choose_boundary
	189	from email.generator import _make_boundary as make_boundary
185	190	except ImportError:
186	191	# Python 2
187		from mimetools import choose_boundary
188		boundary = choose_boundary()
	192	from mimetools import choose_boundary as make_boundary
	193	boundary = make_boundary()
189	194	ct = "multipart/byteranges; boundary=%s" % boundary
190	195	response.headers['Content-Type'] = ct
191	196	if "Content-Length" in response.headers:
192	197	# Delete Content-Length header so finalize() recalcs it.
193	198	del response.headers["Content-Length"]
194
	199
195	200	def file_ranges():
196	201	# Apache compatibility:
197	202	yield ntob("\r\n")
198
	203
199	204	for start, stop in r:
200	205	if debug:
201		cherrypy.log('Multipart; start: %r, stop: %r' % (start, stop),
202		'TOOLS.STATIC')
	206	cherrypy.log(
	207	'Multipart; start: %r, stop: %r' % (
	208	start, stop),
	209	'TOOLS.STATIC')
203	210	yield ntob("--" + boundary, 'ascii')
204		yield ntob("\r\nContent-type: %s" % content_type, 'ascii')
205		yield ntob("\r\nContent-range: bytes %s-%s/%s\r\n\r\n"
206		% (start, stop - 1, content_length), 'ascii')
	211	yield ntob("\r\nContent-type: %s" % content_type,
	212	'ascii')
	213	yield ntob(
	214	"\r\nContent-range: bytes %s-%s/%s\r\n\r\n" % (
	215	start, stop - 1, content_length),
	216	'ascii')
207	217	fileobj.seek(start)
208		for chunk in file_generator_limited(fileobj, stop-start):
	218	gen = file_generator_limited(fileobj, stop - start)
	219	for chunk in gen:
209	220	yield chunk
210	221	yield ntob("\r\n")
211	222	# Final boundary
212	223	yield ntob("--" + boundary + "--", 'ascii')
213
	224
214	225	# Apache compatibility:
215	226	yield ntob("\r\n")
216	227	response.body = file_ranges()

218	229	else:
219	230	if debug:
220	231	cherrypy.log('No byteranges requested', 'TOOLS.STATIC')
221
	232
222	233	# Set Content-Length and use an iterable (file object)
223	234	# this way CP won't load the whole file in memory
224	235	response.headers['Content-Length'] = content_length
225	236	response.body = fileobj
226	237	return response.body
	238
227	239
228	240	def serve_download(path, name=None):
229	241	"""Serve 'path' as an application/x-download attachment."""

251	263	cherrypy.log('NotFound', 'TOOLS.STATICFILE')
252	264	return False
253	265
	266
254	267	def staticdir(section, dir, root="", match="", content_types=None, index="",
255	268	debug=False):
256	269	"""Serve a static resource from the given (root +) dir.
257
	270
258	271	match
259	272	If given, request.path_info will be searched for the given
260	273	regular expression before attempting to serve static content.
261
	274
262	275	content_types
263	276	If given, it should be a Python dictionary of
264	277	{file-extension: content-type} pairs, where 'file-extension' is
265	278	a string (e.g. "gif") and 'content-type' is the value to write
266	279	out in the Content-Type response header (e.g. "image/gif").
267
	280
268	281	index
269	282	If provided, it should be the (relative) name of a file to
270	283	serve for directory requests. For example, if the dir argument is

276	289	if debug:
277	290	cherrypy.log('request.method not GET or HEAD', 'TOOLS.STATICDIR')
278	291	return False
279
	292
280	293	if match and not re.search(match, request.path_info):
281	294	if debug:
282	295	cherrypy.log('request.path_info %r does not match pattern %r' %
283	296	(request.path_info, match), 'TOOLS.STATICDIR')
284	297	return False
285
	298
286	299	# Allow the use of '~' to refer to a user's home directory.
287	300	dir = os.path.expanduser(dir)
288	301

294	307	cherrypy.log(msg, 'TOOLS.STATICDIR')
295	308	raise ValueError(msg)
296	309	dir = os.path.join(root, dir)
297
	310
298	311	# Determine where we are in the object tree relative to 'section'
299	312	# (where the static tool was defined).
300	313	if section == 'global':

302	315	section = section.rstrip(r"\/")
303	316	branch = request.path_info[len(section) + 1:]
304	317	branch = unquote(branch.lstrip(r"\/"))
305
	318
306	319	# If branch is "", filename will end in a slash
307	320	filename = os.path.join(dir, branch)
308	321	if debug:
309	322	cherrypy.log('Checking file %r to fulfill %r' %
310	323	(filename, request.path_info), 'TOOLS.STATICDIR')
311
	324
312	325	# There's a chance that the branch pulled from the URL might
313	326	# have ".." or similar uplevel attacks in it. Check that the final
314	327	# filename is a child of dir.
315	328	if not os.path.normpath(filename).startswith(os.path.normpath(dir)):
316		raise cherrypy.HTTPError(403) # Forbidden
317
	329	raise cherrypy.HTTPError(403) # Forbidden
	330
318	331	handled = _attempt(filename, content_types)
319	332	if not handled:
320	333	# Check for an index file if a folder was requested.

324	337	request.is_index = filename[-1] in (r"\/")
325	338	return handled
326	339
	340
327	341	def staticfile(filename, root=None, match="", content_types=None, debug=False):
328	342	"""Serve a static resource from the given (root +) filename.
329
	343
330	344	match
331	345	If given, request.path_info will be searched for the given
332	346	regular expression before attempting to serve static content.
333
	347
334	348	content_types
335	349	If given, it should be a Python dictionary of
336	350	{file-extension: content-type} pairs, where 'file-extension' is
337	351	a string (e.g. "gif") and 'content-type' is the value to write
338	352	out in the Content-Type response header (e.g. "image/gif").
339
	353
340	354	"""
341	355	request = cherrypy.serving.request
342	356	if request.method not in ('GET', 'HEAD'):
343	357	if debug:
344	358	cherrypy.log('request.method not GET or HEAD', 'TOOLS.STATICFILE')
345	359	return False
346
	360
347	361	if match and not re.search(match, request.path_info):
348	362	if debug:
349	363	cherrypy.log('request.path_info %r does not match pattern %r' %
350	364	(request.path_info, match), 'TOOLS.STATICFILE')
351	365	return False
352
	366
353	367	# If filename is relative, make absolute using "root".
354	368	if not os.path.isabs(filename):
355	369	if not root:
356		msg = "Static tool requires an absolute filename (got '%s')." % filename
	370	msg = "Static tool requires an absolute filename (got '%s')." % (
	371	filename,)
357	372	if debug:
358	373	cherrypy.log(msg, 'TOOLS.STATICFILE')
359	374	raise ValueError(msg)
360	375	filename = os.path.join(root, filename)
361
	376
362	377	return _attempt(filename, content_types, debug=debug)

-1

cherrypy/lib/xmlrpcutil.py less more

1	1
2	2	import cherrypy
3	3	from cherrypy._cpcompat import ntob
	4
4	5
5	6	def get_xmlrpclib():
6	7	try:

8	9	except ImportError:
9	10	import xmlrpclib as x
10	11	return x
	12
11	13
12	14	def process_body():
13	15	"""Return (params, method) from request body."""

47	49	encoding=encoding,
48	50	allow_none=allow_none))
49	51
	52
50	53	def on_error(args, *kwargs):
51	54	body = str(sys.exc_info()[1])
52	55	xmlrpclib = get_xmlrpclib()
53	56	_set_response(xmlrpclib.dumps(xmlrpclib.Fault(1, body)))
54

+162

-128

cherrypy/process/plugins.py less more

6	6	import time
7	7	import threading
8	8
9		from cherrypy._cpcompat import basestring, get_daemon, get_thread_ident, ntob, set
	9	from cherrypy._cpcompat import basestring, get_daemon, get_thread_ident
	10	from cherrypy._cpcompat import ntob, set, Timer, SetDaemonProperty
10	11
11	12	# _module__file__base is used by Autoreload to make
12	13	# absolute any filenames retrieved from sys.modules which are not

18	19	# changes the current directory by executing os.chdir(), then the next time
19	20	# Autoreload runs, it will not be able to find any filenames which are
20	21	# not absolute paths, because the current directory is not the same as when the
21		# module was first imported. Autoreload will then wrongly conclude the file has
22		# "changed", and initiate the shutdown/re-exec sequence.
	22	# module was first imported. Autoreload will then wrongly conclude the file
	23	# has "changed", and initiate the shutdown/re-exec sequence.
23	24	# See ticket #917.
24	25	# For this workaround to have a decent probability of success, this module
25	26	# needs to be imported as early as possible, before the app has much chance

28	29
29	30
30	31	class SimplePlugin(object):
	32
31	33	"""Plugin base class which auto-subscribes methods for known channels."""
32
	34
33	35	bus = None
34		"""A :class:`Bus <cherrypy.process.wspbus.Bus>`, usually cherrypy.engine."""
35
	36	"""A :class:`Bus <cherrypy.process.wspbus.Bus>`, usually cherrypy.engine.
	37	"""
	38
36	39	def __init__(self, bus):
37	40	self.bus = bus
38
	41
39	42	def subscribe(self):
40	43	"""Register this object as a (multi-channel) listener on the bus."""
41	44	for channel in self.bus.listeners:

43	46	method = getattr(self, channel, None)
44	47	if method is not None:
45	48	self.bus.subscribe(channel, method)
46
	49
47	50	def unsubscribe(self):
48	51	"""Unregister this object as a listener on the bus."""
49	52	for channel in self.bus.listeners:

53	56	self.bus.unsubscribe(channel, method)
54	57
55	58
56
57	59	class SignalHandler(object):
	60
58	61	"""Register bus channels (and listeners) for system signals.
59
	62
60	63	You can modify what signals your application listens for, and what it does
61	64	when it receives signals, by modifying :attr:`SignalHandler.handlers`,
62	65	a dict of {signal name: callback} pairs. The default set is::
63
	66
64	67	handlers = {'SIGTERM': self.bus.exit,
65	68	'SIGHUP': self.handle_SIGHUP,
66	69	'SIGUSR1': self.bus.graceful,
67	70	}
68
	71
69	72	The :func:`SignalHandler.handle_SIGHUP`` method calls
70	73	:func:`bus.restart()<cherrypy.process.wspbus.Bus.restart>`
71	74	if the process is daemonized, but
72	75	:func:`bus.exit()<cherrypy.process.wspbus.Bus.exit>`
73	76	if the process is attached to a TTY. This is because Unix window
74	77	managers tend to send SIGHUP to terminal windows when the user closes them.
75
76		Feel free to add signals which are not available on every platform. The
77		:class:`SignalHandler` will ignore errors raised from attempting to register
78		handlers for unknown signals.
79		"""
80
	78
	79	Feel free to add signals which are not available on every platform.
	80	The :class:`SignalHandler` will ignore errors raised from attempting
	81	to register handlers for unknown signals.
	82	"""
	83
81	84	handlers = {}
82	85	"""A map from signal names (e.g. 'SIGTERM') to handlers (e.g. bus.exit)."""
83
	86
84	87	signals = {}
85	88	"""A map from signal numbers to names."""
86
	89
87	90	for k, v in vars(_signal).items():
88	91	if k.startswith('SIG') and not k.startswith('SIG_'):
89	92	signals[v] = k
90	93	del k, v
91
	94
92	95	def __init__(self, bus):
93	96	self.bus = bus
94	97	# Set default handlers

105	108	self.handlers['SIGINT'] = self._jython_SIGINT_handler
106	109
107	110	self._previous_handlers = {}
108
	111
109	112	def _jython_SIGINT_handler(self, signum=None, frame=None):
110	113	# See http://bugs.jython.org/issue1313
111	114	self.bus.log('Keyboard Interrupt: shutting down bus')
112	115	self.bus.exit()
113
	116
114	117	def subscribe(self):
115	118	"""Subscribe self.handlers to signals."""
116	119	for sig, func in self.handlers.items():

118	121	self.set_handler(sig, func)
119	122	except ValueError:
120	123	pass
121
	124
122	125	def unsubscribe(self):
123	126	"""Unsubscribe self.handlers from signals."""
124	127	for signum, handler in self._previous_handlers.items():
125	128	signame = self.signals[signum]
126
	129
127	130	if handler is None:
128	131	self.bus.log("Restoring %s handler to SIG_DFL." % signame)
129	132	handler = _signal.SIG_DFL
130	133	else:
131	134	self.bus.log("Restoring %s handler %r." % (signame, handler))
132
	135
133	136	try:
134	137	our_handler = _signal.signal(signum, handler)
135	138	if our_handler is None:

139	142	except ValueError:
140	143	self.bus.log("Unable to restore %s handler %r." %
141	144	(signame, handler), level=40, traceback=True)
142
	145
143	146	def set_handler(self, signal, listener=None):
144	147	"""Subscribe a handler for the given signal (number or name).
145
	148
146	149	If the optional 'listener' argument is provided, it will be
147	150	subscribed as a listener for the given signal's channel.
148
	151
149	152	If the given signal name or number is not available on the current
150	153	platform, ValueError is raised.
151	154	"""

160	163	except KeyError:
161	164	raise ValueError("No such signal: %r" % signal)
162	165	signum = signal
163
	166
164	167	prev = _signal.signal(signum, self._handle_signal)
165	168	self._previous_handlers[signum] = prev
166
	169
167	170	if listener is not None:
168	171	self.bus.log("Listening for %s." % signame)
169	172	self.bus.subscribe(signame, listener)
170
	173
171	174	def _handle_signal(self, signum=None, frame=None):
172	175	"""Python signal handler (self.set_handler subscribes it for you)."""
173	176	signame = self.signals[signum]
174	177	self.bus.log("Caught signal %s." % signame)
175	178	self.bus.publish(signame)
176
	179
177	180	def handle_SIGHUP(self):
178	181	"""Restart if daemonized, else exit."""
179	182	if os.isatty(sys.stdin.fileno()):

186	189
187	190
188	191	try:
189		import pwd, grp
	192	import pwd
	193	import grp
190	194	except ImportError:
191	195	pwd, grp = None, None
192	196
193	197
194	198	class DropPrivileges(SimplePlugin):
	199
195	200	"""Drop privileges. uid/gid arguments not available on Windows.
196
197		Special thanks to Gavin Baker: http://antonym.org/node/100.
198		"""
199
	201
	202	Special thanks to `Gavin Baker <http://antonym.org/2005/12/dropping-privileges-in-python.html>`_
	203	"""
	204
200	205	def __init__(self, bus, umask=None, uid=None, gid=None):
201	206	SimplePlugin.__init__(self, bus)
202	207	self.finalized = False
203	208	self.uid = uid
204	209	self.gid = gid
205	210	self.umask = umask
206
	211
207	212	def _get_uid(self):
208	213	return self._uid
	214
209	215	def _set_uid(self, val):
210	216	if val is not None:
211	217	if pwd is None:

216	222	val = pwd.getpwnam(val)[2]
217	223	self._uid = val
218	224	uid = property(_get_uid, _set_uid,
219		doc="The uid under which to run. Availability: Unix.")
220
	225	doc="The uid under which to run. Availability: Unix.")
	226
221	227	def _get_gid(self):
222	228	return self._gid
	229
223	230	def _set_gid(self, val):
224	231	if val is not None:
225	232	if grp is None:

230	237	val = grp.getgrnam(val)[2]
231	238	self._gid = val
232	239	gid = property(_get_gid, _set_gid,
233		doc="The gid under which to run. Availability: Unix.")
234
	240	doc="The gid under which to run. Availability: Unix.")
	241
235	242	def _get_umask(self):
236	243	return self._umask
	244
237	245	def _set_umask(self, val):
238	246	if val is not None:
239	247	try:

243	251	level=30)
244	252	val = None
245	253	self._umask = val
246		umask = property(_get_umask, _set_umask,
247		doc="""The default permission mode for newly created files and directories.
248
	254	umask = property(
	255	_get_umask,
	256	_set_umask,
	257	doc="""The default permission mode for newly created files and
	258	directories.
	259
249	260	Usually expressed in octal format, for example, ``0644``.
250	261	Availability: Unix, Windows.
251	262	""")
252
	263
253	264	def start(self):
254	265	# uid/gid
255	266	def current_ids():

260	271	if grp:
261	272	group = grp.getgrgid(os.getgid())[0]
262	273	return name, group
263
	274
264	275	if self.finalized:
265	276	if not (self.uid is None and self.gid is None):
266	277	self.bus.log('Already running as uid: %r gid: %r' %

277	288	if self.uid is not None:
278	289	os.setuid(self.uid)
279	290	self.bus.log('Running as uid: %r gid: %r' % current_ids())
280
	291
281	292	# umask
282	293	if self.finalized:
283	294	if self.umask is not None:

289	300	old_umask = os.umask(self.umask)
290	301	self.bus.log('umask old: %03o, new: %03o' %
291	302	(old_umask, self.umask))
292
	303
293	304	self.finalized = True
294	305	# This is slightly higher than the priority for server.start
295	306	# in order to facilitate the most common use: starting on a low

298	309
299	310
300	311	class Daemonizer(SimplePlugin):
	312
301	313	"""Daemonize the running script.
302
	314
303	315	Use this with a Web Site Process Bus via::
304
	316
305	317	Daemonizer(bus).subscribe()
306
	318
307	319	When this component finishes, the process is completely decoupled from
308	320	the parent environment. Please note that when this component is used,
309	321	the return code from the parent process will still be 0 if a startup

313	325	of whether the process fully started. In fact, that return code only
314	326	indicates if the process succesfully finished the first fork.
315	327	"""
316
	328
317	329	def __init__(self, bus, stdin='/dev/null', stdout='/dev/null',
318	330	stderr='/dev/null'):
319	331	SimplePlugin.__init__(self, bus)

321	333	self.stdout = stdout
322	334	self.stderr = stderr
323	335	self.finalized = False
324
	336
325	337	def start(self):
326	338	if self.finalized:
327	339	self.bus.log('Already deamonized.')
328
	340
329	341	# forking has issues with threads:
330	342	# http://www.opengroup.org/onlinepubs/000095399/functions/fork.html
331	343	# "The general problem with making fork() work in a multi-threaded

335	347	self.bus.log('There are %r active threads. '
336	348	'Daemonizing now may cause strange failures.' %
337	349	threading.enumerate(), level=30)
338
	350
339	351	# See http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
340	352	# (or http://www.faqs.org/faqs/unix-faq/programmer/faq/ section 1.7)
341	353	# and http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66012
342
	354
343	355	# Finish up with the current stdout/stderr
344	356	sys.stdout.flush()
345	357	sys.stderr.flush()
346
	358
347	359	# Do first fork.
348	360	try:
349	361	pid = os.fork()

359	371	exc = sys.exc_info()[1]
360	372	sys.exit("%s: fork #1 failed: (%d) %s\n"
361	373	% (sys.argv[0], exc.errno, exc.strerror))
362
	374
363	375	os.setsid()
364
	376
365	377	# Do second fork
366	378	try:
367	379	pid = os.fork()
368	380	if pid > 0:
369	381	self.bus.log('Forking twice.')
370		os._exit(0) # Exit second parent
	382	os._exit(0) # Exit second parent
371	383	except OSError:
372	384	exc = sys.exc_info()[1]
373	385	sys.exit("%s: fork #2 failed: (%d) %s\n"
374	386	% (sys.argv[0], exc.errno, exc.strerror))
375
	387
376	388	os.chdir("/")
377	389	os.umask(0)
378
	390
379	391	si = open(self.stdin, "r")
380	392	so = open(self.stdout, "a+")
381	393	se = open(self.stderr, "a+")

386	398	os.dup2(si.fileno(), sys.stdin.fileno())
387	399	os.dup2(so.fileno(), sys.stdout.fileno())
388	400	os.dup2(se.fileno(), sys.stderr.fileno())
389
	401
390	402	self.bus.log('Daemonized to PID: %s' % os.getpid())
391	403	self.finalized = True
392	404	start.priority = 65
393	405
394	406
395	407	class PIDFile(SimplePlugin):
	408
396	409	"""Maintain a PID file via a WSPBus."""
397
	410
398	411	def __init__(self, bus, pidfile):
399	412	SimplePlugin.__init__(self, bus)
400	413	self.pidfile = pidfile
401	414	self.finalized = False
402
	415
403	416	def start(self):
404	417	pid = os.getpid()
405	418	if self.finalized:
406	419	self.bus.log('PID %r already written to %r.' % (pid, self.pidfile))
407	420	else:
408		open(self.pidfile, "wb").write(ntob("%s" % pid, 'utf8'))
	421	open(self.pidfile, "wb").write(ntob("%s\n" % pid, 'utf8'))
409	422	self.bus.log('PID %r written to %r.' % (pid, self.pidfile))
410	423	self.finalized = True
411	424	start.priority = 70
412
	425
413	426	def exit(self):
414	427	try:
415	428	os.remove(self.pidfile)

420	433	pass
421	434
422	435
423		class PerpetualTimer(threading._Timer):
424		"""A responsive subclass of threading._Timer whose run() method repeats.
425
	436	class PerpetualTimer(Timer):
	437
	438	"""A responsive subclass of threading.Timer whose run() method repeats.
	439
426	440	Use this timer only when you really need a very interruptible timer;
427	441	this checks its 'finished' condition up to 20 times a second, which can
428		results in pretty high CPU usage
429		"""
430
	442	results in pretty high CPU usage
	443	"""
	444
	445	def __init__(self, args, *kwargs):
	446	"Override parent constructor to allow 'bus' to be provided."
	447	self.bus = kwargs.pop('bus', None)
	448	super(PerpetualTimer, self).__init__(args, *kwargs)
	449
431	450	def run(self):
432	451	while True:
433	452	self.finished.wait(self.interval)

436	455	try:
437	456	self.function(self.args, *self.kwargs)
438	457	except Exception:
439		self.bus.log("Error in perpetual timer thread function %r." %
440		self.function, level=40, traceback=True)
	458	if self.bus:
	459	self.bus.log(
	460	"Error in perpetual timer thread function %r." %
	461	self.function, level=40, traceback=True)
441	462	# Quit on first error to avoid massive logs.
442	463	raise
443	464
444	465
445		class BackgroundTask(threading.Thread):
	466	class BackgroundTask(SetDaemonProperty, threading.Thread):
	467
446	468	"""A subclass of threading.Thread whose run() method repeats.
447
	469
448	470	Use this class for most repeating tasks. It uses time.sleep() to wait
449	471	for each interval, which isn't very responsive; that is, even if you call
450	472	self.cancel(), you'll have to wait until the sleep() call finishes before
451	473	the thread stops. To compensate, it defaults to being daemonic, which means
452	474	it won't delay stopping the whole process.
453	475	"""
454
	476
455	477	def __init__(self, interval, function, args=[], kwargs={}, bus=None):
456	478	threading.Thread.__init__(self)
457	479	self.interval = interval

460	482	self.kwargs = kwargs
461	483	self.running = False
462	484	self.bus = bus
463
	485
	486	# default to daemonic
	487	self.daemon = True
	488
464	489	def cancel(self):
465	490	self.running = False
466
	491
467	492	def run(self):
468	493	self.running = True
469	494	while self.running:

478	503	% self.function, level=40, traceback=True)
479	504	# Quit on first error to avoid massive logs.
480	505	raise
481
482		def _set_daemon(self):
483		return True
484	506
485	507
486	508	class Monitor(SimplePlugin):
	509
487	510	"""WSPBus listener to periodically run a callback in its own thread."""
488
	511
489	512	callback = None
490	513	"""The function to call at intervals."""
491
	514
492	515	frequency = 60
493	516	"""The time in seconds between callback runs."""
494
	517
495	518	thread = None
496		"""A :class:`BackgroundTask<cherrypy.process.plugins.BackgroundTask>` thread."""
497
	519	"""A :class:`BackgroundTask<cherrypy.process.plugins.BackgroundTask>`
	520	thread.
	521	"""
	522
498	523	def __init__(self, bus, callback, frequency=60, name=None):
499	524	SimplePlugin.__init__(self, bus)
500	525	self.callback = callback
501	526	self.frequency = frequency
502	527	self.thread = None
503	528	self.name = name
504
	529
505	530	def start(self):
506	531	"""Start our callback in its own background thread."""
507	532	if self.frequency > 0:
508	533	threadname = self.name or self.__class__.__name__
509	534	if self.thread is None:
510	535	self.thread = BackgroundTask(self.frequency, self.callback,
511		bus = self.bus)
	536	bus=self.bus)
512	537	self.thread.setName(threadname)
513	538	self.thread.start()
514	539	self.bus.log("Started monitor thread %r." % threadname)
515	540	else:
516	541	self.bus.log("Monitor thread %r already started." % threadname)
517	542	start.priority = 70
518
	543
519	544	def stop(self):
520	545	"""Stop our callback's background task thread."""
521	546	if self.thread is None:
522		self.bus.log("No thread running for %s." % self.name or self.__class__.__name__)
	547	self.bus.log("No thread running for %s." %
	548	self.name or self.__class__.__name__)
523	549	else:
524	550	if self.thread is not threading.currentThread():
525	551	name = self.thread.getName()

529	555	self.thread.join()
530	556	self.bus.log("Stopped thread %r." % name)
531	557	self.thread = None
532
	558
533	559	def graceful(self):
534	560	"""Stop the callback's background task thread and restart it."""
535	561	self.stop()

537	563
538	564
539	565	class Autoreloader(Monitor):
	566
540	567	"""Monitor which re-executes the process when files change.
541
	568
542	569	This :ref:`plugin<plugins>` restarts the process (via :func:`os.execv`)
543	570	if any of the files it monitors change (or is deleted). By default, the
544	571	autoreloader monitors all imported modules; you can add to the
545	572	set by adding to ``autoreload.files``::
546
	573
547	574	cherrypy.engine.autoreload.files.add(myFile)
548
549		If there are imported files you do not wish to monitor, you can adjust the
550		``match`` attribute, a regular expression. For example, to stop monitoring
551		cherrypy itself::
552
	575
	576	If there are imported files you do not wish to monitor, you can
	577	adjust the ``match`` attribute, a regular expression. For example,
	578	to stop monitoring cherrypy itself::
	579
553	580	cherrypy.engine.autoreload.match = r'^(?!cherrypy).+'
554
	581
555	582	Like all :class:`Monitor<cherrypy.process.plugins.Monitor>` plugins,
556	583	the autoreload plugin takes a ``frequency`` argument. The default is
557	584	1 second; that is, the autoreloader will examine files once each second.
558	585	"""
559
	586
560	587	files = None
561	588	"""The set of files to poll for modifications."""
562
	589
563	590	frequency = 1
564	591	"""The interval in seconds at which to poll for modified files."""
565
	592
566	593	match = '.*'
567	594	"""A regular expression by which to match filenames."""
568
	595
569	596	def __init__(self, bus, frequency=1, match='.*'):
570	597	self.mtimes = {}
571	598	self.files = set()
572	599	self.match = match
573	600	Monitor.__init__(self, bus, self.run, frequency)
574
	601
575	602	def start(self):
576	603	"""Start our own background task thread for self.run."""
577	604	if self.thread is None:
578	605	self.mtimes = {}
579	606	Monitor.start(self)
580		start.priority = 70
581
	607	start.priority = 70
	608
582	609	def sysfiles(self):
583	610	"""Return a Set of sys.modules filenames to monitor."""
584	611	files = set()
585		for k, m in sys.modules.items():
	612	for k, m in list(sys.modules.items()):
586	613	if re.match(self.match, k):
587		if hasattr(m, '__loader__') and hasattr(m.__loader__, 'archive'):
	614	if (
	615	hasattr(m, '__loader__') and
	616	hasattr(m.__loader__, 'archive')
	617	):
588	618	f = m.__loader__.archive
589	619	else:
590	620	f = getattr(m, '__file__', None)
591	621	if f is not None and not os.path.isabs(f):
592		# ensure absolute paths so a os.chdir() in the app doesn't break me
593		f = os.path.normpath(os.path.join(_module__file__base, f))
	622	# ensure absolute paths so a os.chdir() in the app
	623	# doesn't break me
	624	f = os.path.normpath(
	625	os.path.join(_module__file__base, f))
594	626	files.add(f)
595	627	return files
596
	628
597	629	def run(self):
598	630	"""Reload the process if registered files have been modified."""
599	631	for filename in self.sysfiles() \| self.files:
600	632	if filename:
601	633	if filename.endswith('.pyc'):
602	634	filename = filename[:-1]
603
	635
604	636	oldtime = self.mtimes.get(filename, 0)
605	637	if oldtime is None:
606	638	# Module with no .py file. Skip it.
607	639	continue
608
	640
609	641	try:
610	642	mtime = os.stat(filename).st_mtime
611	643	except OSError:
612	644	# Either a module with no .py file, or it's been deleted.
613	645	mtime = None
614
	646
615	647	if filename not in self.mtimes:
616	648	# If a module has no .py file, this will be None.
617	649	self.mtimes[filename] = mtime
618	650	else:
619	651	if mtime is None or mtime > oldtime:
620	652	# The file has been deleted or modified.
621		self.bus.log("Restarting because %s changed." % filename)
	653	self.bus.log("Restarting because %s changed." %
	654	filename)
622	655	self.thread.cancel()
623		self.bus.log("Stopped thread %r." % self.thread.getName())
	656	self.bus.log("Stopped thread %r." %
	657	self.thread.getName())
624	658	self.bus.restart()
625	659	return
626	660
627	661
628	662	class ThreadManager(SimplePlugin):
	663
629	664	"""Manager for HTTP request threads.
630
	665
631	666	If you have control over thread creation and destruction, publish to
632	667	the 'acquire_thread' and 'release_thread' channels (for each thread).
633	668	This will register/unregister the current thread and publish to
634	669	'start_thread' and 'stop_thread' listeners in the bus as needed.
635
	670
636	671	If threads are created and destroyed by code you do not control
637	672	(e.g., Apache), then, at the beginning of every HTTP request,
638	673	publish to 'acquire_thread' only. You should not publish to

640	675	the thread will be re-used or not. The bus will call
641	676	'stop_thread' listeners for you when it stops.
642	677	"""
643
	678
644	679	threads = None
645	680	"""A map of {thread ident: index number} pairs."""
646
	681
647	682	def __init__(self, bus):
648	683	self.threads = {}
649	684	SimplePlugin.__init__(self, bus)

654	689
655	690	def acquire_thread(self):
656	691	"""Run 'start_thread' listeners for the current thread.
657
	692
658	693	If the current thread has already been seen, any 'start_thread'
659	694	listeners will not be run again.
660	695	"""

665	700	i = len(self.threads) + 1
666	701	self.threads[thread_ident] = i
667	702	self.bus.publish('start_thread', i)
668
	703
669	704	def release_thread(self):
670	705	"""Release the current thread and run 'stop_thread' listeners."""
671	706	thread_ident = get_thread_ident()
672	707	i = self.threads.pop(thread_ident, None)
673	708	if i is not None:
674	709	self.bus.publish('stop_thread', i)
675
	710
676	711	def stop(self):
677	712	"""Release all threads and run all 'stop_thread' listeners."""
678	713	for thread_ident, i in self.threads.items():
679	714	self.bus.publish('stop_thread', i)
680	715	self.threads.clear()
681	716	graceful = stop
682

+86

-48

cherrypy/process/servers.py less more

12	12	with engine.start::
13	13
14	14	s1 = ServerAdapter(cherrypy.engine, MyWSGIServer(host='0.0.0.0', port=80))
15		s2 = ServerAdapter(cherrypy.engine, another.HTTPServer(host='127.0.0.1', SSL=True))
	15	s2 = ServerAdapter(cherrypy.engine,
	16	another.HTTPServer(host='127.0.0.1',
	17	SSL=True))
16	18	s1.subscribe()
17	19	s2.subscribe()
18	20	cherrypy.engine.start()

53	55
54	56	#!/usr/bin/python
55	57	import cherrypy
56
	58
57	59	class HelloWorld:
58	60	\"""Sample request handler class.\"""
59	61	def index(self):
60	62	return "Hello world!"
61	63	index.exposed = True
62
	64
63	65	cherrypy.tree.mount(HelloWorld())
64	66	# CherryPy autoreload must be disabled for the flup server to work
65		cherrypy.config.update({'engine.autoreload_on':False})
	67	cherrypy.config.update({'engine.autoreload.on':False})
66	68
67	69	Then run :doc:`/deployguide/cherryd` with the '-f' arg::
68	70

106	108	} # end of $HTTP["url"] =~ "^/"
107	109
108	110	Please see `Lighttpd FastCGI Docs
109		<http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModFastCGI>`_ for an explanation
110		of the possible configuration options.
	111	<http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModFastCGI>`_ for
	112	an explanation of the possible configuration options.
111	113	"""
112	114
113	115	import sys
114	116	import time
	117	import warnings
115	118
116	119
117	120	class ServerAdapter(object):
	121
118	122	"""Adapter for an HTTP server.
119
	123
120	124	If you need to start more than one HTTP server (to serve on multiple
121	125	ports, or protocols, etc.), you can manually register each one and then
122	126	start them all with bus.start:
123
	127
124	128	s1 = ServerAdapter(bus, MyWSGIServer(host='0.0.0.0', port=80))
125	129	s2 = ServerAdapter(bus, another.HTTPServer(host='127.0.0.1', SSL=True))
126	130	s1.subscribe()
127	131	s2.subscribe()
128	132	bus.start()
129	133	"""
130
	134
131	135	def __init__(self, bus, httpserver=None, bind_addr=None):
132	136	self.bus = bus
133	137	self.httpserver = httpserver
134	138	self.bind_addr = bind_addr
135	139	self.interrupt = None
136	140	self.running = False
137
	141
138	142	def subscribe(self):
139	143	self.bus.subscribe('start', self.start)
140	144	self.bus.subscribe('stop', self.stop)
141
	145
142	146	def unsubscribe(self):
143	147	self.bus.unsubscribe('start', self.start)
144	148	self.bus.unsubscribe('stop', self.stop)
145
	149
146	150	def start(self):
147	151	"""Start the HTTP server."""
148	152	if self.bind_addr is None:
149	153	on_what = "unknown interface (dynamic?)"
150	154	elif isinstance(self.bind_addr, tuple):
151		host, port = self.bind_addr
152		on_what = "%s:%s" % (host, port)
	155	on_what = self._get_base()
153	156	else:
154	157	on_what = "socket file: %s" % self.bind_addr
155
	158
156	159	if self.running:
157	160	self.bus.log("Already serving on %s" % on_what)
158	161	return
159
	162
160	163	self.interrupt = None
161	164	if not self.httpserver:
162	165	raise ValueError("No HTTP server has been created.")
163
	166
164	167	# Start the httpserver in a new thread.
165	168	if isinstance(self.bind_addr, tuple):
166	169	wait_for_free_port(*self.bind_addr)
167
	170
168	171	import threading
169	172	t = threading.Thread(target=self._start_http_thread)
170	173	t.setName("HTTPServer " + t.getName())
171	174	t.start()
172
	175
173	176	self.wait()
174	177	self.running = True
175	178	self.bus.log("Serving on %s" % on_what)
176	179	start.priority = 75
177
	180
	181	def _get_base(self):
	182	if not self.httpserver:
	183	return ''
	184	host, port = self.bind_addr
	185	if getattr(self.httpserver, 'ssl_certificate', None):
	186	scheme = "https"
	187	if port != 443:
	188	host += ":%s" % port
	189	else:
	190	scheme = "http"
	191	if port != 80:
	192	host += ":%s" % port
	193
	194	return "%s://%s" % (scheme, host)
	195
178	196	def _start_http_thread(self):
179	197	"""HTTP servers MUST be running in new threads, so that the
180	198	main thread persists to receive KeyboardInterrupt's. If an

199	217	traceback=True, level=40)
200	218	self.bus.exit()
201	219	raise
202
	220
203	221	def wait(self):
204	222	"""Wait until the HTTP server is ready to receive requests."""
205	223	while not getattr(self.httpserver, "ready", False):
206	224	if self.interrupt:
207	225	raise self.interrupt
208	226	time.sleep(.1)
209
	227
210	228	# Wait for port to be occupied
211	229	if isinstance(self.bind_addr, tuple):
212	230	host, port = self.bind_addr
213	231	wait_for_occupied_port(host, port)
214
	232
215	233	def stop(self):
216	234	"""Stop the HTTP server."""
217	235	if self.running:

225	243	else:
226	244	self.bus.log("HTTP Server %s already shut down" % self.httpserver)
227	245	stop.priority = 25
228
	246
229	247	def restart(self):
230	248	"""Restart the HTTP server."""
231	249	self.stop()

233	251
234	252
235	253	class FlupCGIServer(object):
	254
236	255	"""Adapter for a flup.server.cgi.WSGIServer."""
237
	256
238	257	def __init__(self, args, *kwargs):
239	258	self.args = args
240	259	self.kwargs = kwargs
241	260	self.ready = False
242
	261
243	262	def start(self):
244	263	"""Start the CGI server."""
245	264	# We have to instantiate the server class here because its __init__
246	265	# starts a threadpool. If we do it too early, daemonize won't work.
247	266	from flup.server.cgi import WSGIServer
248
	267
249	268	self.cgiserver = WSGIServer(self.args, *self.kwargs)
250	269	self.ready = True
251	270	self.cgiserver.run()
252
	271
253	272	def stop(self):
254	273	"""Stop the HTTP server."""
255	274	self.ready = False
256	275
257	276
258	277	class FlupFCGIServer(object):
	278
259	279	"""Adapter for a flup.server.fcgi.WSGIServer."""
260
	280
261	281	def __init__(self, args, *kwargs):
262	282	if kwargs.get('bindAddress', None) is None:
263	283	import socket

269	289	self.args = args
270	290	self.kwargs = kwargs
271	291	self.ready = False
272
	292
273	293	def start(self):
274	294	"""Start the FCGI server."""
275	295	# We have to instantiate the server class here because its __init__

289	309	self.fcgiserver._oldSIGs = []
290	310	self.ready = True
291	311	self.fcgiserver.run()
292
	312
293	313	def stop(self):
294	314	"""Stop the HTTP server."""
295	315	# Forcibly stop the fcgi server main event loop.
296	316	self.fcgiserver._keepGoing = False
297	317	# Force all worker threads to die off.
298		self.fcgiserver._threadPool.maxSpare = self.fcgiserver._threadPool._idleCount
	318	self.fcgiserver._threadPool.maxSpare = (
	319	self.fcgiserver._threadPool._idleCount)
299	320	self.ready = False
300	321
301	322
302	323	class FlupSCGIServer(object):
	324
303	325	"""Adapter for a flup.server.scgi.WSGIServer."""
304
	326
305	327	def __init__(self, args, *kwargs):
306	328	self.args = args
307	329	self.kwargs = kwargs
308	330	self.ready = False
309
	331
310	332	def start(self):
311	333	"""Start the SCGI server."""
312	334	# We have to instantiate the server class here because its __init__

326	348	self.scgiserver._oldSIGs = []
327	349	self.ready = True
328	350	self.scgiserver.run()
329
	351
330	352	def stop(self):
331	353	"""Stop the HTTP server."""
332	354	self.ready = False

343	365	return '127.0.0.1'
344	366	if server_host in ('::', '::0', '::0.0.0.0'):
345	367	# :: is IN6ADDR_ANY, which should answer on localhost.
346		# ::0 and ::0.0.0.0 are non-canonical but common ways to write IN6ADDR_ANY.
	368	# ::0 and ::0.0.0.0 are non-canonical but common
	369	# ways to write IN6ADDR_ANY.
347	370	return '::1'
348	371	return server_host
	372
349	373
350	374	def check_port(host, port, timeout=1.0):
351	375	"""Raise an error if the given port is not free on the given host."""

353	377	raise ValueError("Host values of '' or None are not allowed.")
354	378	host = client_host(host)
355	379	port = int(port)
356
	380
357	381	import socket
358
	382
359	383	# AF_INET or AF_INET6 socket
360	384	# Get the correct address family for our host (allows IPv6 addresses)
361	385	try:

363	387	socket.SOCK_STREAM)
364	388	except socket.gaierror:
365	389	if ':' in host:
366		info = [(socket.AF_INET6, socket.SOCK_STREAM, 0, "", (host, port, 0, 0))]
	390	info = [(
	391	socket.AF_INET6, socket.SOCK_STREAM, 0, "", (host, port, 0, 0)
	392	)]
367	393	else:
368	394	info = [(socket.AF_INET, socket.SOCK_STREAM, 0, "", (host, port))]
369
	395
370	396	for res in info:
371	397	af, socktype, proto, canonname, sa = res
372	398	s = None

377	403	s.settimeout(timeout)
378	404	s.connect((host, port))
379	405	s.close()
	406	except socket.error:
	407	if s:
	408	s.close()
	409	else:
380	410	raise IOError("Port %s is in use on %s; perhaps the previous "
381	411	"httpserver did not shut down properly." %
382	412	(repr(port), repr(host)))
383		except socket.error:
384		if s:
385		s.close()
386	413
387	414
388	415	# Feel free to increase these defaults on slow systems:
389	416	free_port_timeout = 0.1
390	417	occupied_port_timeout = 1.0
	418
391	419
392	420	def wait_for_free_port(host, port, timeout=None):
393	421	"""Wait for the specified port to become free (drop requests)."""

395	423	raise ValueError("Host values of '' or None are not allowed.")
396	424	if timeout is None:
397	425	timeout = free_port_timeout
398
	426
399	427	for trial in range(50):
400	428	try:
401	429	# we are expecting a free port, so reduce the timeout

405	433	time.sleep(timeout)
406	434	else:
407	435	return
408
	436
409	437	raise IOError("Port %r not free on %r" % (port, host))
	438
410	439
411	440	def wait_for_occupied_port(host, port, timeout=None):
412	441	"""Wait for the specified port to become active (receive requests)."""

414	443	raise ValueError("Host values of '' or None are not allowed.")
415	444	if timeout is None:
416	445	timeout = occupied_port_timeout
417
	446
418	447	for trial in range(50):
419	448	try:
420	449	check_port(host, port, timeout=timeout)
421	450	except IOError:
	451	# port is occupied
422	452	return
423	453	else:
424	454	time.sleep(timeout)
425
426		raise IOError("Port %r not bound on %r" % (port, host))
	455
	456	if host == client_host(host):
	457	raise IOError("Port %r not bound on %r" % (port, host))
	458
	459	# On systems where a loopback interface is not available and the
	460	# server is bound to all interfaces, it's difficult to determine
	461	# whether the server is in fact occupying the port. In this case,
	462	# just issue a warning and move on. See issue #1100.
	463	msg = "Unable to verify that the server is bound on %r" % port
	464	warnings.warn(msg)

+30

-24

cherrypy/process/win32.py less more

10	10
11	11
12	12	class ConsoleCtrlHandler(plugins.SimplePlugin):
	13
13	14	"""A WSPBus plugin for handling Win32 console events (like Ctrl-C)."""
14
	15
15	16	def __init__(self, bus):
16	17	self.is_set = False
17	18	plugins.SimplePlugin.__init__(self, bus)
18
	19
19	20	def start(self):
20	21	if self.is_set:
21	22	self.bus.log('Handler for console events already set.', level=40)
22	23	return
23
	24
24	25	result = win32api.SetConsoleCtrlHandler(self.handle, 1)
25	26	if result == 0:
26	27	self.bus.log('Could not SetConsoleCtrlHandler (error %r)' %

28	29	else:
29	30	self.bus.log('Set handler for console events.', level=40)
30	31	self.is_set = True
31
	32
32	33	def stop(self):
33	34	if not self.is_set:
34	35	self.bus.log('Handler for console events already off.', level=40)
35	36	return
36
	37
37	38	try:
38	39	result = win32api.SetConsoleCtrlHandler(self.handle, 0)
39	40	except ValueError:
40	41	# "ValueError: The object has not been registered"
41	42	result = 1
42
	43
43	44	if result == 0:
44	45	self.bus.log('Could not remove SetConsoleCtrlHandler (error %r)' %
45	46	win32api.GetLastError(), level=40)
46	47	else:
47	48	self.bus.log('Removed handler for console events.', level=40)
48	49	self.is_set = False
49
	50
50	51	def handle(self, event):
51	52	"""Handle console control events (like Ctrl-C)."""
52	53	if event in (win32con.CTRL_C_EVENT, win32con.CTRL_LOGOFF_EVENT,
53	54	win32con.CTRL_BREAK_EVENT, win32con.CTRL_SHUTDOWN_EVENT,
54	55	win32con.CTRL_CLOSE_EVENT):
55	56	self.bus.log('Console event %s: shutting down bus' % event)
56
	57
57	58	# Remove self immediately so repeated Ctrl-C doesn't re-call it.
58	59	try:
59	60	self.stop()
60	61	except ValueError:
61	62	pass
62
	63
63	64	self.bus.exit()
64	65	# 'First to return True stops the calls'
65	66	return 1

67	68
68	69
69	70	class Win32Bus(wspbus.Bus):
	71
70	72	"""A Web Site Process Bus implementation for Win32.
71
	73
72	74	Instead of time.sleep, this bus blocks using native win32event objects.
73	75	"""
74
	76
75	77	def __init__(self):
76	78	self.events = {}
77	79	wspbus.Bus.__init__(self)
78
	80
79	81	def _get_state_event(self, state):
80	82	"""Return a win32event for the given state (creating it if needed)."""
81	83	try:

86	88	(state.name, os.getpid()))
87	89	self.events[state] = event
88	90	return event
89
	91
90	92	def _get_state(self):
91	93	return self._state
	94
92	95	def _set_state(self, value):
93	96	self._state = value
94	97	event = self._get_state_event(value)
95	98	win32event.PulseEvent(event)
96	99	state = property(_get_state, _set_state)
97
	100
98	101	def wait(self, state, interval=0.1, channel=None):
99	102	"""Wait for the given state(s), KeyboardInterrupt or SystemExit.
100
	103
101	104	Since this class uses native win32event objects, the interval
102	105	argument is ignored.
103	106	"""

105	108	# Don't wait for an event that beat us to the punch ;)
106	109	if self.state not in state:
107	110	events = tuple([self._get_state_event(s) for s in state])
108		win32event.WaitForMultipleObjects(events, 0, win32event.INFINITE)
	111	win32event.WaitForMultipleObjects(
	112	events, 0, win32event.INFINITE)
109	113	else:
110	114	# Don't wait for an event that beat us to the punch ;)
111	115	if self.state != state:

114	118
115	119
116	120	class _ControlCodes(dict):
	121
117	122	"""Control codes used to "signal" a service via ControlService.
118
	123
119	124	User-defined control codes are in the range 128-255. We generally use
120	125	the standard Python value for the Linux signal and add 128. Example:
121
	126
122	127	>>> signal.SIGUSR1
123	128	10
124	129	control_codes['graceful'] = 128 + 10
125	130	"""
126
	131
127	132	def key_for(self, obj):
128	133	"""For the given value, return its corresponding key."""
129	134	for key, val in self.items():

144	149
145	150
146	151	class PyWebService(win32serviceutil.ServiceFramework):
	152
147	153	"""Python Web Service."""
148
	154
149	155	_svc_name_ = "Python Web Service"
150	156	_svc_display_name_ = "Python Web Service"
151	157	_svc_deps_ = None # sequence of service names on which this depends
152	158	_exe_name_ = "pywebsvc"
153	159	_exe_args_ = None # Default to no arguments
154
	160
155	161	# Only exists on Windows 2000 or later, ignored on windows NT
156	162	_svc_description_ = "Python Web Service"
157
	163
158	164	def SvcDoRun(self):
159	165	from cherrypy import process
160	166	process.bus.start()
161	167	process.bus.block()
162
	168
163	169	def SvcStop(self):
164	170	from cherrypy import process
165	171	self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
166	172	process.bus.exit()
167
	173
168	174	def SvcOther(self, control):
169	175	process.bus.publish(control_codes.key_for(control))
170	176

+67

-51

cherrypy/process/wspbus.py less more

77	77	# sys.executable is a relative-path, and/or cause other problems).
78	78	_startup_cwd = os.getcwd()
79	79
	80
80	81	class ChannelFailures(Exception):
81		"""Exception raised when errors occur in a listener during Bus.publish()."""
	82
	83	"""Exception raised when errors occur in a listener during Bus.publish().
	84	"""
82	85	delimiter = '\n'
83
	86
84	87	def __init__(self, args, *kwargs):
85	88	# Don't use 'super' here; Exceptions are old-style in Py2.4
86		# See http://www.cherrypy.org/ticket/959
	89	# See https://bitbucket.org/cherrypy/cherrypy/issue/959
87	90	Exception.__init__(self, args, *kwargs)
88	91	self._exceptions = list()
89
	92
90	93	def handle_exception(self):
91	94	"""Append the current exception to self."""
92	95	self._exceptions.append(sys.exc_info()[1])
93
	96
94	97	def get_instances(self):
95	98	"""Return a list of seen exception instances."""
96	99	return self._exceptions[:]
97
	100
98	101	def __str__(self):
99	102	exception_strings = map(repr, self.get_instances())
100	103	return self.delimiter.join(exception_strings)

106	109	__nonzero__ = __bool__
107	110
108	111	# Use a flag to indicate the state of the bus.
	112
	113
109	114	class _StateEnum(object):
	115
110	116	class State(object):
111	117	name = None
	118
112	119	def __repr__(self):
113	120	return "states.%s" % self.name
114
	121
115	122	def __setattr__(self, key, value):
116	123	if isinstance(value, self.State):
117	124	value.name = key

136	143
137	144
138	145	class Bus(object):
	146
139	147	"""Process state-machine and messenger for HTTP site deployment.
140
	148
141	149	All listeners for a given channel are guaranteed to be called even
142	150	if others at the same channel fail. Each failure is logged, but
143	151	execution proceeds on to the next listener. The only way to stop all
144	152	processing from inside a listener is to raise SystemExit and stop the
145	153	whole server.
146	154	"""
147
	155
148	156	states = states
149	157	state = states.STOPPED
150	158	execv = False
151	159	max_cloexec_files = max_files
152
	160
153	161	def __init__(self):
154	162	self.execv = False
155	163	self.state = states.STOPPED

157	165	[(channel, set()) for channel
158	166	in ('start', 'stop', 'exit', 'graceful', 'log', 'main')])
159	167	self._priorities = {}
160
	168
161	169	def subscribe(self, channel, callback, priority=None):
162	170	"""Add the given callback at the given channel (if not present)."""
163	171	if channel not in self.listeners:
164	172	self.listeners[channel] = set()
165	173	self.listeners[channel].add(callback)
166
	174
167	175	if priority is None:
168	176	priority = getattr(callback, 'priority', 50)
169	177	self._priorities[(channel, callback)] = priority
170
	178
171	179	def unsubscribe(self, channel, callback):
172	180	"""Discard the given callback (if present)."""
173	181	listeners = self.listeners.get(channel)
174	182	if listeners and callback in listeners:
175	183	listeners.discard(callback)
176	184	del self._priorities[(channel, callback)]
177
	185
178	186	def publish(self, channel, args, *kwargs):
179	187	"""Return output of all subscribers for the given channel."""
180	188	if channel not in self.listeners:
181	189	return []
182
	190
183	191	exc = ChannelFailures()
184	192	output = []
185
	193
186	194	items = [(self._priorities[(channel, listener)], listener)
187	195	for listener in self.listeners[channel]]
188	196	try:

213	221	if exc:
214	222	raise exc
215	223	return output
216
	224
217	225	def _clean_exit(self):
218	226	"""An atexit handler which asserts the Bus is not running."""
219	227	if self.state != states.EXITING:

223	231	"bus.block() after start(), or call bus.exit() before the "
224	232	"main thread exits." % self.state, RuntimeWarning)
225	233	self.exit()
226
	234
227	235	def start(self):
228	236	"""Start all services."""
229	237	atexit.register(self._clean_exit)
230
	238
231	239	self.state = states.STARTING
232	240	self.log('Bus STARTING')
233	241	try:

247	255	pass
248	256	# Re-raise the original error
249	257	raise e_info
250
	258
251	259	def exit(self):
252	260	"""Stop all services and prepare to exit the process."""
253	261	exitstate = self.state
254	262	try:
255	263	self.stop()
256
	264
257	265	self.state = states.EXITING
258	266	self.log('Bus EXITING')
259	267	self.publish('exit')

265	273	# signal handler, console handler, or atexit handler), so we
266	274	# can't just let exceptions propagate out unhandled.
267	275	# Assume it's been logged and just die.
268		os._exit(70) # EX_SOFTWARE
269
	276	os._exit(70) # EX_SOFTWARE
	277
270	278	if exitstate == states.STARTING:
271	279	# exit() was called before start() finished, possibly due to
272	280	# Ctrl-C because a start listener got stuck. In this case,
273	281	# we could get stuck in a loop where Ctrl-C never exits the
274	282	# process, so we just call os.exit here.
275		os._exit(70) # EX_SOFTWARE
276
	283	os._exit(70) # EX_SOFTWARE
	284
277	285	def restart(self):
278	286	"""Restart the process (may close connections).
279
	287
280	288	This method does not restart the process from the calling thread;
281	289	instead, it stops the bus and asks the main thread to call execv.
282	290	"""
283	291	self.execv = True
284	292	self.exit()
285
	293
286	294	def graceful(self):
287	295	"""Advise all services to reload."""
288	296	self.log('Bus graceful')
289	297	self.publish('graceful')
290
	298
291	299	def block(self, interval=0.1):
292	300	"""Wait for the EXITING state, KeyboardInterrupt or SystemExit.
293
	301
294	302	This function is intended to be called only by the main thread.
295	303	After waiting for the EXITING state, it also waits for all threads
296	304	to terminate, and then calls os.execv if self.execv is True. This

308	316	self.log('SystemExit raised: shutting down bus')
309	317	self.exit()
310	318	raise
311
	319
312	320	# Waiting for ALL child threads to finish is necessary on OS X.
313		# See http://www.cherrypy.org/ticket/581.
	321	# See https://bitbucket.org/cherrypy/cherrypy/issue/581.
314	322	# It's also good to let them all shut down before allowing
315	323	# the main thread to call atexit handlers.
316		# See http://www.cherrypy.org/ticket/751.
	324	# See https://bitbucket.org/cherrypy/cherrypy/issue/751.
317	325	self.log("Waiting for child threads to terminate...")
318	326	for t in threading.enumerate():
319		if t != threading.currentThread() and t.isAlive():
	327	# Validate the we're not trying to join the MainThread
	328	# that will cause a deadlock and the case exist when
	329	# implemented as a windows service and in any other case
	330	# that another thread executes cherrypy.engine.exit()
	331	if (
	332	t != threading.currentThread() and
	333	t.isAlive() and
	334	not isinstance(t, threading._MainThread)
	335	):
320	336	# Note that any dummy (external) threads are always daemonic.
321	337	if hasattr(threading.Thread, "daemon"):
322	338	# Python 2.6+

326	342	if not d:
327	343	self.log("Waiting for thread %s." % t.getName())
328	344	t.join()
329
	345
330	346	if self.execv:
331	347	self._do_execv()
332
	348
333	349	def wait(self, state, interval=0.1, channel=None):
334	350	"""Poll for the given state(s) at intervals; publish to channel."""
335	351	if isinstance(state, (tuple, list)):
336	352	states = state
337	353	else:
338	354	states = [state]
339
	355
340	356	def _wait():
341	357	while self.state not in states:
342	358	time.sleep(interval)
343	359	self.publish(channel)
344
	360
345	361	# From http://psyco.sourceforge.net/psycoguide/bugs.html:
346	362	# "The compiled machine code does not include the regular polling
347	363	# done by Python, meaning that a KeyboardInterrupt will not be

352	368	sys.modules['psyco'].cannotcompile(_wait)
353	369	except (KeyError, AttributeError):
354	370	pass
355
	371
356	372	_wait()
357
	373
358	374	def _do_execv(self):
359	375	"""Re-execute the current process.
360
	376
361	377	This must be called from the main thread, because certain platforms
362	378	(OS X) don't allow execv to be called in a child thread very well.
363	379	"""
364	380	args = sys.argv[:]
365	381	self.log('Re-spawning %s' % ' '.join(args))
366
	382
367	383	if sys.platform[:4] == 'java':
368	384	from _systemrestart import SystemRestart
369	385	raise SystemRestart

376	392	if self.max_cloexec_files:
377	393	self._set_cloexec()
378	394	os.execv(sys.executable, args)
379
	395
380	396	def _set_cloexec(self):
381	397	"""Set the CLOEXEC flag on all open files (except stdin/out/err).
382
	398
383	399	If self.max_cloexec_files is an integer (the default), then on
384	400	platforms which support it, it represents the max open files setting
385	401	for the operating system. This function will be called just before
386	402	the process is restarted via os.execv() to prevent open files
387	403	from persisting into the new process.
388
	404
389	405	Set self.max_cloexec_files to 0 to disable this behavior.
390	406	"""
391		for fd in range(3, self.max_cloexec_files): # skip stdin/out/err
	407	for fd in range(3, self.max_cloexec_files): # skip stdin/out/err
392	408	try:
393	409	flags = fcntl.fcntl(fd, fcntl.F_GETFD)
394	410	except IOError:
395	411	continue
396	412	fcntl.fcntl(fd, fcntl.F_SETFD, flags \| fcntl.FD_CLOEXEC)
397
	413
398	414	def stop(self):
399	415	"""Stop all services."""
400	416	self.state = states.STOPPING

402	418	self.publish('stop')
403	419	self.state = states.STOPPED
404	420	self.log('Bus STOPPED')
405
	421
406	422	def start_with_callback(self, func, args=None, kwargs=None):
407	423	"""Start 'func' in a new thread T, then start self (and return T)."""
408	424	if args is None:

410	426	if kwargs is None:
411	427	kwargs = {}
412	428	args = (func,) + args
413
	429
414	430	def _callback(func, a, *kw):
415	431	self.wait(states.STARTED)
416	432	func(a, *kw)
417	433	t = threading.Thread(target=_callback, args=args, kwargs=kwargs)
418	434	t.setName('Bus Callback ' + t.getName())
419	435	t.start()
420
	436
421	437	self.start()
422
	438
423	439	return t
424
	440
425	441	def log(self, msg="", level=20, traceback=False):
426	442	"""Log the given message. Append the last traceback if requested."""
427	443	if traceback:

-9

cherrypy/scaffold/__init__.py less more

19	19
20	20
21	21	class Root:
22
	22
23	23	_cp_config = {'tools.log_tracebacks.on': True,
24	24	}
25
	25
26	26	def index(self):
27	27	return """<html>
28	28	<body>Try some <a href='%s?a=7'>other</a> path,

32	32	</body></html>""" % (url("other"), url("else"),
33	33	url("files/made_with_cherrypy_small.png"))
34	34	index.exposed = True
35
	35
36	36	def default(self, args, *kwargs):
37	37	return "args: %s kwargs: %s" % (args, kwargs)
38	38	default.exposed = True
39
	39
40	40	def other(self, a=2, b='bananas', c=None):
41	41	cherrypy.response.headers['Content-Type'] = 'text/plain'
42	42	if c is None:

44	44	else:
45	45	return "Have %d %s, %s." % (int(a), b, c)
46	46	other.exposed = True
47
	47
48	48	files = cherrypy.tools.staticdir.handler(
49		section="/files",
50		dir=os.path.join(local_dir, "static"),
51		# Ignore .php files, etc.
	49	section="/files",
	50	dir=os.path.join(local_dir, "static"),
	51	# Ignore .php files, etc.
52	52	match=r'\.(css\|gif\|html?\|ico\|jpe?g\|js\|png\|swf\|xml)$',
53		)
	53	)
54	54
55	55
56	56	root = Root()

-0

cherrypy/test/__init__.py less more

10	10	import os
11	11	import sys
12	12
	13
13	14	def newexit():
14	15	os._exit(1)
	16
15	17
16	18	def setup():
17	19	# We want to monkey patch sys.exit so that we can get some

19	21	newexit._old = sys.exit
20	22	sys.exit = newexit
21	23
	24
22	25	def teardown():
23	26	try:
24	27	sys.exit = sys.exit._old

-8

cherrypy/test/_test_decorators.py less more

4	4
5	5
6	6	class ExposeExamples(object):
7
	7
8	8	@expose
9	9	def no_call(self):
10	10	return "Mr E. R. Bradshaw"
11
	11
12	12	@expose()
13	13	def call_empty(self):
14	14	return "Mrs. B.J. Smegma"
15
	15
16	16	@expose("call_alias")
17	17	def nesbitt(self):
18	18	return "Mr Nesbitt"
19
	19
20	20	@expose(["alias1", "alias2"])
21	21	def andrews(self):
22	22	return "Mr Ken Andrews"
23
	23
24	24	@expose(alias="alias3")
25	25	def watson(self):
26	26	return "Mr. and Mrs. Watson"
27	27
28	28
29	29	class ToolExamples(object):
30
	30
31	31	@expose
32	32	@tools.response_headers(headers=[('Content-Type', 'application/data')])
33	33	def blah(self):

36	36	# the _cp_config attribute added by the Tool decorator. You have
37	37	# to write _cp_config[k] = v or _cp_config.update(...) instead.
38	38	blah._cp_config['response.stream'] = True
39
40

-7

cherrypy/test/_test_states_demo.py less more

6	6
7	7
8	8	class Root:
9
	9
10	10	def index(self):
11	11	return "Hello World"
12	12	index.exposed = True
13
	13
14	14	def mtimes(self):
15	15	return repr(cherrypy.engine.publish("Autoreloader", "mtimes"))
16	16	mtimes.exposed = True
17
	17
18	18	def pid(self):
19	19	return str(os.getpid())
20	20	pid.exposed = True
21
	21
22	22	def start(self):
23	23	return repr(starttime)
24	24	start.exposed = True
25
	25
26	26	def exit(self):
27	27	# This handler might be called before the engine is STARTED if an
28	28	# HTTP worker thread handles it before the HTTP server returns

31	31	cherrypy.engine.wait(state=cherrypy.engine.states.STARTED)
32	32	cherrypy.engine.exit()
33	33	exit.exposed = True
34
	34
35	35
36	36	def unsub_sig():
37	37	cherrypy.log("unsubsig: %s" % cherrypy.config.get('unsubsig', False))

56	56	zerodiv = 1 / 0
57	57	cherrypy.engine.subscribe('start', starterror, priority=6)
58	58
	59
59	60	def log_test_case_name():
60	61	if cherrypy.config.get('test_case_name', False):
61		cherrypy.log("STARTED FROM: %s" % cherrypy.config.get('test_case_name'))
	62	cherrypy.log("STARTED FROM: %s" %
	63	cherrypy.config.get('test_case_name'))
62	64	cherrypy.engine.subscribe('start', log_test_case_name, priority=6)
63	65
64	66

+72

-59

cherrypy/test/benchmark.py less more

0	0	"""CherryPy Benchmark Tool
1	1
2	2	Usage:
3		benchmark.py --null --notests --help --cpmodpy --modpython --ab=path --apache=path
4
	3	benchmark.py [options]
	4
5	5	--null: use a null Request object (to bench the HTTP server only)
6	6	--notests: start the server but do not run the tests; this allows
7	7	you to check the tested pages with a browser

10	10	--modpython: run tests via apache on 54583 (with modpython_gateway)
11	11	--ab=path: Use the ab script/executable at 'path' (see below)
12	12	--apache=path: Use the apache script/exe at 'path' (see below)
13
	13
14	14	To run the benchmarks, the Apache Benchmark tool "ab" must either be on
15	15	your system path, or specified via the --ab=path option.
16
	16
17	17	To run the modpython tests, the "apache" executable or script must be
18	18	on your system path, or provided via the --apache=path option. On some
19	19	platforms, "apache" may be called "apachectl" or "apache2ctl"--create

46	46
47	47	size_cache = {}
48	48
	49
49	50	class Root:
50
	51
51	52	def index(self):
52	53	return """<html>
53	54	<head>

64	65	</body>
65	66	</html>"""
66	67	index.exposed = True
67
	68
68	69	def hello(self):
69	70	return "Hello, world\r\n"
70	71	hello.exposed = True
71
	72
72	73	def sizer(self, size):
73	74	resp = size_cache.get(size, None)
74	75	if resp is None:

85	86	'server.max_request_header_size': 0,
86	87	'server.max_request_body_size': 0,
87	88	'engine.deadlock_poll_freq': 0,
88		})
	89	})
89	90
90	91	# Cheat mode on ;)
91	92	del cherrypy.config['tools.log_tracebacks.on']

97	98	'tools.staticdir.on': True,
98	99	'tools.staticdir.dir': 'static',
99	100	'tools.staticdir.root': curdir,
100		},
101		}
	101	},
	102	}
102	103	app = cherrypy.tree.mount(Root(), SCRIPT_NAME, appconf)
103	104
104	105
105	106	class NullRequest:
	107
106	108	"""A null HTTP request class, returning 200 and an empty body."""
107
	109
108	110	def __init__(self, local, remote, scheme="http"):
109	111	pass
110
	112
111	113	def close(self):
112	114	pass
113
	115
114	116	def run(self, method, path, query_string, protocol, headers, rfile):
115	117	cherrypy.response.status = "200 OK"
116	118	cherrypy.response.header_list = [("Content-Type", 'text/html'),

127	129
128	130
129	131	class ABSession:
	132
130	133	"""A session of 'ab', the Apache HTTP server benchmarking tool.
131	134
132	135	Example output from ab:

185	188	100% 130 (longest request)
186	189	Finished 1000 requests
187	190	"""
188
189		parse_patterns = [('complete_requests', 'Completed',
190		ntob(r'^Complete requests:\s*(\d+)')),
191		('failed_requests', 'Failed',
192		ntob(r'^Failed requests:\s*(\d+)')),
193		('requests_per_second', 'req/sec',
194		ntob(r'^Requests per second:\s*([0-9.]+)')),
195		('time_per_request_concurrent', 'msec/req',
196		ntob(r'^Time per request:\s([0-9.]+).concurrent requests\)$')),
197		('transfer_rate', 'KB/sec',
198		ntob(r'^Transfer rate:\s*([0-9.]+)')),
199		]
200
201		def __init__(self, path=SCRIPT_NAME + "/hello", requests=1000, concurrency=10):
	191
	192	parse_patterns = [
	193	('complete_requests', 'Completed',
	194	ntob(r'^Complete requests:\s*(\d+)')),
	195	('failed_requests', 'Failed',
	196	ntob(r'^Failed requests:\s*(\d+)')),
	197	('requests_per_second', 'req/sec',
	198	ntob(r'^Requests per second:\s*([0-9.]+)')),
	199	('time_per_request_concurrent', 'msec/req',
	200	ntob(r'^Time per request:\s([0-9.]+).concurrent requests\)$')),
	201	('transfer_rate', 'KB/sec',
	202	ntob(r'^Transfer rate:\s*([0-9.]+)'))
	203	]
	204
	205	def __init__(self, path=SCRIPT_NAME + "/hello", requests=1000,
	206	concurrency=10):
202	207	self.path = path
203	208	self.requests = requests
204	209	self.concurrency = concurrency
205
	210
206	211	def args(self):
207	212	port = cherrypy.server.socket_port
208	213	assert self.concurrency > 0
209	214	assert self.requests > 0
210	215	# Don't use "localhost".
211		# Cf http://mail.python.org/pipermail/python-win32/2008-March/007050.html
	216	# Cf
	217	# http://mail.python.org/pipermail/python-win32/2008-March/007050.html
212	218	return ("-k -n %s -c %s http://127.0.0.1:%s%s" %
213	219	(self.requests, self.concurrency, port, self.path))
214
	220
215	221	def run(self):
216	222	# Parse output of ab, setting attributes on self
217	223	try:

219	225	except:
220	226	print(_cperror.format_exc())
221	227	raise
222
	228
223	229	for attr, name, pattern in self.parse_patterns:
224	230	val = re.search(pattern, self.output, re.MULTILINE)
225	231	if val:

239	245	sess = ABSession(path)
240	246	attrs, names, patterns = list(zip(*sess.parse_patterns))
241	247	avg = dict.fromkeys(attrs, 0.0)
242
	248
243	249	yield ('threads',) + names
244	250	for c in concurrency:
245	251	sess.concurrency = c

256	262	row.append(val)
257	263	if row:
258	264	yield row
259
	265
260	266	# Add a row of averages.
261	267	yield ["Average"] + [str(avg[attr] / len(concurrency)) for attr in attrs]
262	268
	269
263	270	def size_report(sizes=(10, 100, 1000, 10000, 100000, 100000000),
264		concurrency=50):
	271	concurrency=50):
265	272	sess = ABSession(concurrency=concurrency)
266	273	attrs, names, patterns = list(zip(*sess.parse_patterns))
267	274	yield ('bytes',) + names

270	277	sess.run()
271	278	yield [sz] + [getattr(sess, attr) for attr in attrs]
272	279
	280
273	281	def print_report(rows):
274	282	for row in rows:
275	283	print("")

281	289	def run_standard_benchmarks():
282	290	print("")
283	291	print("Client Thread Report (1000 requests, 14 byte response body, "
284		"%s server threads):" % cherrypy.server.thread_pool)
	292	"%s server threads):" % cherrypy.server.thread_pool)
285	293	print_report(thread_report())
286
	294
287	295	print("")
288	296	print("Client Thread Report (1000 requests, 14 bytes via staticdir, "
289		"%s server threads):" % cherrypy.server.thread_pool)
	297	"%s server threads):" % cherrypy.server.thread_pool)
290	298	print_report(thread_report("%s/static/index.html" % SCRIPT_NAME))
291
	299
292	300	print("")
293	301	print("Size Report (1000 requests, 50 client threads, "
294		"%s server threads):" % cherrypy.server.thread_pool)
	302	"%s server threads):" % cherrypy.server.thread_pool)
295	303	print_report(size_report())
296	304
297	305
298	306	# modpython and other WSGI #
299	307
300	308	def startup_modpython(req=None):
301		"""Start the CherryPy app server in 'serverless' mode (for modpython/WSGI)."""
	309	"""Start the CherryPy app server in 'serverless' mode (for modpython/WSGI).
	310	"""
302	311	if cherrypy.engine.state == cherrypy._cpengine.STOPPED:
303	312	if req:
304	313	if "nullreq" in req.get_options():

311	320	cherrypy.engine.start()
312	321	if cherrypy.engine.state == cherrypy._cpengine.STARTING:
313	322	cherrypy.engine.wait()
314		return 0 # apache.OK
	323	return 0 # apache.OK
315	324
316	325
317	326	def run_modpython(use_wsgi=False):
318	327	print("Starting mod_python...")
319	328	pyopts = []
320
	329
321	330	# Pass the null and ab=path options through Apache
322	331	if "--null" in opts:
323	332	pyopts.append(("nullreq", ""))
324
	333
325	334	if "--ab" in opts:
326	335	pyopts.append(("ab", opts["--ab"]))
327
	336
328	337	s = _cpmodpy.ModPythonServer
329	338	if use_wsgi:
330	339	pyopts.append(("wsgi.application", "cherrypy::tree"))
331		pyopts.append(("wsgi.startup", "cherrypy.test.benchmark::startup_modpython"))
	340	pyopts.append(
	341	("wsgi.startup", "cherrypy.test.benchmark::startup_modpython"))
332	342	handler = "modpython_gateway::handler"
333		s = s(port=54583, opts=pyopts, apache_path=APACHE_PATH, handler=handler)
	343	s = s(port=54583, opts=pyopts,
	344	apache_path=APACHE_PATH, handler=handler)
334	345	else:
335		pyopts.append(("cherrypy.setup", "cherrypy.test.benchmark::startup_modpython"))
	346	pyopts.append(
	347	("cherrypy.setup", "cherrypy.test.benchmark::startup_modpython"))
336	348	s = s(port=54583, opts=pyopts, apache_path=APACHE_PATH)
337
	349
338	350	try:
339	351	s.start()
340	352	run()
341	353	finally:
342	354	s.stop()
343
344	355
345	356
346	357	if __name__ == '__main__':

352	363	except getopt.GetoptError:
353	364	print(__doc__)
354	365	sys.exit(2)
355
	366
356	367	if "--help" in opts:
357	368	print(__doc__)
358	369	sys.exit(0)
359
	370
360	371	if "--ab" in opts:
361	372	AB_PATH = opts['--ab']
362
	373
363	374	if "--notests" in opts:
364	375	# Return without stopping the server, so that the pages
365	376	# can be tested from a standard web browser.
366	377	def run():
367	378	port = cherrypy.server.socket_port
368	379	print("You may now open http://127.0.0.1:%s%s/" %
369		(port, SCRIPT_NAME))
370
	380	(port, SCRIPT_NAME))
	381
371	382	if "--null" in opts:
372	383	print("Using null Request object")
373	384	else:

384	395	raise
385	396	finally:
386	397	cherrypy.engine.exit()
387
	398
388	399	print("Starting CherryPy app server...")
389
	400
390	401	class NullWriter(object):
	402
391	403	"""Suppresses the printing of socket errors."""
	404
392	405	def write(self, data):
393	406	pass
394	407	sys.stderr = NullWriter()
395
	408
396	409	start = time.time()
397
	410
398	411	if "--cpmodpy" in opts:
399	412	run_modpython()
400	413	elif "--modpython" in opts:

403	416	if "--null" in opts:
404	417	cherrypy.server.request_class = NullRequest
405	418	cherrypy.server.response_class = NullResponse
406
	419
407	420	cherrypy.engine.start_with_callback(run)
408	421	cherrypy.engine.block()

-3

cherrypy/test/checkerdemo.py less more

8	8	import cherrypy
9	9	thisdir = os.path.dirname(os.path.abspath(__file__))
10	10
	11
11	12	class Root:
12	13	pass
13	14

18	19	},
19	20	# This entry should be OK.
20	21	'/base/static': {'tools.staticdir.on': True,
21		'tools.staticdir.dir': 'static'},
	22	'tools.staticdir.dir': 'static'},
22	23	# Warn on missing folder.
23	24	'/base/js': {'tools.staticdir.on': True,
24		'tools.staticdir.dir': 'js'},
	25	'tools.staticdir.dir': 'js'},
25	26	# Warn on dir with an abs path even though we provide root.
26	27	'/base/static2': {'tools.staticdir.on': True,
27		'tools.staticdir.dir': '/static'},
	28	'tools.staticdir.dir': '/static'},
28	29	# Warn on dir with a relative path with no root.
29	30	'/static3': {'tools.staticdir.on': True,
30	31	'tools.staticdir.dir': 'static'},

+106

-66

cherrypy/test/helper.py less more

18	18	from cherrypy.lib.reprconf import unrepr
19	19	from cherrypy.test import webtest
20	20
	21	# Use subprocess module from Python 2.7 on Python 2.3-2.6
	22	if sys.version_info < (2, 7):
	23	import cherrypy._cpcompat_subprocess as subprocess
	24	else:
	25	import subprocess
	26
21	27	import nose
22	28
23	29	_testconfig = None
24	30
25		def get_tst_config(overconf = {}):
	31
	32	def get_tst_config(overconf={}):
26	33	global _testconfig
27	34	if _testconfig is None:
28	35	conf = {

50	57
51	58	return conf
52	59
	60
53	61	class Supervisor(object):
	62
54	63	"""Base class for modeling and controlling servers during testing."""
55	64
56	65	def __init__(self, **kwargs):

62	71
63	72	log_to_stderr = lambda msg, level: sys.stderr.write(msg + os.linesep)
64	73
	74
65	75	class LocalSupervisor(Supervisor):
66		"""Base class for modeling/controlling servers which run in the same process.
	76
	77	"""Base class for modeling/controlling servers which run in the same
	78	process.
67	79
68	80	When the server side runs in a different process, start/stop can dump all
69	81	state between each test module easily. When the server side runs in the
70		same process as the client, however, we have to do a bit more work to ensure
71		config and mounted apps are reset between tests.
	82	same process as the client, however, we have to do a bit more work to
	83	ensure config and mounted apps are reset between tests.
72	84	"""
73	85
74	86	using_apache = False

109	121	td = getattr(self, 'teardown', None)
110	122	if td:
111	123	td()
112
	124
113	125	cherrypy.engine.exit()
114
	126
115	127	for name, server in copyitems(getattr(cherrypy, 'servers', {})):
116	128	server.unsubscribe()
117	129	del cherrypy.servers[name]
118	130
119	131
120	132	class NativeServerSupervisor(LocalSupervisor):
	133
121	134	"""Server supervisor for the builtin HTTP server."""
122	135
123	136	httpserver_class = "cherrypy._cpnative_server.CPHTTPServer"

129	142
130	143
131	144	class LocalWSGISupervisor(LocalSupervisor):
	145
132	146	"""Server supervisor for the builtin WSGI server."""
133	147
134	148	httpserver_class = "cherrypy._cpwsgi_server.CPWSGIServer"

146	160	"""Obtain a new (decorated) WSGI app to hook into the origin server."""
147	161	if app is None:
148	162	app = cherrypy.tree
149
	163
150	164	if self.conquer:
151	165	try:
152	166	import wsgiconq
153	167	except ImportError:
154		warnings.warn("Error importing wsgiconq. pyconquer will not run.")
	168	warnings.warn(
	169	"Error importing wsgiconq. pyconquer will not run.")
155	170	else:
156	171	app = wsgiconq.WSGILogger(app, c_calls=True)
157
	172
158	173	if self.validate:
159	174	try:
160	175	from wsgiref import validate
161	176	except ImportError:
162		warnings.warn("Error importing wsgiref. The validator will not run.")
	177	warnings.warn(
	178	"Error importing wsgiref. The validator will not run.")
163	179	else:
164		#wraps the app in the validator
	180	# wraps the app in the validator
165	181	app = validate.validator(app)
166
	182
167	183	return app
168	184
169	185

172	188	sup = modpy.ModPythonSupervisor(**options)
173	189	sup.template = modpy.conf_cpmodpy
174	190	return sup
	191
175	192
176	193	def get_modpygw_supervisor(**options):
177	194	from cherrypy.test import modpy

180	197	sup.using_wsgi = True
181	198	return sup
182	199
	200
183	201	def get_modwsgi_supervisor(**options):
184	202	from cherrypy.test import modwsgi
185	203	return modwsgi.ModWSGISupervisor(**options)
186	204
	205
187	206	def get_modfcgid_supervisor(**options):
188	207	from cherrypy.test import modfcgid
189	208	return modfcgid.ModFCGISupervisor(**options)
190	209
	210
191	211	def get_modfastcgi_supervisor(**options):
192	212	from cherrypy.test import modfastcgi
193	213	return modfastcgi.ModFCGISupervisor(**options)
194	214
	215
195	216	def get_wsgi_u_supervisor(**options):
196	217	cherrypy.server.wsgi_version = ('u', 0)
197	218	return LocalWSGISupervisor(**options)
198	219
199	220
200	221	class CPWebCase(webtest.WebCase):
201
	222
202	223	script_name = ""
203	224	scheme = "http"
204	225

212	233	'modfastcgi': get_modfastcgi_supervisor,
213	234	}
214	235	default_server = "wsgi"
215
	236
216	237	def _setup_server(cls, supervisor, conf):
217	238	v = sys.version.split()[0]
218	239	log.info("Python version used to run this test script: %s" % v)

256	277	webtest.WebCase.HTTP_CONN = HTTPSConnection
257	278	return baseconf
258	279	_setup_server = classmethod(_setup_server)
259
	280
260	281	def setup_class(cls):
261	282	''
262		#Creates a server
	283	# Creates a server
263	284	conf = get_tst_config()
264		supervisor_factory = cls.available_servers.get(conf.get('server', 'wsgi'))
	285	supervisor_factory = cls.available_servers.get(
	286	conf.get('server', 'wsgi'))
265	287	if supervisor_factory is None:
266	288	raise RuntimeError('Unknown server in config: %s' % conf['server'])
267	289	supervisor = supervisor_factory(**conf)
268	290
269		#Copied from "run_test_suite"
	291	# Copied from "run_test_suite"
270	292	cherrypy.config.reset()
271	293	baseconf = cls._setup_server(supervisor, conf)
272	294	cherrypy.config.update(baseconf)

292	314	if hasattr(cls, 'setup_server'):
293	315	cls.supervisor.stop()
294	316	teardown_class = classmethod(teardown_class)
295
	317
296	318	do_gc_test = False
297
	319
298	320	def test_gc(self):
299	321	if self.do_gc_test:
300	322	self.getPage("/gc/stats")
301	323	self.assertBody("Statistics:")
302	324	# Tell nose to run this last in each class.
303	325	# Prefer sys.maxint for Python 2.3, which didn't have float('inf')
304		test_gc.compat_co_firstlineno = getattr(sys, 'maxint', None) or float('inf')
305
	326	test_gc.compat_co_firstlineno = getattr(
	327	sys, 'maxint', None) or float('inf')
	328
306	329	def prefix(self):
307	330	return self.script_name.rstrip("/")
308
	331
309	332	def base(self):
310	333	if ((self.scheme == "http" and self.PORT == 80) or
311		(self.scheme == "https" and self.PORT == 443)):
	334	(self.scheme == "https" and self.PORT == 443)):
312	335	port = ""
313	336	else:
314	337	port = ":%s" % self.PORT
315
	338
316	339	return "%s://%s%s%s" % (self.scheme, self.HOST, port,
317	340	self.script_name.rstrip("/"))
318
	341
319	342	def exit(self):
320	343	sys.exit()
321
322		def getPage(self, url, headers=None, method="GET", body=None, protocol=None):
	344
	345	def getPage(self, url, headers=None, method="GET", body=None,
	346	protocol=None):
323	347	"""Open the url. Return status, headers, body."""
324	348	if self.script_name:
325	349	url = httputil.urljoin(self.script_name, url)
326		return webtest.WebCase.getPage(self, url, headers, method, body, protocol)
327
	350	return webtest.WebCase.getPage(self, url, headers, method, body,
	351	protocol)
	352
328	353	def skip(self, msg='skipped '):
329	354	raise nose.SkipTest(msg)
330
	355
331	356	def assertErrorPage(self, status, message=None, pattern=''):
332	357	"""Compare the response body with a built in error page.
333
	358
334	359	The function will optionally look for the regexp pattern,
335	360	within the exception embedded in the error page."""
336
	361
337	362	# This will never contain a traceback
338	363	page = cherrypy._cperror.get_error_page(status, message=message)
339
	364
340	365	# First, test the response body without checking the traceback.
341	366	# Stick a match-all group (.*) in to grab the traceback.
342		esc = re.escape
343		epage = esc(page)
344		epage = epage.replace(esc('<pre id="traceback"></pre>'),
345		esc('<pre id="traceback">') + '(.*)' + esc('</pre>'))
346		m = re.match(ntob(epage, self.encoding), self.body, re.DOTALL)
	367	def esc(text):
	368	return re.escape(ntob(text))
	369	epage = re.escape(page)
	370	epage = epage.replace(
	371	esc('<pre id="traceback"></pre>'),
	372	esc('<pre id="traceback">') + ntob('(.*)') + esc('</pre>'))
	373	m = re.match(epage, self.body, re.DOTALL)
347	374	if not m:
348		self._handlewebError('Error page does not match; expected:\n' + page)
	375	self._handlewebError(
	376	'Error page does not match; expected:\n' + page)
349	377	return
350
	378
351	379	# Now test the pattern against the traceback
352	380	if pattern is None:
353	381	# Special-case None to mean that there should be no traceback.

359	387	m.group(1))):
360	388	msg = 'Error page does not contain %s in traceback'
361	389	self._handlewebError(msg % repr(pattern))
362
	390
363	391	date_tolerance = 2
364
	392
365	393	def assertEqualDates(self, dt1, dt2, seconds=None):
366	394	"""Assert abs(dt1 - dt2) is within Y seconds."""
367	395	if seconds is None:
368	396	seconds = self.date_tolerance
369
	397
370	398	if dt1 > dt2:
371	399	diff = dt1 - dt2
372	400	else:

387	415
388	416
389	417	class CPProcess(object):
390
	418
391	419	pid_file = os.path.join(thisdir, 'test.pid')
392	420	config_file = os.path.join(thisdir, 'test.conf')
393	421	config_template = """[global]

402	430	"""
403	431	error_log = os.path.join(thisdir, 'test.error.log')
404	432	access_log = os.path.join(thisdir, 'test.access.log')
405
406		def __init__(self, wait=False, daemonize=False, ssl=False, socket_host=None, socket_port=None):
	433
	434	def __init__(self, wait=False, daemonize=False, ssl=False,
	435	socket_host=None, socket_port=None):
407	436	self.wait = wait
408	437	self.daemonize = daemonize
409	438	self.ssl = ssl
410	439	self.host = socket_host or cherrypy.server.socket_host
411	440	self.port = socket_port or cherrypy.server.socket_port
412
	441
413	442	def write_conf(self, extra=""):
414	443	if self.ssl:
415	444	serverpem = os.path.join(thisdir, 'test.pem')

419	448	""" % (serverpem, serverpem)
420	449	else:
421	450	ssl = ""
422
	451
423	452	conf = self.config_template % {
424	453	'host': self.host,
425	454	'port': self.port,

427	456	'access_log': self.access_log,
428	457	'ssl': ssl,
429	458	'extra': extra,
430		}
	459	}
431	460	f = open(self.config_file, 'wb')
432	461	f.write(ntob(conf, 'utf-8'))
433	462	f.close()
434
	463
435	464	def start(self, imports=None):
436	465	"""Start cherryd in a subprocess."""
437	466	cherrypy._cpserver.wait_for_free_port(self.host, self.port)
438
439		args = [sys.executable, os.path.join(thisdir, '..', 'cherryd'),
440		'-c', self.config_file, '-p', self.pid_file]
441
	467
	468	args = [
	469	os.path.join(thisdir, '..', 'cherryd'),
	470	'-c', self.config_file,
	471	'-p', self.pid_file,
	472	]
	473
442	474	if not isinstance(imports, (list, tuple)):
443	475	imports = [imports]
444	476	for i in imports:
445	477	if i:
446	478	args.append('-i')
447	479	args.append(i)
448
	480
449	481	if self.daemonize:
450	482	args.append('-d')
451	483
452	484	env = os.environ.copy()
453		# Make sure we import the cherrypy package in which this module is defined.
	485	# Make sure we import the cherrypy package in which this module is
	486	# defined.
454	487	grandparentdir = os.path.abspath(os.path.join(thisdir, '..', '..'))
455	488	if env.get('PYTHONPATH', ''):
456		env['PYTHONPATH'] = os.pathsep.join((grandparentdir, env['PYTHONPATH']))
	489	env['PYTHONPATH'] = os.pathsep.join(
	490	(grandparentdir, env['PYTHONPATH']))
457	491	else:
458	492	env['PYTHONPATH'] = grandparentdir
	493	self._proc = subprocess.Popen([sys.executable] + args, env=env)
459	494	if self.wait:
460		self.exit_code = os.spawnve(os.P_WAIT, sys.executable, args, env)
461		else:
462		os.spawnve(os.P_NOWAIT, sys.executable, args, env)
	495	self.exit_code = self._proc.wait()
	496	else:
463	497	cherrypy._cpserver.wait_for_occupied_port(self.host, self.port)
464
	498
465	499	# Give the engine a wee bit more time to finish STARTING
466	500	if self.daemonize:
467	501	time.sleep(2)
468	502	else:
469	503	time.sleep(1)
470
	504
471	505	def get_pid(self):
472		return int(open(self.pid_file, 'rb').read())
473
	506	if self.daemonize:
	507	return int(open(self.pid_file, 'rb').read())
	508	return self._proc.pid
	509
474	510	def join(self):
475	511	"""Wait for the process to exit."""
	512	if self.daemonize:
	513	return self._join_daemon()
	514	self._proc.wait()
	515
	516	def _join_daemon(self):
476	517	try:
477	518	try:
478	519	# Mac, UNIX

490	531	x = sys.exc_info()[1]
491	532	if x.args != (10, 'No child processes'):
492	533	raise
493

+40

-29

cherrypy/test/logtest.py less more

9	9	try:
10	10	# On Windows, msvcrt.getch reads a single char without output.
11	11	import msvcrt
	12
12	13	def getchar():
13	14	return msvcrt.getch()
14	15	except ImportError:
15	16	# Unix getchr
16		import tty, termios
	17	import tty
	18	import termios
	19
17	20	def getchar():
18	21	fd = sys.stdin.fileno()
19	22	old_settings = termios.tcgetattr(fd)

26	29
27	30
28	31	class LogCase(object):
	32
29	33	"""unittest.TestCase mixin for testing log messages.
30
	34
31	35	logfile: a filename for the desired log. Yes, I know modes are evil,
32	36	but it makes the test functions so much cleaner to set this once.
33
	37
34	38	lastmarker: the last marker in the log. This can be used to search for
35	39	messages since the last marker.
36
	40
37	41	markerPrefix: a string with which to prefix log markers. This should be
38	42	unique enough from normal log output to use for marker identification.
39	43	"""
40
	44
41	45	logfile = None
42	46	lastmarker = None
43	47	markerPrefix = ntob("test suite marker: ")
44
	48
45	49	def _handleLogError(self, msg, data, marker, pattern):
46	50	print("")
47	51	print(" ERROR: %s" % msg)
48
	52
49	53	if not self.interactive:
50	54	raise self.failureException(msg)
51
52		p = " Show: [L]og [M]arker [P]attern; [I]gnore, [R]aise, or sys.e[X]it >> "
	55
	56	p = (" Show: "
	57	"[L]og [M]arker [P]attern; "
	58	"[I]gnore, [R]aise, or sys.e[X]it >> ")
53	59	sys.stdout.write(p + ' ')
54	60	# ARGH
55	61	sys.stdout.flush()

81	87	elif i == "X":
82	88	self.exit()
83	89	sys.stdout.write(p + ' ')
84
	90
85	91	def exit(self):
86	92	sys.exit()
87
	93
88	94	def emptyLog(self):
89	95	"""Overwrite self.logfile with 0 bytes."""
90	96	open(self.logfile, 'wb').write("")
91
	97
92	98	def markLog(self, key=None):
93	99	"""Insert a marker line into the log and set self.lastmarker."""
94	100	if key is None:
95	101	key = str(time.time())
96	102	self.lastmarker = key
97
98		open(self.logfile, 'ab+').write(ntob("%s%s\n" % (self.markerPrefix, key),"utf-8"))
99
	103
	104	open(self.logfile, 'ab+').write(
	105	ntob("%s%s\n" % (self.markerPrefix, key), "utf-8"))
	106
100	107	def _read_marked_region(self, marker=None):
101	108	"""Return lines from self.logfile in the marked region.
102
	109
103	110	If marker is None, self.lastmarker is used. If the log hasn't
104	111	been marked (using self.markLog), the entire log will be returned.
105	112	"""
106		## # Give the logger time to finish writing?
107		## time.sleep(0.5)
108
	113	# Give the logger time to finish writing?
	114	# time.sleep(0.5)
	115
109	116	logfile = self.logfile
110	117	marker = marker or self.lastmarker
111	118	if marker is None:
112	119	return open(logfile, 'rb').readlines()
113
	120
114	121	if isinstance(marker, unicodestr):
115	122	marker = marker.encode('utf-8')
116	123	data = []

124	131	elif marker in line:
125	132	in_region = True
126	133	return data
127
	134
128	135	def assertInLog(self, line, marker=None):
129	136	"""Fail if the given (partial) line is not in the log.
130
	137
131	138	The log will be searched from the given marker to the next marker.
132	139	If marker is None, self.lastmarker is used. If the log hasn't
133	140	been marked (using self.markLog), the entire log will be searched.

138	145	return
139	146	msg = "%r not found in log" % line
140	147	self._handleLogError(msg, data, marker, line)
141
	148
142	149	def assertNotInLog(self, line, marker=None):
143	150	"""Fail if the given (partial) line is in the log.
144
	151
145	152	The log will be searched from the given marker to the next marker.
146	153	If marker is None, self.lastmarker is used. If the log hasn't
147	154	been marked (using self.markLog), the entire log will be searched.

151	158	if line in logline:
152	159	msg = "%r found in log" % line
153	160	self._handleLogError(msg, data, marker, line)
154
	161
155	162	def assertLog(self, sliceargs, lines, marker=None):
156	163	"""Fail if log.readlines()[sliceargs] is not contained in 'lines'.
157
	164
158	165	The log will be searched from the given marker to the next marker.
159	166	If marker is None, self.lastmarker is used. If the log hasn't
160	167	been marked (using self.markLog), the entire log will be searched.

168	175	lines = lines.encode('utf-8')
169	176	if lines not in data[sliceargs]:
170	177	msg = "%r not found on log line %r" % (lines, sliceargs)
171		self._handleLogError(msg, [data[sliceargs],"--EXTRA CONTEXT--"] + data[sliceargs+1:sliceargs+6], marker, lines)
	178	self._handleLogError(
	179	msg,
	180	[data[sliceargs], "--EXTRA CONTEXT--"] + data[
	181	sliceargs + 1:sliceargs + 6],
	182	marker,
	183	lines)
172	184	else:
173	185	# Multiple args. Use __getslice__ and require lines to be list.
174	186	if isinstance(lines, tuple):

176	188	elif isinstance(lines, basestring):
177	189	raise TypeError("The 'lines' arg must be a list when "
178	190	"'sliceargs' is a tuple.")
179
	191
180	192	start, stop = sliceargs
181	193	for line, logline in zip(lines, data[start:stop]):
182	194	if isinstance(line, unicodestr):

184	196	if line not in logline:
185	197	msg = "%r not found in log" % line
186	198	self._handleLogError(msg, data[start:stop], marker, line)
187

+12

-10

cherrypy/test/modfastcgi.py less more

79	79	FastCgiExternalServer "%(server)s" -host 127.0.0.1:4000
80	80	"""
81	81
	82
82	83	def erase_script_name(environ, start_response):
83	84	environ['SCRIPT_NAME'] = ''
84	85	return cherrypy.tree(environ, start_response)
85	86
	87
86	88	class ModFCGISupervisor(helper.LocalWSGISupervisor):
87
	89
88	90	httpserver_class = "cherrypy.process.servers.FlupFCGIServer"
89	91	using_apache = True
90	92	using_wsgi = True
91	93	template = conf_fastcgi
92
	94
93	95	def __str__(self):
94	96	return "FCGI Server on %s:%s" % (self.host, self.port)
95
	97
96	98	def start(self, modulename):
97	99	cherrypy.server.httpserver = servers.FlupFCGIServer(
98	100	application=erase_script_name, bindAddress=('127.0.0.1', 4000))

103	105	# ...and our local server
104	106	cherrypy.engine.start()
105	107	self.sync_apps()
106
	108
107	109	def start_apache(self):
108	110	fcgiconf = CONF_PATH
109	111	if not os.path.isabs(fcgiconf):
110	112	fcgiconf = os.path.join(curdir, fcgiconf)
111
	113
112	114	# Write the Apache conf file.
113	115	f = open(fcgiconf, 'wb')
114	116	try:

119	121	f.write(output)
120	122	finally:
121	123	f.close()
122
	124
123	125	result = read_process(APACHE_PATH, "-k start -f %s" % fcgiconf)
124	126	if result:
125	127	print(result)
126
	128
127	129	def stop(self):
128	130	"""Gracefully shutdown a server that is serving forever."""
129	131	read_process(APACHE_PATH, "-k stop")
130	132	helper.LocalWSGISupervisor.stop(self)
131
	133
132	134	def sync_apps(self):
133		cherrypy.server.httpserver.fcgiserver.application = self.get_app(erase_script_name)
134
	135	cherrypy.server.httpserver.fcgiserver.application = self.get_app(
	136	erase_script_name)

-9

cherrypy/test/modfcgid.py less more

76	76	FastCgiExternalServer "%(server)s" -host 127.0.0.1:4000
77	77	"""
78	78
	79
79	80	class ModFCGISupervisor(helper.LocalSupervisor):
80
	81
81	82	using_apache = True
82	83	using_wsgi = True
83	84	template = conf_fcgid
84
	85
85	86	def __str__(self):
86	87	return "FCGI Server on %s:%s" % (self.host, self.port)
87
	88
88	89	def start(self, modulename):
89	90	cherrypy.server.httpserver = servers.FlupFCGIServer(
90	91	application=cherrypy.tree, bindAddress=('127.0.0.1', 4000))

93	94	self.start_apache()
94	95	# ...and our local server
95	96	helper.LocalServer.start(self, modulename)
96
	97
97	98	def start_apache(self):
98	99	fcgiconf = CONF_PATH
99	100	if not os.path.isabs(fcgiconf):
100	101	fcgiconf = os.path.join(curdir, fcgiconf)
101
	102
102	103	# Write the Apache conf file.
103	104	f = open(fcgiconf, 'wb')
104	105	try:

109	110	f.write(output)
110	111	finally:
111	112	f.close()
112
	113
113	114	result = read_process(APACHE_PATH, "-k start -f %s" % fcgiconf)
114	115	if result:
115	116	print(result)
116
	117
117	118	def stop(self):
118	119	"""Gracefully shutdown a server that is serving forever."""
119	120	read_process(APACHE_PATH, "-k stop")
120	121	helper.LocalServer.stop(self)
121
	122
122	123	def sync_apps(self):
123	124	cherrypy.server.httpserver.fcgiserver.application = self.get_app()
124

+15

-13

cherrypy/test/modpy.py less more

90	90	PythonDebug On
91	91	"""
92	92
	93
93	94	class ModPythonSupervisor(helper.Supervisor):
94
	95
95	96	using_apache = True
96	97	using_wsgi = False
97	98	template = None
98
	99
99	100	def __str__(self):
100	101	return "ModPython Server on %s:%s" % (self.host, self.port)
101
	102
102	103	def start(self, modulename):
103	104	mpconf = CONF_PATH
104	105	if not os.path.isabs(mpconf):
105	106	mpconf = os.path.join(curdir, mpconf)
106
	107
107	108	f = open(mpconf, 'wb')
108	109	try:
109	110	f.write(self.template %

111	112	'host': self.host})
112	113	finally:
113	114	f.close()
114
	115
115	116	result = read_process(APACHE_PATH, "-k start -f %s" % mpconf)
116	117	if result:
117	118	print(result)
118
	119
119	120	def stop(self):
120	121	"""Gracefully shutdown a server that is serving forever."""
121	122	read_process(APACHE_PATH, "-k stop")
122	123
123	124
124	125	loaded = False
	126
	127
125	128	def wsgisetup(req):
126	129	global loaded
127	130	if not loaded:
128	131	loaded = True
129	132	options = req.get_options()
130
	133
131	134	import cherrypy
132	135	cherrypy.config.update({
133	136	"log.error_file": os.path.join(curdir, "test.log"),
134	137	"environment": "test_suite",
135	138	"server.socket_host": options['socket_host'],
136		})
137
	139	})
	140
138	141	modname = options['testmod']
139	142	mod = __import__(modname, globals(), locals(), [''])
140	143	mod.setup_server()
141
	144
142	145	cherrypy.server.unsubscribe()
143	146	cherrypy.engine.start()
144	147	from mod_python import apache

150	153	if not loaded:
151	154	loaded = True
152	155	options = req.get_options()
153
	156
154	157	import cherrypy
155	158	cherrypy.config.update({
156	159	"log.error_file": os.path.join(curdir, "test.log"),
157	160	"environment": "test_suite",
158	161	"server.socket_host": options['socket_host'],
159		})
	162	})
160	163	from mod_python import apache
161	164	return apache.OK
162

+13

-11

cherrypy/test/modwsgi.py less more

88	88
89	89
90	90	class ModWSGISupervisor(helper.Supervisor):
	91
91	92	"""Server Controller for ModWSGI and CherryPy."""
92
	93
93	94	using_apache = True
94	95	using_wsgi = True
95		template=conf_modwsgi
96
	96	template = conf_modwsgi
	97
97	98	def __str__(self):
98	99	return "ModWSGI Server on %s:%s" % (self.host, self.port)
99
	100
100	101	def start(self, modulename):
101	102	mpconf = CONF_PATH
102	103	if not os.path.isabs(mpconf):
103	104	mpconf = os.path.join(curdir, mpconf)
104
	105
105	106	f = open(mpconf, 'wb')
106	107	try:
107	108	output = (self.template %

110	111	f.write(output)
111	112	finally:
112	113	f.close()
113
	114
114	115	result = read_process(APACHE_PATH, "-k start -f %s" % mpconf)
115	116	if result:
116	117	print(result)
117
	118
118	119	# Make a request so mod_wsgi starts up our app.
119	120	# If we don't, concurrent initial requests will 404.
120	121	cherrypy._cpserver.wait_for_occupied_port("127.0.0.1", self.port)
121	122	webtest.openURL('/ihopetheresnodefault', port=self.port)
122	123	time.sleep(1)
123
	124
124	125	def stop(self):
125	126	"""Gracefully shutdown a server that is serving forever."""
126	127	read_process(APACHE_PATH, "-k stop")
127	128
128	129
129	130	loaded = False
	131
	132
130	133	def application(environ, start_response):
131	134	import cherrypy
132	135	global loaded

135	138	modname = "cherrypy.test." + environ['testmod']
136	139	mod = __import__(modname, globals(), locals(), [''])
137	140	mod.setup_server()
138
	141
139	142	cherrypy.config.update({
140	143	"log.error_file": os.path.join(curdir, "test.error.log"),
141	144	"log.access_file": os.path.join(curdir, "test.access.log"),
142	145	"environment": "test_suite",
143	146	"engine.SIGHUP": None,
144	147	"engine.SIGTERM": None,
145		})
	148	})
146	149	return cherrypy.tree(environ, start_response)
147

+22

-17

cherrypy/test/sessiondemo.py less more

14	14	<style type='text/css'>
15	15	table { border-collapse: collapse; border: 1px solid #663333; }
16	16	th { text-align: right; background-color: #663333; color: white; padding: 0.5em; }
17		td { white-space: pre-wrap; font-family: monospace; padding: 0.5em;
	17	td { white-space: pre-wrap; font-family: monospace; padding: 0.5em;
18	18	border: 1px solid #663333; }
19	19	.warn { font-family: serif; color: #990000; }
20	20	</style>

50	50	// Set the content of the 'btime' cell.
51	51	var currentTime = new Date();
52	52	var bunixtime = Math.floor(currentTime.getTime() / 1000);
53
	53
54	54	var v = formattime(currentTime);
55	55	v += " (Unix time: " + bunixtime + ")";
56
	56
57	57	var diff = Math.abs(%(serverunixtime)s - bunixtime);
58	58	if (diff > fudge_seconds) v += "<p class='warn'>Browser and Server times disagree.</p>";
59
	59
60	60	document.getElementById('btime').innerHTML = v;
61
	61
62	62	// Warn if response cookie expires is not close to one hour in the future.
63	63	// Yes, we want this to happen when wit hit the 'Expire' link, too.
64	64	var expires = Date.parse("%(expires)s") / 1000;

94	94	</body></html>
95	95	"""
96	96
	97
97	98	class Root(object):
98
	99
99	100	def page(self):
100	101	changemsg = []
101	102	if cherrypy.session.id != cherrypy.session.originalid:
102	103	if cherrypy.session.originalid is None:
103		changemsg.append('Created new session because no session id was given.')
	104	changemsg.append(
	105	'Created new session because no session id was given.')
104	106	if cherrypy.session.missing:
105		changemsg.append('Created new session due to missing (expired or malicious) session.')
	107	changemsg.append(
	108	'Created new session due to missing '
	109	'(expired or malicious) session.')
106	110	if cherrypy.session.regenerated:
107	111	changemsg.append('Application generated a new session.')
108
	112
109	113	try:
110	114	expires = cherrypy.response.cookie['session_id']['expires']
111	115	except KeyError:
112	116	expires = ''
113
	117
114	118	return page % {
115	119	'sessionid': cherrypy.session.id,
116	120	'changemsg': '<br>'.join(changemsg),
117	121	'respcookie': cherrypy.response.cookie.output(),
118	122	'reqcookie': cherrypy.request.cookie.output(),
119	123	'sessiondata': copyitems(cherrypy.session),
120		'servertime': datetime.utcnow().strftime("%Y/%m/%d %H:%M") + " UTC",
	124	'servertime': (
	125	datetime.utcnow().strftime("%Y/%m/%d %H:%M") + " UTC"
	126	),
121	127	'serverunixtime': calendar.timegm(datetime.utcnow().timetuple()),
122	128	'cpversion': cherrypy.__version__,
123	129	'pyversion': sys.version,
124	130	'expires': expires,
125		}
126
	131	}
	132
127	133	def index(self):
128	134	# Must modify data or the session will not be saved.
129	135	cherrypy.session['color'] = 'green'
130	136	return self.page()
131	137	index.exposed = True
132
	138
133	139	def expire(self):
134	140	sessions.expire()
135	141	return self.page()
136	142	expire.exposed = True
137
	143
138	144	def regen(self):
139	145	cherrypy.session.regenerate()
140	146	# Must modify data or the session will not be saved.

147	153	#'environment': 'production',
148	154	'log.screen': True,
149	155	'tools.sessions.on': True,
150		})
	156	})
151	157	cherrypy.quickstart(Root())
152

-0

cherrypy/test/static/404.html less more

	0	<html>
	1	<body>
	2	<h1>I couldn't find that thing you were looking for!</h1>
	3	</body>
	4	</html>

-1

~~cherrypy/test/static/has space.html~~ less more

Hello, world

+30

-16

cherrypy/test/test_auth_basic.py less more

11	11
12	12	def setup_server():
13	13	class Root:
	14
14	15	def index(self):
15	16	return "This is public."
16	17	index.exposed = True
17	18
18	19	class BasicProtected:
	20
19	21	def index(self):
20		return "Hello %s, you've been authorized." % cherrypy.request.login
	22	return "Hello %s, you've been authorized." % (
	23	cherrypy.request.login)
21	24	index.exposed = True
22	25
23	26	class BasicProtected2:
	27
24	28	def index(self):
25		return "Hello %s, you've been authorized." % cherrypy.request.login
	29	return "Hello %s, you've been authorized." % (
	30	cherrypy.request.login)
26	31	index.exposed = True
27	32
28		userpassdict = {'xuser' : 'xpassword'}
29		userhashdict = {'xuser' : md5(ntob('xpassword')).hexdigest()}
	33	userpassdict = {'xuser': 'xpassword'}
	34	userhashdict = {'xuser': md5(ntob('xpassword')).hexdigest()}
30	35
31	36	def checkpasshash(realm, user, password):
32	37	p = userhashdict.get(user)
33	38	return p and p == md5(ntob(password)).hexdigest() or False
34	39
35		conf = {'/basic': {'tools.auth_basic.on': True,
36		'tools.auth_basic.realm': 'wonderland',
37		'tools.auth_basic.checkpassword': auth_basic.checkpassword_dict(userpassdict)},
38		'/basic2': {'tools.auth_basic.on': True,
39		'tools.auth_basic.realm': 'wonderland',
40		'tools.auth_basic.checkpassword': checkpasshash},
41		}
	40	basic_checkpassword_dict = auth_basic.checkpassword_dict(userpassdict)
	41	conf = {
	42	'/basic': {
	43	'tools.auth_basic.on': True,
	44	'tools.auth_basic.realm': 'wonderland',
	45	'tools.auth_basic.checkpassword': basic_checkpassword_dict
	46	},
	47	'/basic2': {
	48	'tools.auth_basic.on': True,
	49	'tools.auth_basic.realm': 'wonderland',
	50	'tools.auth_basic.checkpassword': checkpasshash
	51	},
	52	}
42	53
43	54	root = Root()
44	55	root.basic = BasicProtected()

57	68	self.assertStatus(401)
58	69	self.assertHeader('WWW-Authenticate', 'Basic realm="wonderland"')
59	70
60		self.getPage('/basic/', [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')])
	71	self.getPage('/basic/',
	72	[('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')])
61	73	self.assertStatus(401)
62	74
63		self.getPage('/basic/', [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')])
	75	self.getPage('/basic/',
	76	[('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')])
64	77	self.assertStatus('200 OK')
65	78	self.assertBody("Hello xuser, you've been authorized.")
66	79

69	82	self.assertStatus(401)
70	83	self.assertHeader('WWW-Authenticate', 'Basic realm="wonderland"')
71	84
72		self.getPage('/basic2/', [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')])
	85	self.getPage('/basic2/',
	86	[('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')])
73	87	self.assertStatus(401)
74	88
75		self.getPage('/basic2/', [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')])
	89	self.getPage('/basic2/',
	90	[('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')])
76	91	self.assertStatus('200 OK')
77	92	self.assertBody("Hello xuser, you've been authorized.")
78

+37

-13

cherrypy/test/test_auth_digest.py less more

7	7
8	8	from cherrypy.test import helper
9	9
	10
10	11	class DigestAuthTest(helper.CPWebCase):
11	12
12	13	def setup_server():
13	14	class Root:
	15
14	16	def index(self):
15	17	return "This is public."
16	18	index.exposed = True
17	19
18	20	class DigestProtected:
	21
19	22	def index(self):
20		return "Hello %s, you've been authorized." % cherrypy.request.login
	23	return "Hello %s, you've been authorized." % (
	24	cherrypy.request.login)
21	25	index.exposed = True
22	26
23	27	def fetch_users():
24	28	return {'test': 'test'}
25
26	29
27	30	get_ha1 = cherrypy.lib.auth_digest.get_ha1_dict_plain(fetch_users())
28	31	conf = {'/digest': {'tools.auth_digest.on': True,

35	38	root.digest = DigestProtected()
36	39	cherrypy.tree.mount(root, config=conf)
37	40	setup_server = staticmethod(setup_server)
38
	41
39	42	def testPublic(self):
40	43	self.getPage("/")
41	44	self.assertStatus('200 OK')

54	57	break
55	58
56	59	if value is None:
57		self._handlewebError("Digest authentification scheme was not found")
	60	self._handlewebError(
	61	"Digest authentification scheme was not found")
58	62
59	63	value = value[7:]
60	64	items = value.split(', ')

69	73	if 'realm' not in tokens:
70	74	self._handlewebError(missing_msg % 'realm')
71	75	elif tokens['realm'] != '"localhost"':
72		self._handlewebError(bad_value_msg % ('realm', '"localhost"', tokens['realm']))
	76	self._handlewebError(bad_value_msg %
	77	('realm', '"localhost"', tokens['realm']))
73	78	if 'nonce' not in tokens:
74	79	self._handlewebError(missing_msg % 'nonce')
75	80	else:

77	82	if 'algorithm' not in tokens:
78	83	self._handlewebError(missing_msg % 'algorithm')
79	84	elif tokens['algorithm'] != '"MD5"':
80		self._handlewebError(bad_value_msg % ('algorithm', '"MD5"', tokens['algorithm']))
	85	self._handlewebError(bad_value_msg %
	86	('algorithm', '"MD5"', tokens['algorithm']))
81	87	if 'qop' not in tokens:
82	88	self._handlewebError(missing_msg % 'qop')
83	89	elif tokens['qop'] != '"auth"':
84		self._handlewebError(bad_value_msg % ('qop', '"auth"', tokens['qop']))
	90	self._handlewebError(bad_value_msg %
	91	('qop', '"auth"', tokens['qop']))
85	92
86		get_ha1 = auth_digest.get_ha1_dict_plain({'test' : 'test'})
	93	get_ha1 = auth_digest.get_ha1_dict_plain({'test': 'test'})
87	94
88	95	# Test user agent response with a wrong value for 'realm'
89		base_auth = 'Digest username="test", realm="wrong realm", nonce="%s", uri="/digest/", algorithm=MD5, response="%s", qop=auth, nc=%s, cnonce="1522e61005789929"'
	96	base_auth = ('Digest username="test", '
	97	'realm="wrong realm", '
	98	'nonce="%s", '
	99	'uri="/digest/", '
	100	'algorithm=MD5, '
	101	'response="%s", '
	102	'qop=auth, '
	103	'nc=%s, '
	104	'cnonce="1522e61005789929"')
90	105
91		auth_header = base_auth % (nonce, '11111111111111111111111111111111', '00000001')
	106	auth_header = base_auth % (
	107	nonce, '11111111111111111111111111111111', '00000001')
92	108	auth = auth_digest.HttpDigestAuthorization(auth_header, 'GET')
93	109	# calculate the response digest
94	110	ha1 = get_ha1(auth.realm, 'test')

99	115	self.assertStatus(401)
100	116
101	117	# Test that must pass
102		base_auth = 'Digest username="test", realm="localhost", nonce="%s", uri="/digest/", algorithm=MD5, response="%s", qop=auth, nc=%s, cnonce="1522e61005789929"'
	118	base_auth = ('Digest username="test", '
	119	'realm="localhost", '
	120	'nonce="%s", '
	121	'uri="/digest/", '
	122	'algorithm=MD5, '
	123	'response="%s", '
	124	'qop=auth, '
	125	'nc=%s, '
	126	'cnonce="1522e61005789929"')
103	127
104		auth_header = base_auth % (nonce, '11111111111111111111111111111111', '00000001')
	128	auth_header = base_auth % (
	129	nonce, '11111111111111111111111111111111', '00000001')
105	130	auth = auth_digest.HttpDigestAuthorization(auth_header, 'GET')
106	131	# calculate the response digest
107	132	ha1 = get_ha1('localhost', 'test')

111	136	self.getPage('/digest/', [('Authorization', auth_header)])
112	137	self.assertStatus('200 OK')
113	138	self.assertBody("Hello test, you've been authorized.")
114

+24

-11

cherrypy/test/test_bus.py less more

23	23
24	24	for channel in b.listeners:
25	25	for index, priority in enumerate([100, 50, 0, 51]):
26		b.subscribe(channel, self.get_listener(channel, index), priority)
	26	b.subscribe(channel,
	27	self.get_listener(channel, index), priority)
27	28
28	29	for channel in b.listeners:
29	30	b.publish(channel)

41	42	custom_listeners = ('hugh', 'louis', 'dewey')
42	43	for channel in custom_listeners:
43	44	for index, priority in enumerate([None, 10, 60, 40]):
44		b.subscribe(channel, self.get_listener(channel, index), priority)
	45	b.subscribe(channel,
	46	self.get_listener(channel, index), priority)
45	47
46	48	for channel in custom_listeners:
47	49	b.publish(channel, 'ah so')
48		expected.extend([msg % (i, channel, 'ah so') for i in (1, 3, 0, 2)])
	50	expected.extend([msg % (i, channel, 'ah so')
	51	for i in (1, 3, 0, 2)])
49	52	b.publish(channel)
50	53	expected.extend([msg % (i, channel, None) for i in (1, 3, 0, 2)])
51	54

73	76
74	77	def log(self, bus):
75	78	self._log_entries = []
	79
76	80	def logit(msg, level):
77	81	self._log_entries.append(msg)
78	82	bus.subscribe('log', logit)

97	101	b.start()
98	102	try:
99	103	# The start method MUST call all 'start' listeners.
100		self.assertEqual(set(self.responses),
101		set([msg % (i, 'start', None) for i in range(num)]))
	104	self.assertEqual(
	105	set(self.responses),
	106	set([msg % (i, 'start', None) for i in range(num)]))
102	107	# The start method MUST move the state to STARTED
103	108	# (or EXITING, if errors occur)
104	109	self.assertEqual(b.state, b.states.STARTED)

139	144	b.graceful()
140	145
141	146	# The graceful method MUST call all 'graceful' listeners.
142		self.assertEqual(set(self.responses),
143		set([msg % (i, 'graceful', None) for i in range(num)]))
	147	self.assertEqual(
	148	set(self.responses),
	149	set([msg % (i, 'graceful', None) for i in range(num)]))
144	150	# The graceful method MUST log its states.
145	151	self.assertLog(['Bus graceful'])
146	152

164	170	# The exit method MUST move the state to EXITING
165	171	self.assertEqual(b.state, b.states.EXITING)
166	172	# The exit method MUST log its states.
167		self.assertLog(['Bus STOPPING', 'Bus STOPPED', 'Bus EXITING', 'Bus EXITED'])
	173	self.assertLog(
	174	['Bus STOPPING', 'Bus STOPPED', 'Bus EXITING', 'Bus EXITED'])
168	175
169	176	def test_wait(self):
170	177	b = wspbus.Bus()

175	182
176	183	for method, states in [('start', [b.states.STARTED]),
177	184	('stop', [b.states.STOPPED]),
178		('start', [b.states.STARTING, b.states.STARTED]),
	185	('start',
	186	[b.states.STARTING, b.states.STARTED]),
179	187	('exit', [b.states.EXITING]),
180	188	]:
181	189	threading.Thread(target=f, args=(method,)).start()

192	200	def f():
193	201	time.sleep(0.2)
194	202	b.exit()
	203
195	204	def g():
196	205	time.sleep(0.4)
197	206	threading.Thread(target=f).start()

203	212
204	213	# The block method MUST wait for the EXITING state.
205	214	self.assertEqual(b.state, b.states.EXITING)
206		# The block method MUST wait for ALL non-main, non-daemon threads to finish.
	215	# The block method MUST wait for ALL non-main, non-daemon threads to
	216	# finish.
207	217	threads = [t for t in threading.enumerate() if not get_daemon(t)]
208	218	self.assertEqual(len(threads), 1)
209		# The last message will mention an indeterminable thread name; ignore it
	219	# The last message will mention an indeterminable thread name; ignore
	220	# it
210	221	self.assertEqual(self._log_entries[:-1],
211	222	['Bus STOPPING', 'Bus STOPPED',
212	223	'Bus EXITING', 'Bus EXITED',

217	228	self.log(b)
218	229	try:
219	230	events = []
	231
220	232	def f(args, *kwargs):
221	233	events.append(("f", args, kwargs))
	234
222	235	def g():
223	236	events.append("g")
224	237	b.subscribe("start", g)

+77

-63

cherrypy/test/test_caching.py less more

11	11	from cherrypy._cpcompat import next, ntob, quote, xrange
12	12	from cherrypy.lib import httputil
13	13
14		gif_bytes = ntob('GIF89a\x01\x00\x01\x00\x82\x00\x01\x99"\x1e\x00\x00\x00\x00\x00'
15		'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
16		'\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x02\x03\x02\x08\t\x00;')
17
	14	gif_bytes = ntob(
	15	'GIF89a\x01\x00\x01\x00\x82\x00\x01\x99"\x1e\x00\x00\x00\x00\x00'
	16	'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
	17	'\x00,\x00\x00\x00\x00\x01\x00\x01\x00\x02\x03\x02\x08\t\x00;'
	18	)
18	19
19	20
20	21	from cherrypy.test import helper
21	22
	23
22	24	class CacheTest(helper.CPWebCase):
23	25
24	26	def setup_server():
25
	27
26	28	class Root:
27
	29
28	30	_cp_config = {'tools.caching.on': True}
29
	31
30	32	def __init__(self):
31	33	self.counter = 0
32	34	self.control_counter = 0
33	35	self.longlock = threading.Lock()
34
	36
35	37	def index(self):
36	38	self.counter += 1
37	39	msg = "visit #%s" % self.counter
38	40	return msg
39	41	index.exposed = True
40
	42
41	43	def control(self):
42	44	self.control_counter += 1
43	45	return "visit #%s" % self.control_counter
44	46	control.exposed = True
45
	47
46	48	def a_gif(self):
47		cherrypy.response.headers['Last-Modified'] = httputil.HTTPDate()
	49	cherrypy.response.headers[
	50	'Last-Modified'] = httputil.HTTPDate()
48	51	return gif_bytes
49	52	a_gif.exposed = True
50
	53
51	54	def long_process(self, seconds='1'):
52	55	try:
53	56	self.longlock.acquire()

56	59	self.longlock.release()
57	60	return 'success!'
58	61	long_process.exposed = True
59
	62
60	63	def clear_cache(self, path):
61	64	cherrypy._cache.store[cherrypy.request.base + path].clear()
62	65	clear_cache.exposed = True
63
	66
64	67	class VaryHeaderCachingServer(object):
65
66		_cp_config = {'tools.caching.on': True,
	68
	69	_cp_config = {
	70	'tools.caching.on': True,
67	71	'tools.response_headers.on': True,
68		'tools.response_headers.headers': [('Vary', 'Our-Varying-Header')],
69		}
70
	72	'tools.response_headers.headers': [
	73	('Vary', 'Our-Varying-Header')
	74	],
	75	}
	76
71	77	def __init__(self):
72	78	self.counter = count(1)
73
	79
74	80	def index(self):
75	81	return "visit #%s" % next(self.counter)
76	82	index.exposed = True
77
	83
78	84	class UnCached(object):
79	85	_cp_config = {'tools.expires.on': True,
80	86	'tools.expires.secs': 60,

103	109	cacheable.exposed = True
104	110
105	111	def specific(self):
106		cherrypy.response.headers['Etag'] = 'need_this_to_make_me_cacheable'
	112	cherrypy.response.headers[
	113	'Etag'] = 'need_this_to_make_me_cacheable'
107	114	return "I am being specific"
108	115	specific.exposed = True
109	116	specific._cp_config = {'tools.expires.secs': 86400}
110	117
111		class Foo(object):pass
112
	118	class Foo(object):
	119	pass
	120
113	121	def wrongtype(self):
114		cherrypy.response.headers['Etag'] = 'need_this_to_make_me_cacheable'
	122	cherrypy.response.headers[
	123	'Etag'] = 'need_this_to_make_me_cacheable'
115	124	return "Woops"
116	125	wrongtype.exposed = True
117	126	wrongtype._cp_config = {'tools.expires.secs': Foo()}
118
	127
119	128	cherrypy.tree.mount(Root())
120	129	cherrypy.tree.mount(UnCached(), "/expires")
121	130	cherrypy.tree.mount(VaryHeaderCachingServer(), "/varying_headers")

133	142	age = int(self.assertHeader("Age"))
134	143	self.assert_(age >= elapsed)
135	144	elapsed = age
136
	145
137	146	# POST, PUT, DELETE should not be cached.
138	147	self.getPage("/", method="POST")
139	148	self.assertBody('visit #2')
140		# Because gzip is turned on, the Vary header should always Vary for content-encoding
	149	# Because gzip is turned on, the Vary header should always Vary for
	150	# content-encoding
141	151	self.assertHeader('Vary', 'Accept-Encoding')
142	152	# The previous request should have invalidated the cache,
143	153	# so this request will recalc the response.

148	158	self.assertBody('visit #3')
149	159	self.getPage("/", method="DELETE")
150	160	self.assertBody('visit #4')
151
	161
152	162	# The previous request should have invalidated the cache,
153	163	# so this request will recalc the response.
154	164	self.getPage("/", method="GET", headers=[('Accept-Encoding', 'gzip')])
155	165	self.assertHeader('Content-Encoding', 'gzip')
156	166	self.assertHeader('Vary')
157		self.assertEqual(cherrypy.lib.encoding.decompress(self.body), ntob("visit #5"))
158
	167	self.assertEqual(
	168	cherrypy.lib.encoding.decompress(self.body), ntob("visit #5"))
	169
159	170	# Now check that a second request gets the gzip header and gzipped body
160	171	# This also tests a bug in 3.0 to 3.0.2 whereby the cached, gzipped
161	172	# response body was being gzipped a second time.
162	173	self.getPage("/", method="GET", headers=[('Accept-Encoding', 'gzip')])
163	174	self.assertHeader('Content-Encoding', 'gzip')
164		self.assertEqual(cherrypy.lib.encoding.decompress(self.body), ntob("visit #5"))
165
	175	self.assertEqual(
	176	cherrypy.lib.encoding.decompress(self.body), ntob("visit #5"))
	177
166	178	# Now check that a third request that doesn't accept gzip
167	179	# skips the cache (because the 'Vary' header denies it).
168	180	self.getPage("/", method="GET")
169	181	self.assertNoHeader('Content-Encoding')
170	182	self.assertBody('visit #6')
171
	183
172	184	def testVaryHeader(self):
173	185	self.getPage("/varying_headers/")
174	186	self.assertStatus("200 OK")
175	187	self.assertHeaderItemValue('Vary', 'Our-Varying-Header')
176	188	self.assertBody('visit #1')
177
	189
178	190	# Now check that different 'Vary'-fields don't evict each other.
179	191	# This test creates 2 requests with different 'Our-Varying-Header'
180	192	# and then tests if the first one still exists.
181		self.getPage("/varying_headers/", headers=[('Our-Varying-Header', 'request 2')])
182		self.assertStatus("200 OK")
183		self.assertBody('visit #2')
184
185		self.getPage("/varying_headers/", headers=[('Our-Varying-Header', 'request 2')])
186		self.assertStatus("200 OK")
187		self.assertBody('visit #2')
188
	193	self.getPage("/varying_headers/",
	194	headers=[('Our-Varying-Header', 'request 2')])
	195	self.assertStatus("200 OK")
	196	self.assertBody('visit #2')
	197
	198	self.getPage("/varying_headers/",
	199	headers=[('Our-Varying-Header', 'request 2')])
	200	self.assertStatus("200 OK")
	201	self.assertBody('visit #2')
	202
189	203	self.getPage("/varying_headers/")
190	204	self.assertStatus("200 OK")
191	205	self.assertBody('visit #1')
192
	206
193	207	def testExpiresTool(self):
194	208	# test setting an expires header
195	209	self.getPage("/expires/specific")
196	210	self.assertStatus("200 OK")
197	211	self.assertHeader("Expires")
198
	212
199	213	# test exceptions for bad time values
200	214	self.getPage("/expires/wrongtype")
201	215	self.assertStatus(500)
202	216	self.assertInBody("TypeError")
203
	217
204	218	# static content should not have "cache prevention" headers
205	219	self.getPage("/expires/index.html")
206	220	self.assertStatus("200 OK")
207	221	self.assertNoHeader("Pragma")
208	222	self.assertNoHeader("Cache-Control")
209	223	self.assertHeader("Expires")
210
	224
211	225	# dynamic content that sets indicators should not have
212	226	# "cache prevention" headers
213	227	self.getPage("/expires/cacheable")

215	229	self.assertNoHeader("Pragma")
216	230	self.assertNoHeader("Cache-Control")
217	231	self.assertHeader("Expires")
218
	232
219	233	self.getPage('/expires/dynamic')
220	234	self.assertBody("D-d-d-dynamic!")
221	235	# the Cache-Control header should be untouched
222	236	self.assertHeader("Cache-Control", "private")
223	237	self.assertHeader("Expires")
224
	238
225	239	# configure the tool to ignore indicators and replace existing headers
226	240	self.getPage("/expires/force")
227	241	self.assertStatus("200 OK")

230	244	if cherrypy.server.protocol_version == "HTTP/1.1":
231	245	self.assertHeader("Cache-Control", "no-cache, must-revalidate")
232	246	self.assertHeader("Expires", "Sun, 28 Jan 2007 00:00:00 GMT")
233
	247
234	248	# static content should now have "cache prevention" headers
235	249	self.getPage("/expires/index.html")
236	250	self.assertStatus("200 OK")

238	252	if cherrypy.server.protocol_version == "HTTP/1.1":
239	253	self.assertHeader("Cache-Control", "no-cache, must-revalidate")
240	254	self.assertHeader("Expires", "Sun, 28 Jan 2007 00:00:00 GMT")
241
	255
242	256	# the cacheable handler should now have "cache prevention" headers
243	257	self.getPage("/expires/cacheable")
244	258	self.assertStatus("200 OK")

246	260	if cherrypy.server.protocol_version == "HTTP/1.1":
247	261	self.assertHeader("Cache-Control", "no-cache, must-revalidate")
248	262	self.assertHeader("Expires", "Sun, 28 Jan 2007 00:00:00 GMT")
249
	263
250	264	self.getPage('/expires/dynamic')
251	265	self.assertBody("D-d-d-dynamic!")
252	266	# dynamic sets Cache-Control to private but it should be

255	269	if cherrypy.server.protocol_version == "HTTP/1.1":
256	270	self.assertHeader("Cache-Control", "no-cache, must-revalidate")
257	271	self.assertHeader("Expires", "Sun, 28 Jan 2007 00:00:00 GMT")
258
	272
259	273	def testLastModified(self):
260	274	self.getPage("/a.gif")
261	275	self.assertStatus(200)
262	276	self.assertBody(gif_bytes)
263	277	lm1 = self.assertHeader("Last-Modified")
264
	278
265	279	# this request should get the cached copy.
266	280	self.getPage("/a.gif")
267	281	self.assertStatus(200)

269	283	self.assertHeader("Age")
270	284	lm2 = self.assertHeader("Last-Modified")
271	285	self.assertEqual(lm1, lm2)
272
	286
273	287	# this request should match the cached copy, but raise 304.
274	288	self.getPage("/a.gif", [('If-Modified-Since', lm1)])
275	289	self.assertStatus(304)
276	290	self.assertNoHeader("Last-Modified")
277	291	if not getattr(cherrypy.server, "using_apache", False):
278	292	self.assertHeader("Age")
279
	293
280	294	def test_antistampede(self):
281	295	SECONDS = 4
282	296	# We MUST make an initial synchronous request in order to create the

285	299	self.getPage("/long_process?seconds=%d" % SECONDS)
286	300	self.assertBody('success!')
287	301	self.getPage("/clear_cache?path=" +
288		quote('/long_process?seconds=%d' % SECONDS, safe=''))
	302	quote('/long_process?seconds=%d' % SECONDS, safe=''))
289	303	self.assertStatus(200)
290
	304
291	305	start = datetime.datetime.now()
	306
292	307	def run():
293	308	self.getPage("/long_process?seconds=%d" % SECONDS)
294	309	# The response should be the same every time

302	317	# Allow a second (two, for slow hosts)
303	318	# for our thread/TCP overhead etc.
304	319	seconds=SECONDS + 2)
305
	320
306	321	def test_cache_control(self):
307	322	self.getPage("/control")
308	323	self.assertBody('visit #1')
309	324	self.getPage("/control")
310	325	self.assertBody('visit #1')
311
	326
312	327	self.getPage("/control", headers=[('Cache-Control', 'no-cache')])
313	328	self.assertBody('visit #2')
314	329	self.getPage("/control")
315	330	self.assertBody('visit #2')
316
	331
317	332	self.getPage("/control", headers=[('Pragma', 'no-cache')])
318	333	self.assertBody('visit #3')
319	334	self.getPage("/control")
320	335	self.assertBody('visit #3')
321
	336
322	337	time.sleep(1)
323	338	self.getPage("/control", headers=[('Cache-Control', 'max-age=0')])
324	339	self.assertBody('visit #4')
325	340	self.getPage("/control")
326	341	self.assertBody('visit #4')
327

+19

-0

cherrypy/test/test_compat.py less more

	0	import unittest
	1
	2	import nose
	3
	4	from cherrypy import _cpcompat as compat
	5
	6
	7	class StringTester(unittest.TestCase):
	8
	9	def test_ntob_non_native(self):
	10	"""
	11	ntob should raise an Exception on unicode.
	12	(Python 2 only)
	13
	14	See #1132 for discussion.
	15	"""
	16	if compat.py3k:
	17	raise nose.SkipTest("Only useful on Python 2")
	18	self.assertRaises(Exception, compat.ntob, unicode('fight'))

+33

-18

cherrypy/test/test_config.py less more

0	0	"""Tests for the CherryPy configuration system."""
1	1
2		import os, sys
	2	import os
	3	import sys
	4	import unittest
	5
	6	import cherrypy
	7	import cherrypy._cpcompat as compat
	8
3	9	localDir = os.path.join(os.getcwd(), os.path.dirname(__file__))
4	10
5		from cherrypy._cpcompat import ntob, StringIO
6		import unittest
7
8		import cherrypy
9	11
10	12	def setup_server():
11	13

40	42	plain._cp_config = {'request.body.attempt_charsets': ['utf-16']}
41	43
42	44	favicon_ico = cherrypy.tools.staticfile.handler(
43		filename=os.path.join(localDir, '../favicon.ico'))
	45	filename=os.path.join(localDir, '../favicon.ico'))
44	46
45	47	class Foo:
46	48

56	58	return 'Hello world'
57	59	silly.exposed = True
58	60	silly._cp_config = {'response.headers.X-silly': 'sillyval'}
59
	61
60	62	# Test the expose and config decorators
61	63	#@cherrypy.expose
62	64	#@cherrypy.config(foo='this3', **{'bax': 'this4'})

71	73	return str(cherrypy.request.config.get(key, "None"))
72	74	index.exposed = True
73	75
74
75	76	def raw_namespace(key, value):
76	77	if key == 'input.map':
77	78	handler = cherrypy.request.handler
	79
78	80	def wrapper():
79	81	params = cherrypy.request.params
80	82	for name, coercer in list(value.items()):

86	88	cherrypy.request.handler = wrapper
87	89	elif key == 'output':
88	90	handler = cherrypy.request.handler
	91
89	92	def wrapper():
90	93	# 'value' is a type (like int or str).
91	94	return value(handler())

100	103	incr.exposed = True
101	104	incr._cp_config = {'raw.input.map': {'num': int}}
102	105
103		ioconf = StringIO("""
	106	if not compat.py3k:
	107	thing3 = "thing3: unicode('test', errors='ignore')"
	108	else:
	109	thing3 = ''
	110
	111	ioconf = compat.StringIO("""
104	112	[/]
105	113	neg: -1234
106	114	filename: os.path.join(sys.prefix, "hello.py")
107	115	thing1: cherrypy.lib.httputil.response_codes[404]
108	116	thing2: __import__('cherrypy.tutorial', globals(), locals(), ['']).thing2
	117	%s
109	118	complex: 3+2j
110	119	mul: 6*3
111	120	ones: "11"

114	123
115	124	[/favicon.ico]
116	125	tools.staticfile.filename = %r
117		""" % os.path.join(localDir, 'static/dirback.jpg'))
	126	""" % (thing3, os.path.join(localDir, 'static/dirback.jpg')))
118	127
119	128	root = Root()
120	129	root.foo = Foo()

131	140	# Client-side code #
132	141
133	142	from cherrypy.test import helper
	143
134	144
135	145	class ConfigTests(helper.CPWebCase):
136	146	setup_server = staticmethod(setup_server)

146	156	('/foo/', 'bax', 'None'),
147	157	('/foo/bar', 'baz', "'that2'"),
148	158	('/foo/nex', 'baz', 'that2'),
149		# If 'foo' == 'this', then the mount point '/another' leaks into '/'.
150		('/another/','foo', 'None'),
	159	# If 'foo' == 'this', then the mount point '/another' leaks into
	160	# '/'.
	161	('/another/', 'foo', 'None'),
151	162	]
152	163	for path, key, expected in tests:
153	164	self.getPage(path + "?key=" + key)

160	171	'request.show_tracebacks': True,
161	172	'log.screen': False,
162	173	'environment': 'test_suite',
163		'engine.autoreload_on': False,
	174	'engine.autoreload.on': False,
164	175	# From global config
165	176	'luxuryyacht': 'throatwobblermangrove',
166	177	# From Root._cp_config

170	181	# From Foo.bar._cp_config
171	182	'foo': 'this3',
172	183	'bax': 'this4',
173		}
	184	}
174	185	for key, expected in expectedconf.items():
175	186	self.getPage("/foo/bar?key=" + key)
176	187	self.assertBody(repr(expected))

191	202	self.getPage("/repr?key=thing2")
192	203	from cherrypy.tutorial import thing2
193	204	self.assertBody(repr(thing2))
	205
	206	if not compat.py3k:
	207	self.getPage("/repr?key=thing3")
	208	self.assertBody(repr(u'test'))
194	209
195	210	self.getPage("/repr?key=complex")
196	211	self.assertBody("(3+2j)")

225	240	self.getPage("/plain", method='POST', headers=[
226	241	('Content-Type', 'application/x-www-form-urlencoded'),
227	242	('Content-Length', '13')],
228		body=ntob('\xff\xfex\x00=\xff\xfea\x00b\x00c\x00'))
	243	body=compat.ntob('\xff\xfex\x00=\xff\xfea\x00b\x00c\x00'))
229	244	self.assertBody("abc")
230	245
231	246

247	262
248	263	""")
249	264
250		fp = StringIO(conf)
	265	fp = compat.StringIO(conf)
251	266
252	267	cherrypy.config.update(fp)
253	268	self.assertEqual(cherrypy.config["my"]["my.dir"], "/some/dir/my/dir")
254		self.assertEqual(cherrypy.config["my"]["my.dir2"], "/some/dir/my/dir/dir2")
255
	269	self.assertEqual(cherrypy.config["my"]
	270	["my.dir2"], "/some/dir/my/dir/dir2")

+30

-23

cherrypy/test/test_config_server.py less more

0	0	"""Tests for the CherryPy configuration system."""
1	1
2		import os, sys
	2	import os
	3	import sys
3	4	localDir = os.path.join(os.getcwd(), os.path.dirname(__file__))
4	5	import socket
5	6	import time

11	12
12	13	from cherrypy.test import helper
13	14
	15
14	16	class ServerConfigTests(helper.CPWebCase):
15	17
16	18	def setup_server():
17
	19
18	20	class Root:
	21
19	22	def index(self):
20	23	return cherrypy.request.wsgi_environ['SERVER_PORT']
21	24	index.exposed = True
22
	25
23	26	def upload(self, file):
24	27	return "Size: %s" % len(file.file.read())
25	28	upload.exposed = True
26
	29
27	30	def tinyupload(self):
28	31	return cherrypy.request.body.read()
29	32	tinyupload.exposed = True
30	33	tinyupload._cp_config = {'request.body.maxbytes': 100}
31
	34
32	35	cherrypy.tree.mount(Root())
33
	36
34	37	cherrypy.config.update({
35	38	'server.socket_host': '0.0.0.0',
36	39	'server.socket_port': 9876,
37	40	'server.max_request_body_size': 200,
38	41	'server.max_request_header_size': 500,
39	42	'server.socket_timeout': 0.5,
40
	43
41	44	# Test explicit server.instance
42	45	'server.2.instance': 'cherrypy._cpwsgi_server.CPWSGIServer',
43	46	'server.2.socket_port': 9877,
44
	47
45	48	# Test non-numeric <servername>
46	49	# Also test default server.instance = builtin server
47	50	'server.yetanother.socket_port': 9878,
48		})
	51	})
49	52	setup_server = staticmethod(setup_server)
50
	53
51	54	PORT = 9876
52
	55
53	56	def testBasicConfig(self):
54	57	self.getPage("/")
55	58	self.assertBody(str(self.PORT))
56
	59
57	60	def testAdditionalServers(self):
58	61	if self.scheme == 'https':
59	62	return self.skip("not available under ssl")

63	66	self.PORT = 9878
64	67	self.getPage("/")
65	68	self.assertBody(str(self.PORT))
66
	69
67	70	def testMaxRequestSizePerHandler(self):
68	71	if getattr(cherrypy.server, "using_apache", False):
69	72	return self.skip("skipped due to known Apache differences... ")
70
	73
71	74	self.getPage('/tinyupload', method="POST",
72	75	headers=[('Content-Type', 'text/plain'),
73	76	('Content-Length', '100')],
74	77	body="x" * 100)
75	78	self.assertStatus(200)
76	79	self.assertBody("x" * 100)
77
	80
78	81	self.getPage('/tinyupload', method="POST",
79	82	headers=[('Content-Type', 'text/plain'),
80	83	('Content-Length', '101')],
81	84	body="x" * 101)
82	85	self.assertStatus(413)
83
	86
84	87	def testMaxRequestSize(self):
85	88	if getattr(cherrypy.server, "using_apache", False):
86	89	return self.skip("skipped due to known Apache differences... ")
87
	90
88	91	for size in (500, 5000, 50000):
89	92	self.getPage("/", headers=[('From', "x" * 500)])
90	93	self.assertStatus(413)
91
92		# Test for http://www.cherrypy.org/ticket/421
	94
	95	# Test for https://bitbucket.org/cherrypy/cherrypy/issue/421
93	96	# (Incorrect border condition in readline of SizeCheckWrapper).
94	97	# This hangs in rev 891 and earlier.
95	98	lines256 = "x" * 248
96	99	self.getPage("/",
97	100	headers=[('Host', '%s:%s' % (self.HOST, self.PORT)),
98	101	('From', lines256)])
99
	102
100	103	# Test upload
	104	cd = (
	105	'Content-Disposition: form-data; '
	106	'name="file"; '
	107	'filename="hello.txt"'
	108	)
101	109	body = '\r\n'.join([
102	110	'--x',
103		'Content-Disposition: form-data; name="file"; filename="hello.txt"',
	111	cd,
104	112	'Content-Type: text/plain',
105	113	'',
106	114	'%s',

111	119	("Content-Length", "%s" % len(b))]
112	120	self.getPage('/upload', h, "POST", b)
113	121	self.assertBody('Size: %d' % partlen)
114
	122
115	123	b = body % ("x" * 200)
116	124	h = [("Content-type", "multipart/form-data; boundary=x"),
117	125	("Content-Length", "%s" % len(b))]
118	126	self.getPage('/upload', h, "POST", b)
119	127	self.assertStatus(413)
120

+23

-17

cherrypy/test/test_conn.py less more

6	6
7	7
8	8	import cherrypy
9		from cherrypy._cpcompat import HTTPConnection, HTTPSConnection, NotConnected, BadStatusLine
10		from cherrypy._cpcompat import ntob, urlopen, unicodestr
	9	from cherrypy._cpcompat import HTTPConnection, HTTPSConnection, NotConnected
	10	from cherrypy._cpcompat import BadStatusLine, ntob, urlopen, unicodestr
11	11	from cherrypy.test import webtest
12	12	from cherrypy import _cperror
13	13
14	14
15	15	pov = 'pPeErRsSiIsStTeEnNcCeE oOfF vViIsSiIoOnN'
	16
16	17
17	18	def setup_server():
18	19

92	93	cherrypy.config.update({
93	94	'server.max_request_body_size': 1001,
94	95	'server.socket_timeout': timeout,
95		})
	96	})
96	97
97	98
98	99	from cherrypy.test import helper
	100
99	101
100	102	class ConnectionCloseTests(helper.CPWebCase):
101	103	setup_server = staticmethod(setup_server)

178	180	else:
179	181	self.assertHeader("Connection", "close")
180	182
181		# Make another request on the same connection, which should error.
	183	# Make another request on the same connection, which should
	184	# error.
182	185	self.assertRaises(NotConnected, self.getPage, "/")
183	186
184		# Try HEAD. See http://www.cherrypy.org/ticket/864.
	187	# Try HEAD. See
	188	# https://bitbucket.org/cherrypy/cherrypy/issue/864.
185	189	self.getPage("/stream", method='HEAD')
186	190	self.assertStatus('200 OK')
187	191	self.assertBody('')

219	223	self.assertNoHeader("Connection", "Keep-Alive")
220	224	self.assertNoHeader("Transfer-Encoding")
221	225
222		# Make another request on the same connection, which should error.
	226	# Make another request on the same connection, which should
	227	# error.
223	228	self.assertRaises(NotConnected, self.getPage, "/")
224	229
225	230	def test_HTTP10_KeepAlive(self):

234	239	self.assertStatus('200 OK')
235	240	self.assertBody(pov)
236	241	# Apache, for example, may emit a Connection header even for HTTP/1.0
237		## self.assertNoHeader("Connection")
	242	# self.assertNoHeader("Connection")
238	243
239	244	# Test a keep-alive HTTP/1.0 request.
240	245	self.persistent = True

249	254	self.assertStatus('200 OK')
250	255	self.assertBody(pov)
251	256	# Apache, for example, may emit a Connection header even for HTTP/1.0
252		## self.assertNoHeader("Connection")
	257	# self.assertNoHeader("Connection")
253	258
254	259
255	260	class PipelineTests(helper.CPWebCase):

360	365	self.body = response.read()
361	366	self.assertBody(pov)
362	367
363
364	368	# Make another request on the same socket,
365	369	# but timeout on the headers
366	370	conn.send(ntob('GET /hello HTTP/1.1'))

470	474	while True:
471	475	line = response.fp.readline().strip()
472	476	if line:
473		self.fail("100 Continue should not output any headers. Got %r" % line)
	477	self.fail(
	478	"100 Continue should not output any headers. Got %r" %
	479	line)
474	480	else:
475	481	break
476	482

595	601	return self.skip()
596	602
597	603	if (hasattr(self, 'harness') and
598		"modpython" in self.harness.__class__.__name__.lower()):
	604	"modpython" in self.harness.__class__.__name__.lower()):
599	605	# mod_python forbids chunked encoding
600	606	return self.skip()
601	607

607	613
608	614	# Try a normal chunked request (with extensions)
609	615	body = ntob("8;key=value\r\nxx\r\nxxxx\r\n5\r\nyyyyy\r\n0\r\n"
610		"Content-Type: application/json\r\n"
611		"\r\n")
	616	"Content-Type: application/json\r\n"
	617	"\r\n")
612	618	conn.putrequest("POST", "/upload", skip_host=True)
613	619	conn.putheader("Host", self.HOST)
614	620	conn.putheader("Transfer-Encoding", "chunked")

679	685	# the actual bytes in the response body.
680	686	self.persistent = True
681	687	conn = self.HTTP_CONN
682		conn.putrequest("GET", "/custom_cl?body=I+too&body=+have+too+many&cl=5",
683		skip_host=True)
	688	conn.putrequest(
	689	"GET", "/custom_cl?body=I+too&body=+have+too+many&cl=5",
	690	skip_host=True)
684	691	conn.putheader("Host", self.HOST)
685	692	conn.endheaders()
686	693	response = conn.getresponse()

691	698
692	699	def test_598(self):
693	700	remote_data_conn = urlopen('%s://%s:%s/one_megabyte_of_a/' %
694		(self.scheme, self.HOST, self.PORT,))
	701	(self.scheme, self.HOST, self.PORT,))
695	702	buf = remote_data_conn.read(512)
696	703	time.sleep(timeout * 0.6)
697	704	remaining = (1024 * 1024) - 512

730	737	self.body = response.read()
731	738	self.assertBody("HTTP requires CRLF terminators")
732	739	conn.close()
733

+192

-156

cherrypy/test/test_core.py less more

16	16
17	17	from cherrypy.test import helper
18	18
	19
19	20	class CoreRequestHandlingTest(helper.CPWebCase):
20	21
21	22	def setup_server():
22	23	class Root:
23
	24
24	25	def index(self):
25	26	return "hello"
26	27	index.exposed = True
27
	28
28	29	favicon_ico = tools.staticfile.handler(filename=favicon_path)
29
	30
30	31	def defct(self, newct):
31	32	newct = "text/%s" % newct
32	33	cherrypy.config.update({'tools.response_headers.on': True,
33	34	'tools.response_headers.headers':
34	35	[('Content-Type', newct)]})
35	36	defct.exposed = True
36
	37
37	38	def baseurl(self, path_info, relative=None):
38	39	return cherrypy.url(path_info, relative=bool(relative))
39	40	baseurl.exposed = True
40
	41
41	42	root = Root()
42
	43
43	44	if sys.version_info >= (2, 5):
44	45	from cherrypy.test._test_decorators import ExposeExamples
45	46	root.expose_dec = ExposeExamples()
46	47
47
48	48	class TestType(type):
49		"""Metaclass which automatically exposes all functions in each subclass,
50		and adds an instance of the subclass as an attribute of root.
	49
	50	"""Metaclass which automatically exposes all functions in each
	51	subclass, and adds an instance of the subclass as an attribute
	52	of root.
51	53	"""
52	54	def __init__(cls, name, bases, dct):
53	55	type.__init__(cls, name, bases, dct)

56	58	value.exposed = True
57	59	setattr(root, name.lower(), cls())
58	60	Test = TestType('Test', (object, ), {})
59
60
	61
61	62	class URL(Test):
62
	63
63	64	_cp_config = {'tools.trailing_slash.on': False}
64
	65
65	66	def index(self, path_info, relative=None):
66	67	if relative != 'server':
67	68	relative = bool(relative)
68	69	return cherrypy.url(path_info, relative=relative)
69
	70
70	71	def leaf(self, path_info, relative=None):
71	72	if relative != 'server':
72	73	relative = bool(relative)
73	74	return cherrypy.url(path_info, relative=relative)
74	75
75
76	76	def log_status():
77	77	Status.statuses.append(cherrypy.response.status)
78		cherrypy.tools.log_status = cherrypy.Tool('on_end_resource', log_status)
79
	78	cherrypy.tools.log_status = cherrypy.Tool(
	79	'on_end_resource', log_status)
80	80
81	81	class Status(Test):
82
	82
83	83	def index(self):
84	84	return "normal"
85
	85
86	86	def blank(self):
87	87	cherrypy.response.status = ""
88
	88
89	89	# According to RFC 2616, new status codes are OK as long as they
90	90	# are between 100 and 599.
91
	91
92	92	# Here is an illegal code...
93	93	def illegal(self):
94	94	cherrypy.response.status = 781
95	95	return "oops"
96
	96
97	97	# ...and here is an unknown but legal code.
98	98	def unknown(self):
99	99	cherrypy.response.status = "431 My custom error"
100	100	return "funky"
101
	101
102	102	# Non-numeric code
103	103	def bad(self):
104	104	cherrypy.response.status = "error"
105	105	return "bad news"
106
	106
107	107	statuses = []
	108
108	109	def on_end_resource_stage(self):
109	110	return repr(self.statuses)
110	111	on_end_resource_stage._cp_config = {'tools.log_status.on': True}
111	112
112
113	113	class Redirect(Test):
114
	114
115	115	class Error:
116	116	_cp_config = {"tools.err_redirect.on": True,
117	117	"tools.err_redirect.url": "/errpage",
118	118	"tools.err_redirect.internal": False,
119	119	}
120
	120
121	121	def index(self):
122	122	raise NameError("redirect_test")
123	123	index.exposed = True
124	124	error = Error()
125
	125
126	126	def index(self):
127	127	return "child"
128
	128
129	129	def custom(self, url, code):
130	130	raise cherrypy.HTTPRedirect(url, code)
131
	131
132	132	def by_code(self, code):
133	133	raise cherrypy.HTTPRedirect("somewhere%20else", code)
134	134	by_code._cp_config = {'tools.trailing_slash.extra': True}
135
	135
136	136	def nomodify(self):
137	137	raise cherrypy.HTTPRedirect("", 304)
138
	138
139	139	def proxy(self):
140	140	raise cherrypy.HTTPRedirect("proxy", 305)
141
	141
142	142	def stringify(self):
143	143	return str(cherrypy.HTTPRedirect("/"))
144
	144
145	145	def fragment(self, frag):
146	146	raise cherrypy.HTTPRedirect("/some/url#%s" % frag)
147
	147
	148	def url_with_quote(self):
	149	raise cherrypy.HTTPRedirect("/some\"url/that'we/want")
	150
148	151	def login_redir():
149	152	if not getattr(cherrypy.request, "login", None):
150	153	raise cherrypy.InternalRedirect("/internalredirect/login")
151	154	tools.login_redir = _cptools.Tool('before_handler', login_redir)
152
	155
153	156	def redir_custom():
154	157	raise cherrypy.InternalRedirect("/internalredirect/custom_err")
155
	158
156	159	class InternalRedirect(Test):
157
	160
158	161	def index(self):
159	162	raise cherrypy.InternalRedirect("/")
160
	163
161	164	def choke(self):
162	165	return 3 / 0
163	166	choke.exposed = True
164	167	choke._cp_config = {'hooks.before_error_response': redir_custom}
165
	168
166	169	def relative(self, a, b):
167	170	raise cherrypy.InternalRedirect("cousin?t=6")
168
	171
169	172	def cousin(self, t):
170	173	assert cherrypy.request.prev.closed
171	174	return cherrypy.request.prev.query_string
172
	175
173	176	def petshop(self, user_id):
174	177	if user_id == "parrot":
175	178	# Trade it for a slug when redirecting
176		raise cherrypy.InternalRedirect('/image/getImagesByUser?user_id=slug')
	179	raise cherrypy.InternalRedirect(
	180	'/image/getImagesByUser?user_id=slug')
177	181	elif user_id == "terrier":
178	182	# Trade it for a fish when redirecting
179		raise cherrypy.InternalRedirect('/image/getImagesByUser?user_id=fish')
	183	raise cherrypy.InternalRedirect(
	184	'/image/getImagesByUser?user_id=fish')
180	185	else:
181	186	# This should pass the user_id through to getImagesByUser
182	187	raise cherrypy.InternalRedirect(
183	188	'/image/getImagesByUser?user_id=%s' % str(user_id))
184
185		# We support Python 2.3, but the @-deco syntax would look like this:
	189
	190	# We support Python 2.3, but the @-deco syntax would look like
	191	# this:
186	192	# @tools.login_redir()
187	193	def secure(self):
188	194	return "Welcome!"

190	196	# Since calling the tool returns the same function you pass in,
191	197	# you could skip binding the return value, and just write:
192	198	# tools.login_redir()(secure)
193
	199
194	200	def login(self):
195	201	return "Please log in"
196
	202
197	203	def custom_err(self):
198	204	return "Something went horribly wrong."
199
	205
200	206	def early_ir(self, arg):
201	207	return "whatever"
202	208	early_ir._cp_config = {'hooks.before_request_body': redir_custom}
203
204
	209
205	210	class Image(Test):
206
	211
207	212	def getImagesByUser(self, user_id):
208	213	return "0 images for %s" % user_id
209	214
210
211	215	class Flatten(Test):
212
	216
213	217	def as_string(self):
214	218	return "content"
215
	219
216	220	def as_list(self):
217	221	return ["con", "tent"]
218
	222
219	223	def as_yield(self):
220	224	yield ntob("content")
221
	225
222	226	def as_dblyield(self):
223	227	yield self.as_yield()
224	228	as_dblyield._cp_config = {'tools.flatten.on': True}
225
	229
226	230	def as_refyield(self):
227	231	for chunk in self.as_yield():
228	232	yield chunk
229
230
	233
231	234	class Ranges(Test):
232
	235
233	236	def get_ranges(self, bytes):
234	237	return repr(httputil.get_ranges('bytes=%s' % bytes, 8))
235
	238
236	239	def slice_file(self):
237	240	path = os.path.join(os.getcwd(), os.path.dirname(__file__))
238		return static.serve_file(os.path.join(path, "static/index.html"))
239
	241	return static.serve_file(
	242	os.path.join(path, "static/index.html"))
240	243
241	244	class Cookies(Test):
242
	245
243	246	def single(self, name):
244	247	cookie = cherrypy.request.cookie[name]
245	248	# Python2's SimpleCookie.__setitem__ won't take unicode keys.
246	249	cherrypy.response.cookie[str(name)] = cookie.value
247
	250
248	251	def multiple(self, names):
249	252	for name in names:
250	253	cookie = cherrypy.request.cookie[name]
251		# Python2's SimpleCookie.__setitem__ won't take unicode keys.
	254	# Python2's SimpleCookie.__setitem__ won't take unicode
	255	# keys.
252	256	cherrypy.response.cookie[str(name)] = cookie.value
253	257
254	258	def append_headers(header_list, debug=False):

257	261	"Extending response headers with %s" % repr(header_list),
258	262	"TOOLS.APPEND_HEADERS")
259	263	cherrypy.serving.response.header_list.extend(header_list)
260		cherrypy.tools.append_headers = cherrypy.Tool('on_end_resource', append_headers)
261
	264	cherrypy.tools.append_headers = cherrypy.Tool(
	265	'on_end_resource', append_headers)
	266
262	267	class MultiHeader(Test):
263
	268
264	269	def header_list(self):
265	270	pass
266	271	header_list = cherrypy.tools.append_headers(header_list=[
267	272	(ntob('WWW-Authenticate'), ntob('Negotiate')),
268	273	(ntob('WWW-Authenticate'), ntob('Basic realm="foo"')),
269		])(header_list)
270
	274	])(header_list)
	275
271	276	def commas(self):
272		cherrypy.response.headers['WWW-Authenticate'] = 'Negotiate,Basic realm="foo"'
273
	277	cherrypy.response.headers[
	278	'WWW-Authenticate'] = 'Negotiate,Basic realm="foo"'
274	279
275	280	cherrypy.tree.mount(root)
276	281	setup_server = staticmethod(setup_server)
277
278	282
279	283	def testStatus(self):
280	284	self.getPage("/status/")
281	285	self.assertBody('normal')
282	286	self.assertStatus(200)
283
	287
284	288	self.getPage("/status/blank")
285	289	self.assertBody('')
286	290	self.assertStatus(200)
287
	291
288	292	self.getPage("/status/illegal")
289	293	self.assertStatus(500)
290	294	msg = "Illegal response status from server (781 is out of range)."
291	295	self.assertErrorPage(500, msg)
292
	296
293	297	if not getattr(cherrypy.server, 'using_apache', False):
294	298	self.getPage("/status/unknown")
295	299	self.assertBody('funky')
296	300	self.assertStatus(431)
297
	301
298	302	self.getPage("/status/bad")
299	303	self.assertStatus(500)
300	304	msg = "Illegal response status from server ('error' is non-numeric)."

312	316	# Make sure GET params are preserved.
313	317	self.getPage("/redirect?id=3")
314	318	self.assertStatus(301)
315		self.assertInBody("<a href='%s/redirect/?id=3'>"
316		"%s/redirect/?id=3</a>" % (self.base(), self.base()))
317
	319	self.assertMatchesBody('<a href=([\'"])%s/redirect/[?]id=3\\1>'
	320	"%s/redirect/[?]id=3</a>" % (self.base(), self.base()))
	321
318	322	if self.prefix():
319	323	# Corner case: the "trailing slash" redirect could be tricky if
320	324	# we're using a virtual root and the URI is "/vroot" (no slash).
321	325	self.getPage("")
322	326	self.assertStatus(301)
323		self.assertInBody("<a href='%s/'>%s/</a>" %
	327	self.assertMatchesBody("<a href=(['\"])%s/\\1>%s/</a>" %
324	328	(self.base(), self.base()))
325
	329
326	330	# Test that requests for NON-index methods WITH a trailing slash
327	331	# get redirected to the same URI path WITHOUT a trailing slash.
328	332	# Make sure GET params are preserved.
329	333	self.getPage("/redirect/by_code/?code=307")
330	334	self.assertStatus(301)
331		self.assertInBody("<a href='%s/redirect/by_code?code=307'>"
332		"%s/redirect/by_code?code=307</a>"
	335	self.assertMatchesBody("<a href=(['\"])%s/redirect/by_code[?]code=307\\1>"
	336	"%s/redirect/by_code[?]code=307</a>"
333	337	% (self.base(), self.base()))
334
	338
335	339	# If the trailing_slash tool is off, CP should just continue
336	340	# as if the slashes were correct. But it needs some help
337	341	# inside cherrypy.url to form correct output.

339	343	self.assertBody('%s/url/page1' % self.base())
340	344	self.getPage('/url/leaf/?path_info=page1')
341	345	self.assertBody('%s/url/page1' % self.base())
342
	346
343	347	def testRedirect(self):
344	348	self.getPage("/redirect/")
345	349	self.assertBody('child')
346	350	self.assertStatus(200)
347
	351
348	352	self.getPage("/redirect/by_code?code=300")
349		self.assertMatchesBody(r"<a href='(.*)somewhere%20else'>\1somewhere%20else</a>")
	353	self.assertMatchesBody(
	354	r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
350	355	self.assertStatus(300)
351
	356
352	357	self.getPage("/redirect/by_code?code=301")
353		self.assertMatchesBody(r"<a href='(.*)somewhere%20else'>\1somewhere%20else</a>")
	358	self.assertMatchesBody(
	359	r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
354	360	self.assertStatus(301)
355
	361
356	362	self.getPage("/redirect/by_code?code=302")
357		self.assertMatchesBody(r"<a href='(.*)somewhere%20else'>\1somewhere%20else</a>")
	363	self.assertMatchesBody(
	364	r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
358	365	self.assertStatus(302)
359
	366
360	367	self.getPage("/redirect/by_code?code=303")
361		self.assertMatchesBody(r"<a href='(.*)somewhere%20else'>\1somewhere%20else</a>")
	368	self.assertMatchesBody(
	369	r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
362	370	self.assertStatus(303)
363
	371
364	372	self.getPage("/redirect/by_code?code=307")
365		self.assertMatchesBody(r"<a href='(.*)somewhere%20else'>\1somewhere%20else</a>")
	373	self.assertMatchesBody(
	374	r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
366	375	self.assertStatus(307)
367
	376
368	377	self.getPage("/redirect/nomodify")
369	378	self.assertBody('')
370	379	self.assertStatus(304)
371
	380
372	381	self.getPage("/redirect/proxy")
373	382	self.assertBody('')
374	383	self.assertStatus(305)
375
	384
376	385	# HTTPRedirect on error
377	386	self.getPage("/redirect/error/")
378	387	self.assertStatus(('302 Found', '303 See Other'))
379	388	self.assertInBody('/errpage')
380
	389
381	390	# Make sure str(HTTPRedirect()) works.
382	391	self.getPage("/redirect/stringify", protocol="HTTP/1.0")
383	392	self.assertStatus(200)

386	395	self.getPage("/redirect/stringify", protocol="HTTP/1.1")
387	396	self.assertStatus(200)
388	397	self.assertBody("(['%s/'], 303)" % self.base())
389
	398
390	399	# check that #fragments are handled properly
391	400	# http://skrb.org/ietf/http_errata.html#location-fragments
392	401	frag = "foo"
393	402	self.getPage("/redirect/fragment/%s" % frag)
394		self.assertMatchesBody(r"<a href='(.*)\/some\/url\#%s'>\1\/some\/url\#%s</a>" % (frag, frag))
	403	self.assertMatchesBody(
	404	r"<a href=(['\"])(.*)\/some\/url\#%s\1>\2\/some\/url\#%s</a>" % (
	405	frag, frag))
395	406	loc = self.assertHeader('Location')
396	407	assert loc.endswith("#%s" % frag)
397	408	self.assertStatus(('302 Found', '303 See Other'))
398
	409
399	410	# check injection protection
400		# See http://www.cherrypy.org/ticket/1003
401		self.getPage("/redirect/custom?code=303&url=/foobar/%0d%0aSet-Cookie:%20somecookie=someval")
	411	# See https://bitbucket.org/cherrypy/cherrypy/issue/1003
	412	self.getPage(
	413	"/redirect/custom?"
	414	"code=303&url=/foobar/%0d%0aSet-Cookie:%20somecookie=someval")
402	415	self.assertStatus(303)
403	416	loc = self.assertHeader('Location')
404	417	assert 'Set-Cookie' in loc
405	418	self.assertNoHeader('Set-Cookie')
406
	419
	420	def assertValidXHTML():
	421	from xml.etree import ElementTree
	422	try:
	423	ElementTree.fromstring('<html><body>%s</body></html>' % self.body)
	424	except ElementTree.ParseError as e:
	425	self._handlewebError('automatically generated redirect '
	426	'did not generate well-formed html')
	427
	428	# check redirects to URLs generated valid HTML - we check this
	429	# by seeing if it appears as valid XHTML.
	430	self.getPage("/redirect/by_code?code=303")
	431	self.assertStatus(303)
	432	assertValidXHTML()
	433
	434	# do the same with a url containing quote characters.
	435	self.getPage("/redirect/url_with_quote")
	436	self.assertStatus(303)
	437	assertValidXHTML()
	438
407	439	def test_InternalRedirect(self):
408	440	# InternalRedirect
409	441	self.getPage("/internalredirect/")
410	442	self.assertBody('hello')
411	443	self.assertStatus(200)
412
	444
413	445	# Test passthrough
414		self.getPage("/internalredirect/petshop?user_id=Sir-not-appearing-in-this-film")
	446	self.getPage(
	447	"/internalredirect/petshop?user_id=Sir-not-appearing-in-this-film")
415	448	self.assertBody('0 images for Sir-not-appearing-in-this-film')
416	449	self.assertStatus(200)
417
	450
418	451	# Test args
419	452	self.getPage("/internalredirect/petshop?user_id=parrot")
420	453	self.assertBody('0 images for slug')
421	454	self.assertStatus(200)
422
	455
423	456	# Test POST
424	457	self.getPage("/internalredirect/petshop", method="POST",
425	458	body="user_id=terrier")
426	459	self.assertBody('0 images for fish')
427	460	self.assertStatus(200)
428
	461
429	462	# Test ir before body read
430	463	self.getPage("/internalredirect/early_ir", method="POST",
431	464	body="arg=aha!")
432	465	self.assertBody("Something went horribly wrong.")
433	466	self.assertStatus(200)
434
	467
435	468	self.getPage("/internalredirect/secure")
436	469	self.assertBody('Please log in')
437	470	self.assertStatus(200)
438
	471
439	472	# Relative path in InternalRedirect.
440	473	# Also tests request.prev.
441	474	self.getPage("/internalredirect/relative?a=3&b=5")
442	475	self.assertBody("a=3&b=5")
443	476	self.assertStatus(200)
444
	477
445	478	# InternalRedirect on error
446	479	self.getPage("/internalredirect/choke")
447	480	self.assertStatus(200)
448	481	self.assertBody("Something went horribly wrong.")
449
	482
450	483	def testFlatten(self):
451	484	for url in ["/flatten/as_string", "/flatten/as_list",
452	485	"/flatten/as_yield", "/flatten/as_dblyield",
453	486	"/flatten/as_refyield"]:
454	487	self.getPage(url)
455	488	self.assertBody('content')
456
	489
457	490	def testRanges(self):
458	491	self.getPage("/ranges/get_ranges?bytes=3-6")
459	492	self.assertBody("[(3, 7)]")
460
	493
461	494	# Test multiple ranges and a suffix-byte-range-spec, for good measure.
462	495	self.getPage("/ranges/get_ranges?bytes=2-4,-1")
463	496	self.assertBody("[(2, 5), (7, 8)]")
464
	497
465	498	# Get a partial file.
466	499	if cherrypy.server.protocol_version == "HTTP/1.1":
467	500	self.getPage("/ranges/slice_file", [('Range', 'bytes=2-5')])

469	502	self.assertHeader("Content-Type", "text/html;charset=utf-8")
470	503	self.assertHeader("Content-Range", "bytes 2-5/14")
471	504	self.assertBody("llo,")
472
	505
473	506	# What happens with overlapping ranges (and out of order, too)?
474	507	self.getPage("/ranges/slice_file", [('Range', 'bytes=4-6,2-5')])
475	508	self.assertStatus(206)

490	523	"--%s--\r\n" % (boundary, boundary, boundary))
491	524	self.assertBody(expected_body)
492	525	self.assertHeader("Content-Length")
493
	526
494	527	# Test "416 Requested Range Not Satisfiable"
495	528	self.getPage("/ranges/slice_file", [('Range', 'bytes=2300-2900')])
496	529	self.assertStatus(416)

503	536	self.getPage("/ranges/slice_file", [('Range', 'bytes=2-5')])
504	537	self.assertStatus(200)
505	538	self.assertBody("Hello, world\r\n")
506
	539
507	540	def testFavicon(self):
508	541	# favicon.ico is served by staticfile.
509	542	icofilename = os.path.join(localDir, "../favicon.ico")
510	543	icofile = open(icofilename, "rb")
511	544	data = icofile.read()
512	545	icofile.close()
513
	546
514	547	self.getPage("/favicon.ico")
515	548	self.assertBody(data)
516
	549
517	550	def testCookies(self):
518	551	if sys.version_info >= (2, 5):
519	552	header_value = lambda x: x
520	553	else:
521		header_value = lambda x: x+';'
522
	554	header_value = lambda x: x + ';'
	555
523	556	self.getPage("/cookies/single?name=First",
524	557	[('Cookie', 'First=Dinsdale;')])
525	558	self.assertHeader('Set-Cookie', header_value('First=Dinsdale'))
526
	559
527	560	self.getPage("/cookies/multiple?names=First&names=Last",
528	561	[('Cookie', 'First=Dinsdale; Last=Piranha;'),
529	562	])
530	563	self.assertHeader('Set-Cookie', header_value('First=Dinsdale'))
531	564	self.assertHeader('Set-Cookie', header_value('Last=Piranha'))
532
533		self.getPage("/cookies/single?name=Something-With:Colon",
534		[('Cookie', 'Something-With:Colon=some-value')])
	565
	566	self.getPage("/cookies/single?name=Something-With%2CComma",
	567	[('Cookie', 'Something-With,Comma=some-value')])
535	568	self.assertStatus(400)
536
	569
537	570	def testDefaultContentType(self):
538	571	self.getPage('/')
539	572	self.assertHeader('Content-Type', 'text/html;charset=utf-8')

541	574	self.getPage('/')
542	575	self.assertHeader('Content-Type', 'text/plain;charset=utf-8')
543	576	self.getPage('/defct/html')
544
	577
545	578	def test_multiple_headers(self):
546	579	self.getPage('/multiheader/header_list')
547		self.assertEqual([(k, v) for k, v in self.headers if k == 'WWW-Authenticate'],
548		[('WWW-Authenticate', 'Negotiate'),
549		('WWW-Authenticate', 'Basic realm="foo"'),
550		])
	580	self.assertEqual(
	581	[(k, v) for k, v in self.headers if k == 'WWW-Authenticate'],
	582	[('WWW-Authenticate', 'Negotiate'),
	583	('WWW-Authenticate', 'Basic realm="foo"'),
	584	])
551	585	self.getPage('/multiheader/commas')
552	586	self.assertHeader('WWW-Authenticate', 'Negotiate,Basic realm="foo"')
553
	587
554	588	def test_cherrypy_url(self):
555	589	# Input relative to current
556	590	self.getPage('/url/leaf?path_info=page1')

562	596	self.getPage('/url/leaf?path_info=page1',
563	597	headers=[('Host', host)])
564	598	self.assertBody('%s://%s/url/page1' % (self.scheme, host))
565
	599
566	600	# Input is 'absolute'; that is, relative to script_name
567	601	self.getPage('/url/leaf?path_info=/page1')
568	602	self.assertBody('%s/page1' % self.base())
569	603	self.getPage('/url/?path_info=/page1')
570	604	self.assertBody('%s/page1' % self.base())
571
	605
572	606	# Single dots
573	607	self.getPage('/url/leaf?path_info=./page1')
574	608	self.assertBody('%s/url/page1' % self.base())

576	610	self.assertBody('%s/url/other/page1' % self.base())
577	611	self.getPage('/url/?path_info=/other/./page1')
578	612	self.assertBody('%s/other/page1' % self.base())
579
	613
580	614	# Double dots
581	615	self.getPage('/url/leaf?path_info=../page1')
582	616	self.assertBody('%s/page1' % self.base())

584	618	self.assertBody('%s/url/page1' % self.base())
585	619	self.getPage('/url/leaf?path_info=/other/../page1')
586	620	self.assertBody('%s/page1' % self.base())
587
	621
588	622	# Output relative to current path or script_name
589	623	self.getPage('/url/?path_info=page1&relative=True')
590	624	self.assertBody('page1')

598	632	self.assertBody('../page1')
599	633	self.getPage('/url/?path_info=other/../page1&relative=True')
600	634	self.assertBody('page1')
601
	635
602	636	# Output relative to /
603	637	self.getPage('/baseurl?path_info=ab&relative=True')
604	638	self.assertBody('ab')
605	639	# Output relative to /
606	640	self.getPage('/baseurl?path_info=/ab&relative=True')
607	641	self.assertBody('ab')
608
	642
609	643	# absolute-path references ("server-relative")
610	644	# Input relative to current
611	645	self.getPage('/url/leaf?path_info=page1&relative=server')

617	651	self.assertBody('/page1')
618	652	self.getPage('/url/?path_info=/page1&relative=server')
619	653	self.assertBody('/page1')
620
	654
621	655	def test_expose_decorator(self):
622	656	if not sys.version_info >= (2, 5):
623	657	return self.skip("skipped (Python 2.5+ only) ")
624
	658
625	659	# Test @expose
626	660	self.getPage("/expose_dec/no_call")
627	661	self.assertStatus(200)
628	662	self.assertBody("Mr E. R. Bradshaw")
629
	663
630	664	# Test @expose()
631	665	self.getPage("/expose_dec/call_empty")
632	666	self.assertStatus(200)
633	667	self.assertBody("Mrs. B.J. Smegma")
634
	668
635	669	# Test @expose("alias")
636	670	self.getPage("/expose_dec/call_alias")
637	671	self.assertStatus(200)

640	674	self.getPage("/expose_dec/nesbitt")
641	675	self.assertStatus(200)
642	676	self.assertBody("Mr Nesbitt")
643
	677
644	678	# Test @expose(["alias1", "alias2"])
645	679	self.getPage("/expose_dec/alias1")
646	680	self.assertStatus(200)

652	686	self.getPage("/expose_dec/andrews")
653	687	self.assertStatus(200)
654	688	self.assertBody("Mr Ken Andrews")
655
	689
656	690	# Test @expose(alias="alias")
657	691	self.getPage("/expose_dec/alias3")
658	692	self.assertStatus(200)

665	699	def break_header():
666	700	# Add a header after finalize that is invalid
667	701	cherrypy.serving.response.header_list.append((2, 3))
668		cherrypy.tools.break_header = cherrypy.Tool('on_end_resource', break_header)
669
	702	cherrypy.tools.break_header = cherrypy.Tool(
	703	'on_end_resource', break_header)
	704
670	705	class Root:
	706
671	707	def index(self):
672	708	return "hello"
673	709	index.exposed = True
674
	710
675	711	def start_response_error(self):
676	712	return "salud!"
677	713	start_response_error._cp_config = {'tools.break_header.on': True}
678	714	root = Root()
679
	715
680	716	cherrypy.tree.mount(root)
681	717	setup_server = staticmethod(setup_server)
682	718
683	719	def test_start_response_error(self):
684	720	self.getPage("/start_response_error")
685	721	self.assertStatus(500)
686		self.assertInBody("TypeError: response.header_list key 2 is not a byte string.")
687
	722	self.assertInBody(
	723	"TypeError: response.header_list key 2 is not a byte string.")

+61

-42

cherrypy/test/test_dynamicobjectmapping.py less more

5	5	script_names = ["", "/foo", "/users/fred/blog", "/corp/blog"]
6	6
7	7
8
9	8	def setup_server():
10	9	class SubSubRoot:
	10
11	11	def index(self):
12	12	return "SubSubRoot index"
13	13	index.exposed = True

30	30	}
31	31
32	32	class SubRoot:
	33
33	34	def index(self):
34	35	return "SubRoot index"
35	36	index.exposed = True

49	50	'1': SubRoot(),
50	51	'2': SubRoot(),
51	52	}
	53
52	54	class Root:
	55
53	56	def index(self):
54	57	return "index"
55	58	index.exposed = True

69	72	# DynamicNodeAndMethodDispatcher example.
70	73	# This example exposes a fairly naive HTTP api
71	74	class User(object):
	75
72	76	def __init__(self, id, name):
73	77	self.id = id
74	78	self.name = name
75	79
76	80	def __unicode__(self):
77	81	return unicode(self.name)
	82
78	83	def __str__(self):
79	84	return str(self.name)
80	85

110	115
111	116	class UserInstanceNode(object):
112	117	exposed = True
	118
113	119	def __init__(self, id):
114	120	self.id = id
115	121	self.user = user_lookup.get(id, None)

134	140
135	141	def PUT(self, name):
136	142	"""
137		Create a new user with the specified id, or edit it if it already exists
	143	Create a new user with the specified id, or edit it if it already
	144	exists
138	145	"""
139	146	if self.user:
140	147	# Edit the current user

153	160	del self.user
154	161	return "DELETE %d" % id
155	162
156
157	163	class ABHandler:
	164
158	165	class CustomDispatch:
	166
159	167	def index(self, a, b):
160	168	return "custom"
161	169	index.exposed = True
162
	170
163	171	def _cp_dispatch(self, vpath):
164	172	"""Make sure that if we don't pop anything from vpath,
165	173	processing still works.
166	174	"""
167	175	return self.CustomDispatch()
168
	176
169	177	def index(self, a, b=None):
170		body = [ 'a:' + str(a) ]
	178	body = ['a:' + str(a)]
171	179	if b is not None:
172	180	body.append(',b:' + str(b))
173	181	return ''.join(body)
174	182	index.exposed = True
175
	183
176	184	def delete(self, a, b):
177	185	return 'deleting ' + str(a) + ' and ' + str(b)
178	186	delete.exposed = True
179
	187
180	188	class IndexOnly:
	189
181	190	def _cp_dispatch(self, vpath):
182		"""Make sure that popping ALL of vpath still shows the index
	191	"""Make sure that popping ALL of vpath still shows the index
183	192	handler.
184	193	"""
185	194	while vpath:
186	195	vpath.pop()
187	196	return self
188
	197
189	198	def index(self):
190	199	return "IndexOnly index"
191	200	index.exposed = True
192
	201
193	202	class DecoratedPopArgs:
	203
194	204	"""Test _cp_dispatch with @cherrypy.popargs."""
	205
195	206	def index(self):
196	207	return "no params"
197	208	index.exposed = True
198
	209
199	210	def hi(self):
200	211	return "hi was not interpreted as 'a' param"
201	212	hi.exposed = True
202		DecoratedPopArgs = cherrypy.popargs('a', 'b', handler=ABHandler())(DecoratedPopArgs)
203
	213	DecoratedPopArgs = cherrypy.popargs(
	214	'a', 'b', handler=ABHandler())(DecoratedPopArgs)
	215
204	216	class NonDecoratedPopArgs:
	217
205	218	"""Test _cp_dispatch = cherrypy.popargs()"""
206
	219
207	220	_cp_dispatch = cherrypy.popargs('a')
208
	221
209	222	def index(self, a):
210	223	return "index: " + str(a)
211	224	index.exposed = True
212
	225
213	226	class ParameterizedHandler:
	227
214	228	"""Special handler created for each request"""
215
	229
216	230	def __init__(self, a):
217	231	self.a = a
218
	232
219	233	def index(self):
220	234	if 'a' in cherrypy.request.params:
221		raise Exception("Parameterized handler argument ended up in request.params")
	235	raise Exception(
	236	"Parameterized handler argument ended up in "
	237	"request.params")
222	238	return self.a
223	239	index.exposed = True
224
	240
225	241	class ParameterizedPopArgs:
	242
226	243	"""Test cherrypy.popargs() with a function call handler"""
227		ParameterizedPopArgs = cherrypy.popargs('a', handler=ParameterizedHandler)(ParameterizedPopArgs)
228
	244	ParameterizedPopArgs = cherrypy.popargs(
	245	'a', handler=ParameterizedHandler)(ParameterizedPopArgs)
	246
229	247	Root.decorated = DecoratedPopArgs()
230	248	Root.undecorated = NonDecoratedPopArgs()
231	249	Root.index_only = IndexOnly()

236	254	md = cherrypy.dispatch.MethodDispatcher('dynamic_dispatch')
237	255	for url in script_names:
238	256	conf = {'/': {
239		'user': (url or "/").split("/")[-2],
240		},
241		'/users': {
242		'request.dispatch': md
243		},
244		}
	257	'user': (url or "/").split("/")[-2],
	258	},
	259	'/users': {
	260	'request.dispatch': md
	261	},
	262	}
245	263	cherrypy.tree.mount(Root(), url, conf)
	264
246	265
247	266	class DynamicObjectMappingTest(helper.CPWebCase):
248	267	setup_server = staticmethod(setup_server)

353	372	self.assertHeader('Allow', headers)
354	373
355	374	# Make sure POSTs update already existings resources
356		self.getPage("/users/%d" % id, method='POST', body="name=%s" % updatedname)
	375	self.getPage("/users/%d" %
	376	id, method='POST', body="name=%s" % updatedname)
357	377	self.assertBody("POST %d" % id)
358	378	self.assertHeader('Allow', headers)
359	379
360	380	# Make sure PUTs Update already existing resources.
361		self.getPage("/users/%d" % id, method='PUT', body="name=%s" % updatedname)
	381	self.getPage("/users/%d" %
	382	id, method='PUT', body="name=%s" % updatedname)
362	383	self.assertBody("PUT %d" % id)
363	384	self.assertHeader('Allow', headers)
364	385

367	388	self.assertBody("DELETE %d" % id)
368	389	self.assertHeader('Allow', headers)
369	390
370
371	391	# GET acts like a container
372	392	self.getPage("/users")
373	393	self.assertBody("[]")
374	394	self.assertHeader('Allow', 'GET, HEAD, POST')
375
	395
376	396	def testVpathDispatch(self):
377	397	self.getPage("/decorated/")
378	398	self.assertBody("no params")
379
	399
380	400	self.getPage("/decorated/hi")
381	401	self.assertBody("hi was not interpreted as 'a' param")
382
	402
383	403	self.getPage("/decorated/yo/")
384	404	self.assertBody("a:yo")
385
	405
386	406	self.getPage("/decorated/yo/there/")
387	407	self.assertBody("a:yo,b:there")
388
	408
389	409	self.getPage("/decorated/yo/there/delete")
390	410	self.assertBody("deleting yo and there")
391
	411
392	412	self.getPage("/decorated/yo/there/handled_by_dispatch/")
393	413	self.assertBody("custom")
394
	414
395	415	self.getPage("/undecorated/blah/")
396	416	self.assertBody("index: blah")
397
	417
398	418	self.getPage("/index_only/a/b/c/d/e/f/g/")
399	419	self.assertBody("IndexOnly index")
400
	420
401	421	self.getPage("/parameter_test/argument2/")
402	422	self.assertBody("argument2")
403

+164

-130

cherrypy/test/test_encoding.py less more

17	17
18	18	def setup_server():
19	19	class Root:
	20
20	21	def index(self, param):
21		assert param == europoundUnicode, "%r != %r" % (param, europoundUnicode)
	22	assert param == europoundUnicode, "%r != %r" % (
	23	param, europoundUnicode)
22	24	yield europoundUnicode
23	25	index.exposed = True
24
	26
25	27	def mao_zedong(self):
26	28	return sing
27	29	mao_zedong.exposed = True
28
	30
29	31	def utf8(self):
30	32	return sing8
31	33	utf8.exposed = True
32	34	utf8._cp_config = {'tools.encode.encoding': 'utf-8'}
33
	35
34	36	def cookies_and_headers(self):
35	37	# if the headers have non-ascii characters and a cookie has
36	38	# any part which is unicode (even ascii), the response
37	39	# should not fail.
38	40	cherrypy.response.cookie['candy'] = 'bar'
39	41	cherrypy.response.cookie['candy']['domain'] = 'cherrypy.org'
40		cherrypy.response.headers['Some-Header'] = 'My d\xc3\xb6g has fleas'
	42	cherrypy.response.headers[
	43	'Some-Header'] = 'My d\xc3\xb6g has fleas'
41	44	return 'Any content'
42	45	cookies_and_headers.exposed = True
43	46
44	47	def reqparams(self, args, *kwargs):
45		return ntob(', ').join([": ".join((k, v)).encode('utf8')
46		for k, v in cherrypy.request.params.items()])
	48	return ntob(', ').join(
	49	[": ".join((k, v)).encode('utf8')
	50	for k, v in sorted(cherrypy.request.params.items())]
	51	)
47	52	reqparams.exposed = True
48
	53
49	54	def nontext(self, args, *kwargs):
50		cherrypy.response.headers['Content-Type'] = 'application/binary'
	55	cherrypy.response.headers[
	56	'Content-Type'] = 'application/binary'
51	57	return '\x00\x01\x02\x03'
52	58	nontext.exposed = True
53	59	nontext._cp_config = {'tools.encode.text_only': False,
54	60	'tools.encode.add_charset': True,
55	61	}
56
	62
57	63	class GZIP:
	64
58	65	def index(self):
59	66	yield "Hello, world"
60	67	index.exposed = True
61
	68
62	69	def noshow(self):
63		# Test for ticket #147, where yield showed no exceptions (content-
64		# encoding was still gzip even though traceback wasn't zipped).
	70	# Test for ticket #147, where yield showed no exceptions
	71	# (content-encoding was still gzip even though traceback
	72	# wasn't zipped).
65	73	raise IndexError()
66	74	yield "Here be dragons"
67	75	noshow.exposed = True
68	76	# Turn encoding off so the gzip tool is the one doing the collapse.
69	77	noshow._cp_config = {'tools.encode.on': False}
70
	78
71	79	def noshow_stream(self):
72		# Test for ticket #147, where yield showed no exceptions (content-
73		# encoding was still gzip even though traceback wasn't zipped).
	80	# Test for ticket #147, where yield showed no exceptions
	81	# (content-encoding was still gzip even though traceback
	82	# wasn't zipped).
74	83	raise IndexError()
75	84	yield "Here be dragons"
76	85	noshow_stream.exposed = True
77	86	noshow_stream._cp_config = {'response.stream': True}
78
	87
79	88	class Decode:
	89
80	90	def extra_charset(self, args, *kwargs):
81	91	return ', '.join([": ".join((k, v))
82	92	for k, v in cherrypy.request.params.items()])

84	94	extra_charset._cp_config = {
85	95	'tools.decode.on': True,
86	96	'tools.decode.default_encoding': ['utf-16'],
87		}
88
	97	}
	98
89	99	def force_charset(self, args, *kwargs):
90	100	return ', '.join([": ".join((k, v))
91	101	for k, v in cherrypy.request.params.items()])

93	103	force_charset._cp_config = {
94	104	'tools.decode.on': True,
95	105	'tools.decode.encoding': 'utf-16',
96		}
97
	106	}
	107
98	108	root = Root()
99	109	root.gzip = GZIP()
100	110	root.decode = Decode()

105	115	europoundUtf8 = europoundUnicode.encode('utf-8')
106	116	self.getPage(ntob('/?param=') + europoundUtf8)
107	117	self.assertBody(europoundUtf8)
108
	118
109	119	# Encoded utf8 query strings MUST be parsed correctly.
110	120	# Here, q is the POUND SIGN U+00A3 encoded in utf8 and then %HEX
111	121	self.getPage("/reqparams?q=%C2%A3")
112	122	# The return value will be encoded as utf8.
113	123	self.assertBody(ntob("q: \xc2\xa3"))
114
	124
115	125	# Query strings that are incorrectly encoded MUST raise 404.
116	126	# Here, q is the POUND SIGN U+00A3 encoded in latin1 and then %HEX
117	127	self.getPage("/reqparams?q=%A3")
118	128	self.assertStatus(404)
119		self.assertErrorPage(404,
	129	self.assertErrorPage(
	130	404,
120	131	"The given query string could not be processed. Query "
121	132	"strings for this resource must be encoded with 'utf8'.")
122
	133
123	134	def test_urlencoded_decoding(self):
124	135	# Test the decoding of an application/x-www-form-urlencoded entity.
125	136	europoundUtf8 = europoundUnicode.encode('utf-8')
126		body=ntob("param=") + europoundUtf8
127		self.getPage('/', method='POST',
128		headers=[("Content-Type", "application/x-www-form-urlencoded"),
129		("Content-Length", str(len(body))),
130		],
	137	body = ntob("param=") + europoundUtf8
	138	self.getPage('/',
	139	method='POST',
	140	headers=[
	141	("Content-Type", "application/x-www-form-urlencoded"),
	142	("Content-Length", str(len(body))),
	143	],
131	144	body=body),
132	145	self.assertBody(europoundUtf8)
133
	146
134	147	# Encoded utf8 entities MUST be parsed and decoded correctly.
135	148	# Here, q is the POUND SIGN U+00A3 encoded in utf8
136	149	body = ntob("q=\xc2\xa3")
137	150	self.getPage('/reqparams', method='POST',
138		headers=[("Content-Type", "application/x-www-form-urlencoded"),
139		("Content-Length", str(len(body))),
140		],
141		body=body),
142		self.assertBody(ntob("q: \xc2\xa3"))
143
	151	headers=[(
	152	"Content-Type", "application/x-www-form-urlencoded"),
	153	("Content-Length", str(len(body))),
	154	],
	155	body=body),
	156	self.assertBody(ntob("q: \xc2\xa3"))
	157
144	158	# ...and in utf16, which is not in the default attempt_charsets list:
145	159	body = ntob("\xff\xfeq\x00=\xff\xfe\xa3\x00")
146		self.getPage('/reqparams', method='POST',
147		headers=[("Content-Type", "application/x-www-form-urlencoded;charset=utf-16"),
148		("Content-Length", str(len(body))),
149		],
150		body=body),
151		self.assertBody(ntob("q: \xc2\xa3"))
152
	160	self.getPage('/reqparams',
	161	method='POST',
	162	headers=[
	163	("Content-Type",
	164	"application/x-www-form-urlencoded;charset=utf-16"),
	165	("Content-Length", str(len(body))),
	166	],
	167	body=body),
	168	self.assertBody(ntob("q: \xc2\xa3"))
	169
153	170	# Entities that are incorrectly encoded MUST raise 400.
154	171	# Here, q is the POUND SIGN U+00A3 encoded in utf16, but
155	172	# the Content-Type incorrectly labels it utf-8.
156	173	body = ntob("\xff\xfeq\x00=\xff\xfe\xa3\x00")
157		self.getPage('/reqparams', method='POST',
158		headers=[("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"),
159		("Content-Length", str(len(body))),
160		],
	174	self.getPage('/reqparams',
	175	method='POST',
	176	headers=[
	177	("Content-Type",
	178	"application/x-www-form-urlencoded;charset=utf-8"),
	179	("Content-Length", str(len(body))),
	180	],
161	181	body=body),
162	182	self.assertStatus(400)
163		self.assertErrorPage(400,
	183	self.assertErrorPage(
	184	400,
164	185	"The request entity could not be decoded. The following charsets "
165	186	"were attempted: ['utf-8']")
166
	187
167	188	def test_decode_tool(self):
168	189	# An extra charset should be tried first, and succeed if it matches.
169	190	# Here, we add utf-16 as a charset and pass a utf-16 body.
170	191	body = ntob("\xff\xfeq\x00=\xff\xfe\xa3\x00")
171	192	self.getPage('/decode/extra_charset', method='POST',
172		headers=[("Content-Type", "application/x-www-form-urlencoded"),
173		("Content-Length", str(len(body))),
174		],
175		body=body),
176		self.assertBody(ntob("q: \xc2\xa3"))
177
	193	headers=[(
	194	"Content-Type", "application/x-www-form-urlencoded"),
	195	("Content-Length", str(len(body))),
	196	],
	197	body=body),
	198	self.assertBody(ntob("q: \xc2\xa3"))
	199
178	200	# An extra charset should be tried first, and continue to other default
179	201	# charsets if it doesn't match.
180	202	# Here, we add utf-16 as a charset but still pass a utf-8 body.
181	203	body = ntob("q=\xc2\xa3")
182	204	self.getPage('/decode/extra_charset', method='POST',
183		headers=[("Content-Type", "application/x-www-form-urlencoded"),
184		("Content-Length", str(len(body))),
185		],
186		body=body),
187		self.assertBody(ntob("q: \xc2\xa3"))
188
	205	headers=[(
	206	"Content-Type", "application/x-www-form-urlencoded"),
	207	("Content-Length", str(len(body))),
	208	],
	209	body=body),
	210	self.assertBody(ntob("q: \xc2\xa3"))
	211
189	212	# An extra charset should error if force is True and it doesn't match.
190	213	# Here, we force utf-16 as a charset but still pass a utf-8 body.
191	214	body = ntob("q=\xc2\xa3")
192	215	self.getPage('/decode/force_charset', method='POST',
193		headers=[("Content-Type", "application/x-www-form-urlencoded"),
194		("Content-Length", str(len(body))),
195		],
196		body=body),
197		self.assertErrorPage(400,
	216	headers=[(
	217	"Content-Type", "application/x-www-form-urlencoded"),
	218	("Content-Length", str(len(body))),
	219	],
	220	body=body),
	221	self.assertErrorPage(
	222	400,
198	223	"The request entity could not be decoded. The following charsets "
199	224	"were attempted: ['utf-16']")
200
	225
201	226	def test_multipart_decoding(self):
202	227	# Test the decoding of a multipart entity when the charset (utf16) is
203	228	# explicitly given.
204		body=ntob('\r\n'.join(['--X',
205		'Content-Type: text/plain;charset=utf-16',
206		'Content-Disposition: form-data; name="text"',
207		'',
208		'\xff\xfea\x00b\x00\x1c c\x00',
209		'--X',
210		'Content-Type: text/plain;charset=utf-16',
211		'Content-Disposition: form-data; name="submit"',
212		'',
213		'\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
214		'--X--']))
	229	body = ntob('\r\n'.join([
	230	'--X',
	231	'Content-Type: text/plain;charset=utf-16',
	232	'Content-Disposition: form-data; name="text"',
	233	'',
	234	'\xff\xfea\x00b\x00\x1c c\x00',
	235	'--X',
	236	'Content-Type: text/plain;charset=utf-16',
	237	'Content-Disposition: form-data; name="submit"',
	238	'',
	239	'\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
	240	'--X--'
	241	]))
215	242	self.getPage('/reqparams', method='POST',
216		headers=[("Content-Type", "multipart/form-data;boundary=X"),
217		("Content-Length", str(len(body))),
218		],
219		body=body),
220		self.assertBody(ntob("text: ab\xe2\x80\x9cc, submit: Create"))
221
	243	headers=[(
	244	"Content-Type", "multipart/form-data;boundary=X"),
	245	("Content-Length", str(len(body))),
	246	],
	247	body=body),
	248	self.assertBody(ntob("submit: Create, text: ab\xe2\x80\x9cc"))
	249
222	250	def test_multipart_decoding_no_charset(self):
223	251	# Test the decoding of a multipart entity when the charset (utf8) is
224	252	# NOT explicitly given, but is in the list of charsets to attempt.
225		body=ntob('\r\n'.join(['--X',
226		'Content-Disposition: form-data; name="text"',
227		'',
228		'\xe2\x80\x9c',
229		'--X',
230		'Content-Disposition: form-data; name="submit"',
231		'',
232		'Create',
233		'--X--']))
	253	body = ntob('\r\n'.join([
	254	'--X',
	255	'Content-Disposition: form-data; name="text"',
	256	'',
	257	'\xe2\x80\x9c',
	258	'--X',
	259	'Content-Disposition: form-data; name="submit"',
	260	'',
	261	'Create',
	262	'--X--'
	263	]))
234	264	self.getPage('/reqparams', method='POST',
235		headers=[("Content-Type", "multipart/form-data;boundary=X"),
236		("Content-Length", str(len(body))),
237		],
238		body=body),
239		self.assertBody(ntob("text: \xe2\x80\x9c, submit: Create"))
240
	265	headers=[(
	266	"Content-Type", "multipart/form-data;boundary=X"),
	267	("Content-Length", str(len(body))),
	268	],
	269	body=body),
	270	self.assertBody(ntob("submit: Create, text: \xe2\x80\x9c"))
	271
241	272	def test_multipart_decoding_no_successful_charset(self):
242	273	# Test the decoding of a multipart entity when the charset (utf16) is
243	274	# NOT explicitly given, and is NOT in the list of charsets to attempt.
244		body=ntob('\r\n'.join(['--X',
245		'Content-Disposition: form-data; name="text"',
246		'',
247		'\xff\xfea\x00b\x00\x1c c\x00',
248		'--X',
249		'Content-Disposition: form-data; name="submit"',
250		'',
251		'\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
252		'--X--']))
	275	body = ntob('\r\n'.join([
	276	'--X',
	277	'Content-Disposition: form-data; name="text"',
	278	'',
	279	'\xff\xfea\x00b\x00\x1c c\x00',
	280	'--X',
	281	'Content-Disposition: form-data; name="submit"',
	282	'',
	283	'\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
	284	'--X--'
	285	]))
253	286	self.getPage('/reqparams', method='POST',
254		headers=[("Content-Type", "multipart/form-data;boundary=X"),
255		("Content-Length", str(len(body))),
256		],
	287	headers=[(
	288	"Content-Type", "multipart/form-data;boundary=X"),
	289	("Content-Length", str(len(body))),
	290	],
257	291	body=body),
258	292	self.assertStatus(400)
259		self.assertErrorPage(400,
	293	self.assertErrorPage(
	294	400,
260	295	"The request entity could not be decoded. The following charsets "
261	296	"were attempted: ['us-ascii', 'utf-8']")
262
	297
263	298	def test_nontext(self):
264	299	self.getPage('/nontext')
265	300	self.assertHeader('Content-Type', 'application/binary;charset=utf-8')
266	301	self.assertBody('\x00\x01\x02\x03')
267
	302
268	303	def testEncoding(self):
269	304	# Default encoding should be utf-8
270	305	self.getPage('/mao_zedong')
271	306	self.assertBody(sing8)
272
	307
273	308	# Ask for utf-16.
274	309	self.getPage('/mao_zedong', [('Accept-Charset', 'utf-16')])
275	310	self.assertHeader('Content-Type', 'text/html;charset=utf-16')
276	311	self.assertBody(sing16)
277
	312
278	313	# Ask for multiple encodings. ISO-8859-1 should fail, and utf-16
279	314	# should be produced.
280	315	self.getPage('/mao_zedong', [('Accept-Charset',
281	316	'iso-8859-1;q=1, utf-16;q=0.5')])
282	317	self.assertBody(sing16)
283
	318
284	319	# The "*" value should default to our default_encoding, utf-8
285	320	self.getPage('/mao_zedong', [('Accept-Charset', '*;q=1, utf-7;q=.2')])
286	321	self.assertBody(sing8)
287
	322
288	323	# Only allow iso-8859-1, which should fail and raise 406.
289	324	self.getPage('/mao_zedong', [('Accept-Charset', 'iso-8859-1, *;q=0')])
290	325	self.assertStatus("406 Not Acceptable")
291	326	self.assertInBody("Your client sent this Accept-Charset header: "
292	327	"iso-8859-1, *;q=0. We tried these charsets: "
293	328	"iso-8859-1.")
294
	329
295	330	# Ask for x-mac-ce, which should be unknown. See ticket #569.
296	331	self.getPage('/mao_zedong', [('Accept-Charset',
297	332	'us-ascii, ISO-8859-1, x-mac-ce')])

299	334	self.assertInBody("Your client sent this Accept-Charset header: "
300	335	"us-ascii, ISO-8859-1, x-mac-ce. We tried these "
301	336	"charsets: ISO-8859-1, us-ascii, x-mac-ce.")
302
	337
303	338	# Test the 'encoding' arg to encode.
304	339	self.getPage('/utf8')
305	340	self.assertBody(sing8)
306	341	self.getPage('/utf8', [('Accept-Charset', 'us-ascii, ISO-8859-1')])
307	342	self.assertStatus("406 Not Acceptable")
308
	343
309	344	def testGzip(self):
310	345	zbuf = BytesIO()
311	346	zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)
312	347	zfile.write(ntob("Hello, world"))
313	348	zfile.close()
314
	349
315	350	self.getPage('/gzip/', headers=[("Accept-Encoding", "gzip")])
316	351	self.assertInBody(zbuf.getvalue()[:3])
317	352	self.assertHeader("Vary", "Accept-Encoding")
318	353	self.assertHeader("Content-Encoding", "gzip")
319
	354
320	355	# Test when gzip is denied.
321	356	self.getPage('/gzip/', headers=[("Accept-Encoding", "identity")])
322	357	self.assertHeader("Vary", "Accept-Encoding")
323	358	self.assertNoHeader("Content-Encoding")
324	359	self.assertBody("Hello, world")
325
	360
326	361	self.getPage('/gzip/', headers=[("Accept-Encoding", "gzip;q=0")])
327	362	self.assertHeader("Vary", "Accept-Encoding")
328	363	self.assertNoHeader("Content-Encoding")
329	364	self.assertBody("Hello, world")
330
	365
331	366	self.getPage('/gzip/', headers=[("Accept-Encoding", "*;q=0")])
332	367	self.assertStatus(406)
333	368	self.assertNoHeader("Content-Encoding")
334	369	self.assertErrorPage(406, "identity, gzip")
335
	370
336	371	# Test for ticket #147
337	372	self.getPage('/gzip/noshow', headers=[("Accept-Encoding", "gzip")])
338	373	self.assertNoHeader('Content-Encoding')
339	374	self.assertStatus(500)
340	375	self.assertErrorPage(500, pattern="IndexError\n")
341
	376
342	377	# In this case, there's nothing we can do to deliver a
343	378	# readable page, since 1) the gzip header is already set,
344	379	# and 2) we may have already written some of the body.
345	380	# The fix is to never stream yields when using gzip.
346	381	if (cherrypy.server.protocol_version == "HTTP/1.0" or
347		getattr(cherrypy.server, "using_apache", False)):
	382	getattr(cherrypy.server, "using_apache", False)):
348	383	self.getPage('/gzip/noshow_stream',
349	384	headers=[("Accept-Encoding", "gzip")])
350	385	self.assertHeader('Content-Encoding', 'gzip')

359	394	def test_UnicodeHeaders(self):
360	395	self.getPage('/cookies_and_headers')
361	396	self.assertBody('Any content')
362

+12

-11

cherrypy/test/test_etags.py less more

6	6
7	7	def setup_server():
8	8	class Root:
	9
9	10	def resource(self):
10	11	return "Oh wah ta goo Siam."
11	12	resource.exposed = True
12
	13
13	14	def fail(self, code):
14	15	code = int(code)
15	16	if 300 <= code <= 399:

17	18	else:
18	19	raise cherrypy.HTTPError(code)
19	20	fail.exposed = True
20
	21
21	22	def unicoded(self):
22	23	return ntou('I am a \u1ee4nicode string.', 'escape')
23	24	unicoded.exposed = True
24	25	# In Python 3, tools.encode is on by default
25	26	unicoded._cp_config = {'tools.encode.on': True}
26
	27
27	28	conf = {'/': {'tools.etags.on': True,
28	29	'tools.etags.autotags': True,
29	30	}}
30	31	cherrypy.tree.mount(Root(), config=conf)
31	32	setup_server = staticmethod(setup_server)
32
	33
33	34	def test_etags(self):
34	35	self.getPage("/resource")
35	36	self.assertStatus('200 OK')
36	37	self.assertHeader('Content-Type', 'text/html;charset=utf-8')
37	38	self.assertBody('Oh wah ta goo Siam.')
38	39	etag = self.assertHeader('ETag')
39
	40
40	41	# Test If-Match (both valid and invalid)
41	42	self.getPage("/resource", headers=[('If-Match', etag)])
42	43	self.assertStatus("200 OK")

46	47	self.assertStatus("200 OK")
47	48	self.getPage("/resource", headers=[('If-Match', "a bogus tag")])
48	49	self.assertStatus("412 Precondition Failed")
49
	50
50	51	# Test If-None-Match (both valid and invalid)
51	52	self.getPage("/resource", headers=[('If-None-Match', etag)])
52	53	self.assertStatus(304)
53		self.getPage("/resource", method='POST', headers=[('If-None-Match', etag)])
	54	self.getPage("/resource", method='POST',
	55	headers=[('If-None-Match', etag)])
54	56	self.assertStatus("412 Precondition Failed")
55	57	self.getPage("/resource", headers=[('If-None-Match', "*")])
56	58	self.assertStatus(304)
57	59	self.getPage("/resource", headers=[('If-None-Match', "a bogus tag")])
58	60	self.assertStatus("200 OK")
59
	61
60	62	def test_errors(self):
61	63	self.getPage("/resource")
62	64	self.assertStatus(200)
63	65	etag = self.assertHeader('ETag')
64
	66
65	67	# Test raising errors in page handler
66	68	self.getPage("/fail/412", headers=[('If-Match', etag)])
67	69	self.assertStatus(412)

71	73	self.assertStatus(412)
72	74	self.getPage("/fail/304", headers=[('If-None-Match', "*")])
73	75	self.assertStatus(304)
74
	76
75	77	def test_unicode_body(self):
76	78	self.getPage("/unicoded")
77	79	self.assertStatus(200)

79	81	self.getPage("/unicoded", headers=[('If-Match', etag1)])
80	82	self.assertStatus(200)
81	83	self.assertHeader('ETag', etag1)
82

+73

-40

cherrypy/test/test_http.py less more

10	10
11	11	def encode_multipart_formdata(files):
12	12	"""Return (content_type, body) ready for httplib.HTTP instance.
13
	13
14	14	files: a sequence of (name, filename, value) tuples for multipart uploads.
15	15	"""
16	16	BOUNDARY = '________ThIs_Is_tHe_bouNdaRY_$'

30	30	return content_type, body
31	31
32	32
33
34
35	33	from cherrypy.test import helper
36	34
	35
37	36	class HTTPTests(helper.CPWebCase):
	37
	38	def make_connection(self):
	39	if self.scheme == "https":
	40	return HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
	41	else:
	42	return HTTPConnection('%s:%s' % (self.interface(), self.PORT))
38	43
39	44	def setup_server():
40	45	class Root:
	46
41	47	def index(self, args, *kwargs):
42	48	return "Hello world!"
43	49	index.exposed = True
44
	50
45	51	def no_body(self, args, *kwargs):
46	52	return "Hello world!"
47	53	no_body.exposed = True
48	54	no_body._cp_config = {'request.process_request_body': False}
49
	55
50	56	def post_multipart(self, file):
51		"""Return a summary ("a * 65536\nb * 65536") of the uploaded file."""
	57	"""Return a summary ("a * 65536\nb * 65536") of the uploaded
	58	file.
	59	"""
52	60	contents = file.file.read()
53	61	summary = []
54	62	curchar = None

58	66	count += 1
59	67	else:
60	68	if count:
61		if py3k: curchar = chr(curchar)
	69	if py3k:
	70	curchar = chr(curchar)
62	71	summary.append("%s * %d" % (curchar, count))
63	72	count = 1
64	73	curchar = c
65	74	if count:
66		if py3k: curchar = chr(curchar)
	75	if py3k:
	76	curchar = chr(curchar)
67	77	summary.append("%s * %d" % (curchar, count))
68	78	return ", ".join(summary)
69	79	post_multipart.exposed = True
70
	80
	81	@cherrypy.expose
	82	def post_filename(self, myfile):
	83	'''Return the name of the file which was uploaded.'''
	84	return myfile.filename
	85
71	86	cherrypy.tree.mount(Root())
72	87	cherrypy.config.update({'server.max_request_body_size': 30000000})
73	88	setup_server = staticmethod(setup_server)
74
	89
75	90	def test_no_content_length(self):
76	91	# "The presence of a message-body in a request is signaled by the
77	92	# inclusion of a Content-Length or Transfer-Encoding header field in
78	93	# the request's message-headers."
79		#
	94	#
80	95	# Send a message with neither header and no body. Even though
81	96	# the request is of method POST, this should be OK because we set
82	97	# request.process_request_body to False for our handler.
83		if self.scheme == "https":
84		c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
85		else:
86		c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
	98	c = self.make_connection()
87	99	c.request("POST", "/no_body")
88	100	response = c.getresponse()
89	101	self.body = response.fp.read()
90	102	self.status = str(response.status)
91	103	self.assertStatus(200)
92	104	self.assertBody(ntob('Hello world!'))
93
	105
94	106	# Now send a message that has no Content-Length, but does send a body.
95	107	# Verify that CP times out the socket and responds
96	108	# with 411 Length Required.

103	115	self.body = response.fp.read()
104	116	self.status = str(response.status)
105	117	self.assertStatus(411)
106
	118
107	119	def test_post_multipart(self):
108	120	alphabet = "abcdefghijklmnopqrstuvwxyz"
109	121	# generate file contents for a large post
110	122	contents = "".join([c * 65536 for c in alphabet])
111
	123
112	124	# encode as multipart form data
113		files=[('file', 'file.txt', contents)]
	125	files = [('file', 'file.txt', contents)]
114	126	content_type, body = encode_multipart_formdata(files)
115	127	body = body.encode('Latin-1')
116
	128
117	129	# post file
118		if self.scheme == 'https':
119		c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
120		else:
121		c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
	130	c = self.make_connection()
122	131	c.putrequest('POST', '/post_multipart')
123	132	c.putheader('Content-Type', content_type)
124	133	c.putheader('Content-Length', str(len(body)))
125	134	c.endheaders()
126	135	c.send(body)
127
	136
128	137	response = c.getresponse()
129	138	self.body = response.fp.read()
130	139	self.status = str(response.status)
131	140	self.assertStatus(200)
132	141	self.assertBody(", ".join(["%s * 65536" % c for c in alphabet]))
	142
	143	def test_post_filename_with_commas(self):
	144	'''Testing that we can handle filenames with commas. This was
	145	reported as a bug in:
	146	https://bitbucket.org/cherrypy/cherrypy/issue/1146/'''
	147	# We'll upload a bunch of files with differing names.
	148	for fname in ['boop.csv', 'foo, bar.csv', 'bar, xxxx.csv', 'file"name.csv']:
	149	files = [('myfile', fname, 'yunyeenyunyue')]
	150	content_type, body = encode_multipart_formdata(files)
	151	body = body.encode('Latin-1')
	152
	153	# post file
	154	c = self.make_connection()
	155	c.putrequest('POST', '/post_filename')
	156	c.putheader('Content-Type', content_type)
	157	c.putheader('Content-Length', str(len(body)))
	158	c.endheaders()
	159	c.send(body)
	160
	161	response = c.getresponse()
	162	self.body = response.fp.read()
	163	self.status = str(response.status)
	164	self.assertStatus(200)
	165	self.assertBody(fname)
133	166
134	167	def test_malformed_request_line(self):
135	168	if getattr(cherrypy.server, "using_apache", False):
136	169	return self.skip("skipped due to known Apache differences...")
137
	170
138	171	# Test missing version in Request-Line
139		if self.scheme == 'https':
140		c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
141		else:
142		c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
	172	c = self.make_connection()
143	173	c._output(ntob('GET /'))
144	174	c._send_output()
145	175	if hasattr(c, 'strict'):

153	183	self.assertEqual(response.fp.read(22), ntob("Malformed Request-Line"))
154	184	c.close()
155	185
	186	def test_request_line_split_issue_1220(self):
	187	Request_URI = "/index?intervenant-entreprise-evenement_classaction=evenement-mailremerciements&_path=intervenant-entreprise-evenement&intervenant-entreprise-evenement_action-id=19404&intervenant-entreprise-evenement_id=19404&intervenant-entreprise_id=28092"
	188	self.assertEqual(len("GET %s HTTP/1.1\r\n" % Request_URI), 256)
	189	self.getPage(Request_URI)
	190	self.assertBody("Hello world!")
	191
156	192	def test_malformed_header(self):
157		if self.scheme == 'https':
158		c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
159		else:
160		c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
	193	c = self.make_connection()
161	194	c.putrequest('GET', '/')
162	195	c.putheader('Content-Type', 'text/plain')
163		# See http://www.cherrypy.org/ticket/941
	196	# See https://bitbucket.org/cherrypy/cherrypy/issue/941
164	197	c._output(ntob('Re, 1.2.3.4#015#012'))
165	198	c.endheaders()
166
	199
167	200	response = c.getresponse()
168	201	self.status = str(response.status)
169	202	self.assertStatus(400)
170	203	self.body = response.fp.read(20)
171	204	self.assertBody("Illegal header line.")
172
	205
173	206	def test_http_over_https(self):
174	207	if self.scheme != 'https':
175	208	return self.skip("skipped (not running HTTPS)... ")
176
	209
177	210	# Try connecting without SSL.
178	211	conn = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
179	212	conn.putrequest("GET", "/", skip_host=True)

201	234	try:
202	235	response.begin()
203	236	self.assertEqual(response.status, 400)
204		self.assertEqual(response.fp.read(22), ntob("Malformed Request-Line"))
	237	self.assertEqual(response.fp.read(22),
	238	ntob("Malformed Request-Line"))
205	239	c.close()
206	240	except socket.error:
207	241	e = sys.exc_info()[1]
208	242	# "Connection reset by peer" is also acceptable.
209	243	if e.errno != errno.ECONNRESET:
210	244	raise
211

+71

-29

cherrypy/test/test_httpauth.py less more

3	3
4	4	from cherrypy.test import helper
5	5
	6
6	7	class HTTPAuthTest(helper.CPWebCase):
7	8
8	9	def setup_server():
9	10	class Root:
	11
10	12	def index(self):
11	13	return "This is public."
12	14	index.exposed = True
13	15
14	16	class DigestProtected:
	17
15	18	def index(self):
16		return "Hello %s, you've been authorized." % cherrypy.request.login
	19	return "Hello %s, you've been authorized." % (
	20	cherrypy.request.login)
17	21	index.exposed = True
18	22
19	23	class BasicProtected:
	24
20	25	def index(self):
21		return "Hello %s, you've been authorized." % cherrypy.request.login
	26	return "Hello %s, you've been authorized." % (
	27	cherrypy.request.login)
22	28	index.exposed = True
23	29
24	30	class BasicProtected2:
	31
25	32	def index(self):
26		return "Hello %s, you've been authorized." % cherrypy.request.login
	33	return "Hello %s, you've been authorized." % (
	34	cherrypy.request.login)
27	35	index.exposed = True
28	36
29	37	def fetch_users():

31	39
32	40	def sha_password_encrypter(password):
33	41	return sha(ntob(password)).hexdigest()
34
	42
35	43	def fetch_password(username):
36	44	return sha(ntob('test')).hexdigest()
37	45
38		conf = {'/digest': {'tools.digest_auth.on': True,
39		'tools.digest_auth.realm': 'localhost',
40		'tools.digest_auth.users': fetch_users},
41		'/basic': {'tools.basic_auth.on': True,
42		'tools.basic_auth.realm': 'localhost',
43		'tools.basic_auth.users': {'test': md5(ntob('test')).hexdigest()}},
44		'/basic2': {'tools.basic_auth.on': True,
45		'tools.basic_auth.realm': 'localhost',
46		'tools.basic_auth.users': fetch_password,
47		'tools.basic_auth.encrypt': sha_password_encrypter}}
48
	46	conf = {
	47	'/digest': {
	48	'tools.digest_auth.on': True,
	49	'tools.digest_auth.realm': 'localhost',
	50	'tools.digest_auth.users': fetch_users
	51	},
	52	'/basic': {
	53	'tools.basic_auth.on': True,
	54	'tools.basic_auth.realm': 'localhost',
	55	'tools.basic_auth.users': {
	56	'test': md5(ntob('test')).hexdigest()
	57	}
	58	},
	59	'/basic2': {
	60	'tools.basic_auth.on': True,
	61	'tools.basic_auth.realm': 'localhost',
	62	'tools.basic_auth.users': fetch_password,
	63	'tools.basic_auth.encrypt': sha_password_encrypter
	64	}
	65	}
	66
49	67	root = Root()
50	68	root.digest = DigestProtected()
51	69	root.basic = BasicProtected()
52	70	root.basic2 = BasicProtected2()
53	71	cherrypy.tree.mount(root, config=conf)
54	72	setup_server = staticmethod(setup_server)
55
56	73
57	74	def testPublic(self):
58	75	self.getPage("/")

67	84
68	85	self.getPage('/basic/', [('Authorization', 'Basic dGVzdDp0ZX60')])
69	86	self.assertStatus(401)
70
	87
71	88	self.getPage('/basic/', [('Authorization', 'Basic dGVzdDp0ZXN0')])
72	89	self.assertStatus('200 OK')
73	90	self.assertBody("Hello test, you've been authorized.")

79	96
80	97	self.getPage('/basic2/', [('Authorization', 'Basic dGVzdDp0ZX60')])
81	98	self.assertStatus(401)
82
	99
83	100	self.getPage('/basic2/', [('Authorization', 'Basic dGVzdDp0ZXN0')])
84	101	self.assertStatus('200 OK')
85	102	self.assertBody("Hello test, you've been authorized.")

87	104	def testDigest(self):
88	105	self.getPage("/digest/")
89	106	self.assertStatus(401)
90
	107
91	108	value = None
92	109	for k, v in self.headers:
93	110	if k.lower() == "www-authenticate":

96	113	break
97	114
98	115	if value is None:
99		self._handlewebError("Digest authentification scheme was not found")
	116	self._handlewebError(
	117	"Digest authentification scheme was not found")
100	118
101	119	value = value[7:]
102	120	items = value.split(', ')

104	122	for item in items:
105	123	key, value = item.split('=')
106	124	tokens[key.lower()] = value
107
	125
108	126	missing_msg = "%s is missing"
109	127	bad_value_msg = "'%s' was expecting '%s' but found '%s'"
110	128	nonce = None
111	129	if 'realm' not in tokens:
112	130	self._handlewebError(missing_msg % 'realm')
113	131	elif tokens['realm'] != '"localhost"':
114		self._handlewebError(bad_value_msg % ('realm', '"localhost"', tokens['realm']))
	132	self._handlewebError(bad_value_msg %
	133	('realm', '"localhost"', tokens['realm']))
115	134	if 'nonce' not in tokens:
116	135	self._handlewebError(missing_msg % 'nonce')
117	136	else:

119	138	if 'algorithm' not in tokens:
120	139	self._handlewebError(missing_msg % 'algorithm')
121	140	elif tokens['algorithm'] != '"MD5"':
122		self._handlewebError(bad_value_msg % ('algorithm', '"MD5"', tokens['algorithm']))
	141	self._handlewebError(bad_value_msg %
	142	('algorithm', '"MD5"', tokens['algorithm']))
123	143	if 'qop' not in tokens:
124	144	self._handlewebError(missing_msg % 'qop')
125	145	elif tokens['qop'] != '"auth"':
126		self._handlewebError(bad_value_msg % ('qop', '"auth"', tokens['qop']))
	146	self._handlewebError(bad_value_msg %
	147	('qop', '"auth"', tokens['qop']))
127	148
128	149	# Test a wrong 'realm' value
129		base_auth = 'Digest username="test", realm="wrong realm", nonce="%s", uri="/digest/", algorithm=MD5, response="%s", qop=auth, nc=%s, cnonce="1522e61005789929"'
	150	base_auth = (
	151	'Digest '
	152	'username="test", '
	153	'realm="wrong realm", '
	154	'nonce="%s", '
	155	'uri="/digest/", '
	156	'algorithm=MD5, '
	157	'response="%s", '
	158	'qop=auth, '
	159	'nc=%s, '
	160	'cnonce="1522e61005789929"'
	161	)
130	162
131	163	auth = base_auth % (nonce, '', '00000001')
132	164	params = httpauth.parseAuthorization(auth)
133	165	response = httpauth._computeDigestResponse(params, 'test')
134
	166
135	167	auth = base_auth % (nonce, response, '00000001')
136	168	self.getPage('/digest/', [('Authorization', auth)])
137	169	self.assertStatus(401)
138	170
139	171	# Test that must pass
140		base_auth = 'Digest username="test", realm="localhost", nonce="%s", uri="/digest/", algorithm=MD5, response="%s", qop=auth, nc=%s, cnonce="1522e61005789929"'
	172	base_auth = (
	173	'Digest '
	174	'username="test", '
	175	'realm="localhost", '
	176	'nonce="%s", '
	177	'uri="/digest/", '
	178	'algorithm=MD5, '
	179	'response="%s", '
	180	'qop=auth, '
	181	'nc=%s, '
	182	'cnonce="1522e61005789929"'
	183	)
141	184
142	185	auth = base_auth % (nonce, '', '00000001')
143	186	params = httpauth.parseAuthorization(auth)
144	187	response = httpauth._computeDigestResponse(params, 'test')
145
	188
146	189	auth = base_auth % (nonce, response, '00000001')
147	190	self.getPage('/digest/', [('Authorization', auth)])
148	191	self.assertStatus('200 OK')
149	192	self.assertBody("Hello test, you've been authorized.")
150

-1

cherrypy/test/test_httplib.py less more

4	4
5	5
6	6	class UtilityTests(unittest.TestCase):
7
	7
8	8	def test_urljoin(self):
9	9	# Test all slash+atom combinations for SCRIPT_NAME and PATH_INFO
10	10	self.assertEqual(httputil.urljoin("/sn/", "/pi/"), "/sn/pi/")

+26

-5

cherrypy/test/test_json.py less more

2	2
3	3	from cherrypy._cpcompat import json
4	4
	5
5	6	class JsonTest(helper.CPWebCase):
	7
6	8	def setup_server():
7	9	class Root(object):
	10
8	11	def plain(self):
9	12	return 'hello'
10	13	plain.exposed = True

32	35	json_post.exposed = True
33	36	json_post._cp_config = {'tools.json_in.on': True}
34	37
	38	def json_cached(self):
	39	return 'hello there'
	40	json_cached.exposed = True
	41	json_cached._cp_config = {
	42	'tools.json_out.on': True,
	43	'tools.caching.on': True,
	44	}
	45
35	46	root = Root()
36	47	cherrypy.tree.mount(root)
37	48	setup_server = staticmethod(setup_server)
38
	49
39	50	def test_json_output(self):
40	51	if json is None:
41	52	self.skip("json not found ")
42	53	return
43
	54
44	55	self.getPage("/plain")
45	56	self.assertBody("hello")
46	57

57	68	if json is None:
58	69	self.skip("json not found ")
59	70	return
60
	71
61	72	body = '[13, "c"]'
62	73	headers = [('Content-Type', 'application/json'),
63	74	('Content-Length', str(len(body)))]
64	75	self.getPage("/json_post", method="POST", headers=headers, body=body)
65	76	self.assertBody('ok')
66
	77
67	78	body = '[13, "c"]'
68	79	headers = [('Content-Type', 'text/plain'),
69	80	('Content-Length', str(len(body)))]
70	81	self.getPage("/json_post", method="POST", headers=headers, body=body)
71	82	self.assertStatus(415, 'Expected an application/json content type')
72
	83
73	84	body = '[13, -]'
74	85	headers = [('Content-Type', 'application/json'),
75	86	('Content-Length', str(len(body)))]
76	87	self.getPage("/json_post", method="POST", headers=headers, body=body)
77	88	self.assertStatus(400, 'Invalid JSON document')
78	89
	90	def test_cached(self):
	91	if json is None:
	92	self.skip("json not found ")
	93	return
	94
	95	self.getPage("/json_cached")
	96	self.assertStatus(200, '"hello"')
	97
	98	self.getPage("/json_cached") # 2'nd time to hit cache
	99	self.assertStatus(200, '"hello"')

+22

-24

cherrypy/test/test_logging.py less more

15	15
16	16	def setup_server():
17	17	class Root:
18
	18
19	19	def index(self):
20	20	return "hello"
21	21	index.exposed = True
22
	22
23	23	def uni_code(self):
24	24	cherrypy.request.login = tartaros
25	25	cherrypy.request.remote.name = erebos
26	26	uni_code.exposed = True
27
	27
28	28	def slashes(self):
29	29	cherrypy.request.request_line = r'GET /slashed\path HTTP/1.1'
30	30	slashes.exposed = True
31
	31
32	32	def whitespace(self):
33	33	# User-Agent = "User-Agent" ":" 1*( product \| comment )
34	34	# comment = "(" *( ctext \| quoted-pair \| comment ) ")"

37	37	# LWS = [CRLF] 1*( SP \| HT )
38	38	cherrypy.request.headers['User-Agent'] = 'Browzuh (1.0\r\n\t\t.3)'
39	39	whitespace.exposed = True
40
	40
41	41	def as_string(self):
42	42	return "content"
43	43	as_string.exposed = True
44
	44
45	45	def as_yield(self):
46	46	yield "content"
47	47	as_yield.exposed = True
48
	48
49	49	def error(self):
50	50	raise ValueError()
51	51	error.exposed = True
52	52	error._cp_config = {'tools.log_tracebacks.on': True}
53
	53
54	54	root = Root()
55
56	55
57	56	cherrypy.config.update({'log.error_file': error_log,
58	57	'log.access_file': access_log,

60	59	cherrypy.tree.mount(root)
61	60
62	61
	62	from cherrypy.test import helper, logtest
63	63
64		from cherrypy.test import helper, logtest
65	64
66	65	class AccessLogTests(helper.CPWebCase, logtest.LogCase):
67	66	setup_server = staticmethod(setup_server)
68
	67
69	68	logfile = access_log
70
	69
71	70	def testNormalReturn(self):
72	71	self.markLog()
73	72	self.getPage("/as_string",

75	74	('User-Agent', 'Mozilla/5.0')])
76	75	self.assertBody('content')
77	76	self.assertStatus(200)
78
	77
79	78	intro = '%s - - [' % self.interface()
80
	79
81	80	self.assertLog(-1, intro)
82
	81
83	82	if [k for k, v in self.headers if k.lower() == 'content-length']:
84	83	self.assertLog(-1, '] "GET %s/as_string HTTP/1.1" 200 7 '
85	84	'"http://www.cherrypy.org/" "Mozilla/5.0"'

88	87	self.assertLog(-1, '] "GET %s/as_string HTTP/1.1" 200 - '
89	88	'"http://www.cherrypy.org/" "Mozilla/5.0"'
90	89	% self.prefix())
91
	90
92	91	def testNormalYield(self):
93	92	self.markLog()
94	93	self.getPage("/as_yield")
95	94	self.assertBody('content')
96	95	self.assertStatus(200)
97
	96
98	97	intro = '%s - - [' % self.interface()
99
	98
100	99	self.assertLog(-1, intro)
101	100	if [k for k, v in self.headers if k.lower() == 'content-length']:
102	101	self.assertLog(-1, '] "GET %s/as_yield HTTP/1.1" 200 7 "" ""' %

104	103	else:
105	104	self.assertLog(-1, '] "GET %s/as_yield HTTP/1.1" 200 - "" ""'
106	105	% self.prefix())
107
	106
108	107	def testEscapedOutput(self):
109	108	# Test unicode in access log pieces.
110	109	self.markLog()

118	117	# Test the erebos value. Included inline for your enlightenment.
119	118	# Note the 'r' prefix--those backslashes are literals.
120	119	self.assertLog(-1, r'\xce\x88\xcf\x81\xce\xb5\xce\xb2\xce\xbf\xcf\x82')
121
	120
122	121	# Test backslashes in output.
123	122	self.markLog()
124	123	self.getPage("/slashes")

127	126	self.assertLog(-1, ntob('"GET /slashed\\path HTTP/1.1"'))
128	127	else:
129	128	self.assertLog(-1, r'"GET /slashed\\path HTTP/1.1"')
130
	129
131	130	# Test whitespace in output.
132	131	self.markLog()
133	132	self.getPage("/whitespace")

138	137
139	138	class ErrorLogTests(helper.CPWebCase, logtest.LogCase):
140	139	setup_server = staticmethod(setup_server)
141
	140
142	141	logfile = error_log
143
	142
144	143	def testTracebacks(self):
145	144	# Test that tracebacks get written to the error log.
146	145	self.markLog()

153	152	self.assertLog(-3, 'raise ValueError()')
154	153	finally:
155	154	ignore.pop()
156

+46

-39

cherrypy/test/test_mime.py less more

2	2	import cherrypy
3	3	from cherrypy._cpcompat import ntob, ntou, sorted
4	4
	5
5	6	def setup_server():
6
	7
7	8	class Root:
8
	9
9	10	def multipart(self, parts):
10	11	return repr(parts)
11	12	multipart.exposed = True
12
	13
13	14	def multipart_form_data(self, **kwargs):
14	15	return repr(list(sorted(kwargs.items())))
15	16	multipart_form_data.exposed = True
16
	17
17	18	def flashupload(self, Filedata, Upload, Filename):
18	19	return ("Upload: %s, Filename: %s, Filedata: %r" %
19	20	(Upload, Filename, Filedata.file.read()))
20	21	flashupload.exposed = True
21
	22
22	23	cherrypy.config.update({'server.max_request_body_size': 0})
23	24	cherrypy.tree.mount(Root())
24	25

27	28
28	29	from cherrypy.test import helper
29	30
	31
30	32	class MultipartTest(helper.CPWebCase):
31	33	setup_server = staticmethod(setup_server)
32
	34
33	35	def test_multipart(self):
34	36	text_part = ntou("This is the text version")
35		html_part = ntou("""<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
	37	html_part = ntou(
	38	"""<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
36	39	<html>
37	40	<head>
38	41	<meta content="text/html;charset=ISO-8859-1" http-equiv="Content-Type">

57	60	headers = [
58	61	('Content-Type', 'multipart/mixed; boundary=123456789'),
59	62	('Content-Length', str(len(body))),
60		]
	63	]
61	64	self.getPage('/multipart', headers, "POST", body)
62	65	self.assertBody(repr([text_part, html_part]))
63
	66
64	67	def test_multipart_form_data(self):
65		body='\r\n'.join(['--X',
66		'Content-Disposition: form-data; name="foo"',
67		'',
68		'bar',
69		'--X',
70		# Test a param with more than one value.
71		# See http://www.cherrypy.org/ticket/1028
72		'Content-Disposition: form-data; name="baz"',
73		'',
74		'111',
75		'--X',
76		'Content-Disposition: form-data; name="baz"',
77		'',
78		'333',
79		'--X--'])
	68	body = '\r\n'.join([
	69	'--X',
	70	'Content-Disposition: form-data; name="foo"',
	71	'',
	72	'bar',
	73	'--X',
	74	# Test a param with more than one value.
	75	# See
	76	# https://bitbucket.org/cherrypy/cherrypy/issue/1028
	77	'Content-Disposition: form-data; name="baz"',
	78	'',
	79	'111',
	80	'--X',
	81	'Content-Disposition: form-data; name="baz"',
	82	'',
	83	'333',
	84	'--X--'
	85	])
80	86	self.getPage('/multipart_form_data', method='POST',
81		headers=[("Content-Type", "multipart/form-data;boundary=X"),
82		("Content-Length", str(len(body))),
83		],
	87	headers=[(
	88	"Content-Type", "multipart/form-data;boundary=X"),
	89	("Content-Length", str(len(body))),
	90	],
84	91	body=body),
85		self.assertBody(repr([('baz', [ntou('111'), ntou('333')]), ('foo', ntou('bar'))]))
	92	self.assertBody(
	93	repr([('baz', [ntou('111'), ntou('333')]), ('foo', ntou('bar'))]))
86	94
87	95
88	96	class SafeMultipartHandlingTest(helper.CPWebCase):

92	100	headers = [
93	101	('Accept', 'text/*'),
94	102	('Content-Type', 'multipart/form-data; '
95		'boundary=----------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6'),
	103	'boundary=----------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6'),
96	104	('User-Agent', 'Shockwave Flash'),
97	105	('Host', 'www.example.com:54583'),
98	106	('Content-Length', '499'),
99	107	('Connection', 'Keep-Alive'),
100	108	('Cache-Control', 'no-cache'),
101		]
	109	]
102	110	filedata = ntob('<?xml version="1.0" encoding="UTF-8"?>\r\n'
103	111	'<projectDescription>\r\n'
104	112	'</projectDescription>\r\n')

112	120	'name="Filedata"; filename=".project"\r\n'
113	121	'Content-Type: application/octet-stream\r\n'
114	122	'\r\n')
115		+ filedata +
	123	+ filedata +
116	124	ntob('\r\n'
117		'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6\r\n'
118		'Content-Disposition: form-data; name="Upload"\r\n'
119		'\r\n'
120		'Submit Query\r\n'
121		# Flash apps omit the trailing \r\n on the last line:
122		'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6--'
123		))
	125	'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6\r\n'
	126	'Content-Disposition: form-data; name="Upload"\r\n'
	127	'\r\n'
	128	'Submit Query\r\n'
	129	# Flash apps omit the trailing \r\n on the last line:
	130	'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6--'
	131	))
124	132	self.getPage('/flashupload', headers, "POST", body)
125	133	self.assertBody("Upload: Submit Query, Filename: .project, "
126	134	"Filedata: %r" % filedata)
127

+42

-34

cherrypy/test/test_misc_tools.py less more

7	7
8	8	def setup_server():
9	9	class Root:
	10
10	11	def index(self):
11	12	yield "Hello, world"
12	13	index.exposed = True
13	14	h = [("Content-Language", "en-GB"), ('Content-Type', 'text/plain')]
14	15	tools.response_headers(headers=h)(index)
15
	16
16	17	def other(self):
17	18	return "salut"
18	19	other.exposed = True

21	22	'tools.response_headers.headers': [("Content-Language", "fr"),
22	23	('Content-Type', 'text/plain')],
23	24	'tools.log_hooks.on': True,
24		}
25
26
	25	}
	26
27	27	class Accept:
28	28	_cp_config = {'tools.accept.on': True}
29
	29
30	30	def index(self):
31	31	return '<a href="feed">Atom feed</a>'
32	32	index.exposed = True
33
	33
34	34	# In Python 2.4+, we could use a decorator instead:
35	35	# @tools.accept('application/atom+xml')
36	36	def feed(self):

40	40	</feed>"""
41	41	feed.exposed = True
42	42	feed._cp_config = {'tools.accept.media': 'application/atom+xml'}
43
	43
44	44	def select(self):
45	45	# We could also write this: mtype = cherrypy.lib.accept.accept(...)
46	46	mtype = tools.accept.callable(['text/html', 'text/plain'])

49	49	else:
50	50	return "PAGE TITLE"
51	51	select.exposed = True
52
	52
53	53	class Referer:
	54
54	55	def accept(self):
55	56	return "Accepted!"
56	57	accept.exposed = True
57	58	reject = accept
58
	59
59	60	class AutoVary:
	61
60	62	def index(self):
61	63	# Read a header directly with 'get'
62	64	ae = cherrypy.request.headers.get('Accept-Encoding')

75	77	mtype = tools.accept.callable(['text/html', 'text/plain'])
76	78	return "Hello, world!"
77	79	index.exposed = True
78
	80
79	81	conf = {'/referer': {'tools.referer.on': True,
80	82	'tools.referer.pattern': r'http://[^/]*example\.com',
81	83	},

84	86	},
85	87	'/autovary': {'tools.autovary.on': True},
86	88	}
87
	89
88	90	root = Root()
89	91	root.referer = Referer()
90	92	root.accept = Accept()

95	97
96	98	from cherrypy.test import helper
97	99
	100
98	101	class ResponseHeadersTest(helper.CPWebCase):
99	102	setup_server = staticmethod(setup_server)
100	103

111	114
112	115	class RefererTest(helper.CPWebCase):
113	116	setup_server = staticmethod(setup_server)
114
	117
115	118	def testReferer(self):
116	119	self.getPage('/referer/accept')
117	120	self.assertErrorPage(403, 'Forbidden Referer header.')
118
	121
119	122	self.getPage('/referer/accept',
120	123	headers=[('Referer', 'http://www.example.com/')])
121	124	self.assertStatus(200)
122	125	self.assertBody('Accepted!')
123
	126
124	127	# Reject
125	128	self.getPage('/referer/reject')
126	129	self.assertStatus(200)
127	130	self.assertBody('Accepted!')
128
	131
129	132	self.getPage('/referer/reject',
130	133	headers=[('Referer', 'http://www.example.com/')])
131	134	self.assertErrorPage(403, 'Forbidden Referer header.')

133	136
134	137	class AcceptTest(helper.CPWebCase):
135	138	setup_server = staticmethod(setup_server)
136
	139
137	140	def test_Accept_Tool(self):
138	141	# Test with no header provided
139	142	self.getPage('/accept/feed')
140	143	self.assertStatus(200)
141	144	self.assertInBody('<title>Unknown Blog</title>')
142
	145
143	146	# Specify exact media type
144		self.getPage('/accept/feed', headers=[('Accept', 'application/atom+xml')])
145		self.assertStatus(200)
146		self.assertInBody('<title>Unknown Blog</title>')
147
	147	self.getPage('/accept/feed',
	148	headers=[('Accept', 'application/atom+xml')])
	149	self.assertStatus(200)
	150	self.assertInBody('<title>Unknown Blog</title>')
	151
148	152	# Specify matching media range
149	153	self.getPage('/accept/feed', headers=[('Accept', 'application/*')])
150	154	self.assertStatus(200)
151	155	self.assertInBody('<title>Unknown Blog</title>')
152
	156
153	157	# Specify all media ranges
154	158	self.getPage('/accept/feed', headers=[('Accept', '/')])
155	159	self.assertStatus(200)
156	160	self.assertInBody('<title>Unknown Blog</title>')
157
	161
158	162	# Specify unacceptable media types
159	163	self.getPage('/accept/feed', headers=[('Accept', 'text/html')])
160	164	self.assertErrorPage(406,
161	165	"Your client sent this Accept header: text/html. "
162	166	"But this resource only emits these media types: "
163	167	"application/atom+xml.")
164
	168
165	169	# Test resource where tool is 'on' but media is None (not set).
166	170	self.getPage('/accept/')
167	171	self.assertStatus(200)
168	172	self.assertBody('<a href="feed">Atom feed</a>')
169
	173
170	174	def test_accept_selection(self):
171	175	# Try both our expected media types
172	176	self.getPage('/accept/select', [('Accept', 'text/html')])

175	179	self.getPage('/accept/select', [('Accept', 'text/plain')])
176	180	self.assertStatus(200)
177	181	self.assertBody('PAGE TITLE')
178		self.getPage('/accept/select', [('Accept', 'text/plain, text/*;q=0.5')])
	182	self.getPage('/accept/select',
	183	[('Accept', 'text/plain, text/*;q=0.5')])
179	184	self.assertStatus(200)
180	185	self.assertBody('PAGE TITLE')
181
	186
182	187	# text/* and / should prefer text/html since it comes first
183	188	# in our 'media' argument to tools.accept
184	189	self.getPage('/accept/select', [('Accept', 'text/*')])

187	192	self.getPage('/accept/select', [('Accept', '/')])
188	193	self.assertStatus(200)
189	194	self.assertBody('<h2>Page Title</h2>')
190
	195
191	196	# Try unacceptable media types
192	197	self.getPage('/accept/select', [('Accept', 'application/xml')])
193		self.assertErrorPage(406,
194		"Your client sent this Accept header: application/xml. "
195		"But this resource only emits these media types: "
196		"text/html, text/plain.")
	198	self.assertErrorPage(
	199	406,
	200	"Your client sent this Accept header: application/xml. "
	201	"But this resource only emits these media types: "
	202	"text/html, text/plain.")
197	203
198	204
199	205	class AutoVaryTest(helper.CPWebCase):

202	208	def testAutoVary(self):
203	209	self.getPage('/autovary/')
204	210	self.assertHeader(
205		"Vary", 'Accept, Accept-Charset, Accept-Encoding, Host, If-Modified-Since, Range')
206
	211	"Vary",
	212	'Accept, Accept-Charset, Accept-Encoding, '
	213	'Host, If-Modified-Since, Range'
	214	)

+113

-101

cherrypy/test/test_objectmapping.py less more

9	9
10	10	def setup_server():
11	11	class Root:
	12
12	13	def index(self, name="world"):
13	14	return name
14	15	index.exposed = True
15
	16
16	17	def foobar(self):
17	18	return "bar"
18	19	foobar.exposed = True
19
	20
20	21	def default(self, params, *kwargs):
21	22	return "default:" + repr(params)
22	23	default.exposed = True
23
	24
24	25	def other(self):
25	26	return "other"
26	27	other.exposed = True
27
	28
28	29	def extra(self, *p):
29	30	return repr(p)
30	31	extra.exposed = True
31
	32
32	33	def redirect(self):
33	34	raise cherrypy.HTTPRedirect('dir1/', 302)
34	35	redirect.exposed = True
35
	36
36	37	def notExposed(self):
37	38	return "not exposed"
38
	39
39	40	def confvalue(self):
40	41	return cherrypy.request.config.get("user")
41	42	confvalue.exposed = True
42
	43
43	44	def redirect_via_url(self, path):
44	45	raise cherrypy.HTTPRedirect(cherrypy.url(path))
45	46	redirect_via_url.exposed = True
46
	47
47	48	def translate_html(self):
48	49	return "OK"
49	50	translate_html.exposed = True
50
	51
51	52	def mapped_func(self, ID=None):
52	53	return "ID is %s" % ID
53	54	mapped_func.exposed = True
54	55	setattr(Root, "Von B\xfclow", mapped_func)
55
56
	56
57	57	class Exposing:
	58
58	59	def base(self):
59	60	return "expose works!"
60	61	cherrypy.expose(base)
61	62	cherrypy.expose(base, "1")
62	63	cherrypy.expose(base, "2")
63
	64
64	65	class ExposingNewStyle(object):
	66
65	67	def base(self):
66	68	return "expose works!"
67	69	cherrypy.expose(base)
68	70	cherrypy.expose(base, "1")
69	71	cherrypy.expose(base, "2")
70
71
	72
72	73	class Dir1:
	74
73	75	def index(self):
74	76	return "index for dir1"
75	77	index.exposed = True
76
	78
77	79	def myMethod(self):
78		return "myMethod from dir1, path_info is:" + repr(cherrypy.request.path_info)
	80	return "myMethod from dir1, path_info is:" + repr(
	81	cherrypy.request.path_info)
79	82	myMethod.exposed = True
80	83	myMethod._cp_config = {'tools.trailing_slash.extra': True}
81
	84
82	85	def default(self, *params):
83	86	return "default for dir1, param is:" + repr(params)
84	87	default.exposed = True
85	88
86
87	89	class Dir2:
	90
88	91	def index(self):
89	92	return "index for dir2, path is:" + cherrypy.request.path_info
90	93	index.exposed = True
91
	94
92	95	def script_name(self):
93	96	return cherrypy.tree.script_name()
94	97	script_name.exposed = True
95
	98
96	99	def cherrypy_url(self):
97	100	return cherrypy.url("/extra")
98	101	cherrypy_url.exposed = True
99
	102
100	103	def posparam(self, *vpath):
101	104	return "/".join(vpath)
102	105	posparam.exposed = True
103
104
	106
105	107	class Dir3:
	108
106	109	def default(self):
107	110	return "default for dir3, not exposed"
108
	111
109	112	class Dir4:
	113
110	114	def index(self):
111	115	return "index for dir4, not exposed"
112
	116
113	117	class DefNoIndex:
	118
114	119	def default(self, *args):
115	120	raise cherrypy.HTTPRedirect("contact")
116	121	default.exposed = True
117
	122
118	123	# MethodDispatcher code
119	124	class ByMethod:
120	125	exposed = True
121
	126
122	127	def __init__(self, *things):
123	128	self.things = list(things)
124
	129
125	130	def GET(self):
126	131	return repr(self.things)
127
	132
128	133	def POST(self, thing):
129	134	self.things.append(thing)
130
	135
131	136	class Collection:
132	137	default = ByMethod('a', 'bit')
133
	138
134	139	Root.exposing = Exposing()
135	140	Root.exposingnew = ExposingNewStyle()
136	141	Root.dir1 = Dir1()

140	145	Root.defnoindex = DefNoIndex()
141	146	Root.bymethod = ByMethod('another')
142	147	Root.collection = Collection()
143
	148
144	149	d = cherrypy.dispatch.MethodDispatcher()
145	150	for url in script_names:
146	151	conf = {'/': {'user': (url or "/").split("/")[-2]},

148	153	'/collection': {'request.dispatch': d},
149	154	}
150	155	cherrypy.tree.mount(Root(), url, conf)
151
152
	156
153	157	class Isolated:
	158
154	159	def index(self):
155	160	return "made it!"
156	161	index.exposed = True
157
	162
158	163	cherrypy.tree.mount(Isolated(), "/isolated")
159
	164
160	165	class AnotherApp:
161
	166
162	167	exposed = True
163
	168
164	169	def GET(self):
165	170	return "milk"
166
167		cherrypy.tree.mount(AnotherApp(), "/app", {'/': {'request.dispatch': d}})
	171
	172	cherrypy.tree.mount(AnotherApp(), "/app",
	173	{'/': {'request.dispatch': d}})
168	174	setup_server = staticmethod(setup_server)
169	175
170
171	176	def testObjectMapping(self):
172	177	for url in script_names:
173	178	prefix = self.script_name = url
174
	179
175	180	self.getPage('/')
176	181	self.assertBody('world')
177
	182
178	183	self.getPage("/dir1/myMethod")
179		self.assertBody("myMethod from dir1, path_info is:'/dir1/myMethod'")
180
	184	self.assertBody(
	185	"myMethod from dir1, path_info is:'/dir1/myMethod'")
	186
181	187	self.getPage("/this/method/does/not/exist")
182		self.assertBody("default:('this', 'method', 'does', 'not', 'exist')")
183
	188	self.assertBody(
	189	"default:('this', 'method', 'does', 'not', 'exist')")
	190
184	191	self.getPage("/extra/too/much")
185	192	self.assertBody("('too', 'much')")
186
	193
187	194	self.getPage("/other")
188	195	self.assertBody('other')
189
	196
190	197	self.getPage("/notExposed")
191	198	self.assertBody("default:('notExposed',)")
192
	199
193	200	self.getPage("/dir1/dir2/")
194	201	self.assertBody('index for dir2, path is:/dir1/dir2/')
195
	202
196	203	# Test omitted trailing slash (should be redirected by default).
197	204	self.getPage("/dir1/dir2")
198	205	self.assertStatus(301)
199	206	self.assertHeader('Location', '%s/dir1/dir2/' % self.base())
200
	207
201	208	# Test extra trailing slash (should be redirected if configured).
202	209	self.getPage("/dir1/myMethod/")
203	210	self.assertStatus(301)
204	211	self.assertHeader('Location', '%s/dir1/myMethod' % self.base())
205
	212
206	213	# Test that default method must be exposed in order to match.
207	214	self.getPage("/dir1/dir2/dir3/dir4/index")
208		self.assertBody("default for dir1, param is:('dir2', 'dir3', 'dir4', 'index')")
209
	215	self.assertBody(
	216	"default for dir1, param is:('dir2', 'dir3', 'dir4', 'index')")
	217
210	218	# Test *vpath when default() is defined but not index()
211	219	# This also tests HTTPRedirect with default.
212	220	self.getPage("/defnoindex")

214	222	self.assertHeader('Location', '%s/contact' % self.base())
215	223	self.getPage("/defnoindex/")
216	224	self.assertStatus((302, 303))
217		self.assertHeader('Location', '%s/defnoindex/contact' % self.base())
	225	self.assertHeader('Location', '%s/defnoindex/contact' %
	226	self.base())
218	227	self.getPage("/defnoindex/page")
219	228	self.assertStatus((302, 303))
220		self.assertHeader('Location', '%s/defnoindex/contact' % self.base())
221
	229	self.assertHeader('Location', '%s/defnoindex/contact' %
	230	self.base())
	231
222	232	self.getPage("/redirect")
223	233	self.assertStatus('302 Found')
224	234	self.assertHeader('Location', '%s/dir1/' % self.base())
225
	235
226	236	if not getattr(cherrypy.server, "using_apache", False):
227		# Test that we can use URL's which aren't all valid Python identifiers
	237	# Test that we can use URL's which aren't all valid Python
	238	# identifiers
228	239	# This should also test the %XX-unquoting of URL's.
229	240	self.getPage("/Von%20B%fclow?ID=14")
230	241	self.assertBody("ID is 14")
231
	242
232	243	# Test that %2F in the path doesn't get unquoted too early;
233	244	# that is, it should not be used to separate path components.
234	245	# See ticket #393.
235	246	self.getPage("/page%2Fname")
236	247	self.assertBody("default:('page/name',)")
237
	248
238	249	self.getPage("/dir1/dir2/script_name")
239	250	self.assertBody(url)
240	251	self.getPage("/dir1/dir2/cherrypy_url")
241	252	self.assertBody("%s/extra" % self.base())
242
	253
243	254	# Test that configs don't overwrite each other from diferent apps
244	255	self.getPage("/confvalue")
245	256	self.assertBody((url or "/").split("/")[-2])
246
	257
247	258	self.script_name = ""
248
	259
249	260	# Test absoluteURI's in the Request-Line
250	261	self.getPage('http://%s:%s/' % (self.interface(), self.PORT))
251	262	self.assertBody('world')
252
	263
253	264	self.getPage('http://%s:%s/abs/?service=http://192.168.0.1/x/y/z' %
254	265	(self.interface(), self.PORT))
255	266	self.assertBody("default:('abs',)")
256
	267
257	268	self.getPage('/rel/?service=http://192.168.120.121:8000/x/y/z')
258	269	self.assertBody("default:('rel',)")
259
	270
260	271	# Test that the "isolated" app doesn't leak url's into the root app.
261	272	# If it did leak, Root.default() would answer with
262	273	# "default:('isolated', 'doesnt', 'exist')".

265	276	self.assertBody("made it!")
266	277	self.getPage("/isolated/doesnt/exist")
267	278	self.assertStatus("404 Not Found")
268
	279
269	280	# Make sure /foobar maps to Root.foobar and not to the app
270		# mounted at /foo. See http://www.cherrypy.org/ticket/573
	281	# mounted at /foo. See
	282	# https://bitbucket.org/cherrypy/cherrypy/issue/573
271	283	self.getPage("/foobar")
272	284	self.assertBody("bar")
273
	285
274	286	def test_translate(self):
275	287	self.getPage("/translate_html")
276	288	self.assertStatus("200 OK")
277	289	self.assertBody("OK")
278
	290
279	291	self.getPage("/translate.html")
280	292	self.assertStatus("200 OK")
281	293	self.assertBody("OK")
282
	294
283	295	self.getPage("/translate-html")
284	296	self.assertStatus("200 OK")
285	297	self.assertBody("OK")
286
	298
287	299	def test_redir_using_url(self):
288	300	for url in script_names:
289	301	prefix = self.script_name = url
290
	302
291	303	# Test the absolute path to the parent (leading slash)
292	304	self.getPage('/redirect_via_url?path=./')
293	305	self.assertStatus(('302 Found', '303 See Other'))
294	306	self.assertHeader('Location', '%s/' % self.base())
295
	307
296	308	# Test the relative path to the parent (no leading slash)
297	309	self.getPage('/redirect_via_url?path=./')
298	310	self.assertStatus(('302 Found', '303 See Other'))
299	311	self.assertHeader('Location', '%s/' % self.base())
300
	312
301	313	# Test the absolute path to the parent (leading slash)
302	314	self.getPage('/redirect_via_url/?path=./')
303	315	self.assertStatus(('302 Found', '303 See Other'))
304	316	self.assertHeader('Location', '%s/' % self.base())
305
	317
306	318	# Test the relative path to the parent (no leading slash)
307	319	self.getPage('/redirect_via_url/?path=./')
308	320	self.assertStatus(('302 Found', '303 See Other'))
309	321	self.assertHeader('Location', '%s/' % self.base())
310
	322
311	323	def testPositionalParams(self):
312	324	self.getPage("/dir1/dir2/posparam/18/24/hut/hike")
313	325	self.assertBody("18/24/hut/hike")
314
	326
315	327	# intermediate index methods should not receive posparams;
316	328	# only the "final" index method should do so.
317	329	self.getPage("/dir1/dir2/5/3/sir")
318	330	self.assertBody("default for dir1, param is:('dir2', '5', '3', 'sir')")
319
	331
320	332	# test that extra positional args raises an 404 Not Found
321		# See http://www.cherrypy.org/ticket/733.
	333	# See https://bitbucket.org/cherrypy/cherrypy/issue/733.
322	334	self.getPage("/dir1/dir2/script_name/extra/stuff")
323	335	self.assertStatus(404)
324
	336
325	337	def testExpose(self):
326	338	# Test the cherrypy.expose function/decorator
327	339	self.getPage("/exposing/base")
328	340	self.assertBody("expose works!")
329
	341
330	342	self.getPage("/exposing/1")
331	343	self.assertBody("expose works!")
332
	344
333	345	self.getPage("/exposing/2")
334	346	self.assertBody("expose works!")
335
	347
336	348	self.getPage("/exposingnew/base")
337	349	self.assertBody("expose works!")
338
	350
339	351	self.getPage("/exposingnew/1")
340	352	self.assertBody("expose works!")
341
	353
342	354	self.getPage("/exposingnew/2")
343	355	self.assertBody("expose works!")
344
	356
345	357	def testMethodDispatch(self):
346	358	self.getPage("/bymethod")
347	359	self.assertBody("['another']")
348	360	self.assertHeader('Allow', 'GET, HEAD, POST')
349
	361
350	362	self.getPage("/bymethod", method="HEAD")
351	363	self.assertBody("")
352	364	self.assertHeader('Allow', 'GET, HEAD, POST')
353
	365
354	366	self.getPage("/bymethod", method="POST", body="thing=one")
355	367	self.assertBody("")
356	368	self.assertHeader('Allow', 'GET, HEAD, POST')
357
	369
358	370	self.getPage("/bymethod")
359	371	self.assertBody(repr(['another', ntou('one')]))
360	372	self.assertHeader('Allow', 'GET, HEAD, POST')
361
	373
362	374	self.getPage("/bymethod", method="PUT")
363	375	self.assertErrorPage(405)
364	376	self.assertHeader('Allow', 'GET, HEAD, POST')
365
	377
366	378	# Test default with posparams
367	379	self.getPage("/collection/silly", method="POST")
368	380	self.getPage("/collection", method="GET")
369	381	self.assertBody("['a', 'bit', 'silly']")
370
	382
371	383	# Test custom dispatcher set on app root (see #737).
372	384	self.getPage("/app")
373	385	self.assertBody("milk")
374	386
375	387	def testTreeMounting(self):
376	388	class Root(object):
	389
377	390	def hello(self):
378	391	return "Hello world!"
379	392	hello.exposed = True
380
381		# When mounting an application instance,
	393
	394	# When mounting an application instance,
382	395	# we can't specify a different script name in the call to mount.
383	396	a = Application(Root(), '/somewhere')
384	397	self.assertRaises(ValueError, cherrypy.tree.mount, a, '/somewhereelse')
385
	398
386	399	# When mounting an application instance...
387	400	a = Application(Root(), '/somewhere')
388	401	# ...we MUST allow in identical script name in the call to mount...

394	407	cherrypy.tree.mount(a)
395	408	self.getPage('/somewhere/hello')
396	409	self.assertStatus(200)
397
	410
398	411	# In addition, we MUST be able to create an Application using
399	412	# script_name == None for access to the wsgi_environ.
400	413	a = Application(Root(), script_name=None)
401	414	# However, this does not apply to tree.mount
402	415	self.assertRaises(TypeError, cherrypy.tree.mount, a, None)
403

+41

-33

cherrypy/test/test_proxy.py less more

6	6	class ProxyTest(helper.CPWebCase):
7	7
8	8	def setup_server():
9
	9
10	10	# Set up site
11	11	cherrypy.config.update({
12	12	'tools.proxy.on': True,
13	13	'tools.proxy.base': 'www.mydomain.test',
14		})
15
	14	})
	15
16	16	# Set up application
17
	17
18	18	class Root:
19
	19
20	20	def __init__(self, sn):
21	21	# Calculate a URL outside of any requests.
22		self.thisnewpage = cherrypy.url("/this/new/page", script_name=sn)
23
	22	self.thisnewpage = cherrypy.url(
	23	"/this/new/page", script_name=sn)
	24
24	25	def pageurl(self):
25	26	return self.thisnewpage
26	27	pageurl.exposed = True
27
	28
28	29	def index(self):
29	30	raise cherrypy.HTTPRedirect('dummy')
30	31	index.exposed = True
31
	32
32	33	def remoteip(self):
33	34	return cherrypy.request.remote.ip
34	35	remoteip.exposed = True
35
	36
36	37	def xhost(self):
37	38	raise cherrypy.HTTPRedirect('blah')
38	39	xhost.exposed = True
39	40	xhost._cp_config = {'tools.proxy.local': 'X-Host',
40	41	'tools.trailing_slash.extra': True,
41	42	}
42
	43
43	44	def base(self):
44	45	return cherrypy.request.base
45	46	base.exposed = True
46
	47
47	48	def ssl(self):
48	49	return cherrypy.request.base
49	50	ssl.exposed = True
50	51	ssl._cp_config = {'tools.proxy.scheme': 'X-Forwarded-Ssl'}
51
	52
52	53	def newurl(self):
53	54	return ("Browse to <a href='%s'>this page</a>."
54	55	% cherrypy.url("/this/new/page"))
55	56	newurl.exposed = True
56
	57
57	58	for sn in script_names:
58	59	cherrypy.tree.mount(Root(sn), sn)
59	60	setup_server = staticmethod(setup_server)
60
	61
61	62	def testProxy(self):
62	63	self.getPage("/")
63	64	self.assertHeader('Location',
64	65	"%s://www.mydomain.test%s/dummy" %
65	66	(self.scheme, self.prefix()))
66
	67
67	68	# Test X-Forwarded-Host (Apache 1.3.33+ and Apache 2)
68		self.getPage("/", headers=[('X-Forwarded-Host', 'http://www.example.test')])
	69	self.getPage(
	70	"/", headers=[('X-Forwarded-Host', 'http://www.example.test')])
69	71	self.assertHeader('Location', "http://www.example.test/dummy")
70	72	self.getPage("/", headers=[('X-Forwarded-Host', 'www.example.test')])
71		self.assertHeader('Location', "%s://www.example.test/dummy" % self.scheme)
	73	self.assertHeader('Location', "%s://www.example.test/dummy" %
	74	self.scheme)
72	75	# Test multiple X-Forwarded-Host headers
73	76	self.getPage("/", headers=[
74	77	('X-Forwarded-Host', 'http://www.example.test, www.cherrypy.test'),
75		])
	78	])
76	79	self.assertHeader('Location', "http://www.example.test/dummy")
77
	80
78	81	# Test X-Forwarded-For (Apache2)
79	82	self.getPage("/remoteip",
80	83	headers=[('X-Forwarded-For', '192.168.0.20')])
81	84	self.assertBody("192.168.0.20")
	85	#Fix bug #1268
82	86	self.getPage("/remoteip",
83		headers=[('X-Forwarded-For', '67.15.36.43, 192.168.0.20')])
84		self.assertBody("192.168.0.20")
85
	87	headers=[
	88	('X-Forwarded-For', '67.15.36.43, 192.168.0.20')
	89	])
	90	self.assertBody("67.15.36.43")
	91
86	92	# Test X-Host (lighttpd; see https://trac.lighttpd.net/trac/ticket/418)
87	93	self.getPage("/xhost", headers=[('X-Host', 'www.example.test')])
88		self.assertHeader('Location', "%s://www.example.test/blah" % self.scheme)
89
	94	self.assertHeader('Location', "%s://www.example.test/blah" %
	95	self.scheme)
	96
90	97	# Test X-Forwarded-Proto (lighttpd)
91	98	self.getPage("/base", headers=[('X-Forwarded-Proto', 'https')])
92	99	self.assertBody("https://www.mydomain.test")
93
	100
94	101	# Test X-Forwarded-Ssl (webfaction?)
95	102	self.getPage("/ssl", headers=[('X-Forwarded-Ssl', 'on')])
96	103	self.assertBody("https://www.mydomain.test")
97
	104
98	105	# Test cherrypy.url()
99	106	for sn in script_names:
100	107	# Test the value inside requests
101	108	self.getPage(sn + "/newurl")
102		self.assertBody("Browse to <a href='%s://www.mydomain.test" % self.scheme
103		+ sn + "/this/new/page'>this page</a>.")
	109	self.assertBody(
	110	"Browse to <a href='%s://www.mydomain.test" % self.scheme
	111	+ sn + "/this/new/page'>this page</a>.")
104	112	self.getPage(sn + "/newurl", headers=[('X-Forwarded-Host',
105	113	'http://www.example.test')])
106	114	self.assertBody("Browse to <a href='http://www.example.test"
107	115	+ sn + "/this/new/page'>this page</a>.")
108
	116
109	117	# Test the value outside requests
110	118	port = ""
111	119	if self.scheme == "http" and self.PORT != 80:

120	128	% (self.scheme, host, port, sn))
121	129	self.getPage(sn + "/pageurl")
122	130	self.assertBody(expected)
123
124		# Test trailing slash (see http://www.cherrypy.org/ticket/562).
	131
	132	# Test trailing slash (see
	133	# https://bitbucket.org/cherrypy/cherrypy/issue/562).
125	134	self.getPage("/xhost/", headers=[('X-Host', 'www.example.test')])
126	135	self.assertHeader('Location', "%s://www.example.test/xhost"
127	136	% self.scheme)
128

-8

cherrypy/test/test_refleaks.py less more

14	14	class ReferenceTests(helper.CPWebCase):
15	15
16	16	def setup_server():
17
	17
18	18	class Root:
	19
19	20	def index(self, args, *kwargs):
20	21	cherrypy.request.thing = data
21	22	return "Hello world!"
22	23	index.exposed = True
23
	24
24	25	cherrypy.tree.mount(Root())
25	26	setup_server = staticmethod(setup_server)
26
	27
27	28	def test_threadlocal_garbage(self):
28	29	success = []
29
	30
30	31	def getpage():
31	32	host = '%s:%s' % (self.interface(), self.PORT)
32	33	if self.scheme == 'https':

43	44	finally:
44	45	c.close()
45	46	success.append(True)
46
	47
47	48	ITERATIONS = 25
48	49	ts = []
49	50	for _ in range(ITERATIONS):
50	51	t = threading.Thread(target=getpage)
51	52	ts.append(t)
52	53	t.start()
53
	54
54	55	for t in ts:
55	56	t.join()
56
	57
57	58	self.assertEqual(len(success), ITERATIONS)
58

+241

-182

cherrypy/test/test_request_obj.py less more

17	17
18	18	from cherrypy.test import helper
19	19
	20
20	21	class RequestObjectTests(helper.CPWebCase):
21	22
22	23	def setup_server():
23	24	class Root:
24
	25
25	26	def index(self):
26	27	return "hello"
27	28	index.exposed = True
28
	29
29	30	def scheme(self):
30	31	return cherrypy.request.scheme
31	32	scheme.exposed = True
32
	33
33	34	root = Root()
34
35
	35
36	36	class TestType(type):
37		"""Metaclass which automatically exposes all functions in each subclass,
38		and adds an instance of the subclass as an attribute of root.
	37	"""Metaclass which automatically exposes all functions in each
	38	subclass, and adds an instance of the subclass as an attribute
	39	of root.
39	40	"""
40	41	def __init__(cls, name, bases, dct):
41	42	type.__init__(cls, name, bases, dct)

51	52	return cherrypy.request.path_info
52	53
53	54	class Params(Test):
54
	55
55	56	def index(self, thing):
56	57	return repr(thing)
57
	58
58	59	def ismap(self, x, y):
59	60	return "Coordinates: %s, %s" % (x, y)
60
	61
61	62	def default(self, args, *kwargs):
62		return "args: %s kwargs: %s" % (args, kwargs)
	63	return "args: %s kwargs: %s" % (args, sorted(kwargs.items()))
63	64	default._cp_config = {'request.query_string_encoding': 'latin1'}
64
65	65
66	66	class ParamErrorsCallable(object):
67	67	exposed = True
	68
68	69	def __call__(self):
69	70	return "data"
70	71

109	110	raise_type_error.exposed = True
110	111
111	112	def raise_type_error_with_default_param(self, x, y=None):
112		return '%d' % 'a' # throw an exception
	113	return '%d' % 'a' # throw an exception
113	114	raise_type_error_with_default_param.exposed = True
114	115
115	116	def callable_error_page(status, **kwargs):
116		return "Error %s - Well, I'm very sorry but you haven't paid!" % status
117
118
	117	return "Error %s - Well, I'm very sorry but you haven't paid!" % (
	118	status)
	119
119	120	class Error(Test):
120
	121
121	122	_cp_config = {'tools.log_tracebacks.on': True,
122	123	}
123
	124
124	125	def reason_phrase(self):
125	126	raise cherrypy.HTTPError("410 Gone fishin'")
126
	127
127	128	def custom(self, err='404'):
128		raise cherrypy.HTTPError(int(err), "No, <b>really</b>, not found!")
129		custom._cp_config = {'error_page.404': os.path.join(localDir, "static/index.html"),
130		'error_page.401': callable_error_page,
131		}
132
	129	raise cherrypy.HTTPError(
	130	int(err), "No, <b>really</b>, not found!")
	131	custom._cp_config = {
	132	'error_page.404': os.path.join(localDir, "static/index.html"),
	133	'error_page.401': callable_error_page,
	134	}
	135
133	136	def custom_default(self):
134		return 1 + 'a' # raise an unexpected error
135		custom_default._cp_config = {'error_page.default': callable_error_page}
136
	137	return 1 + 'a' # raise an unexpected error
	138	custom_default._cp_config = {
	139	'error_page.default': callable_error_page}
	140
137	141	def noexist(self):
138	142	raise cherrypy.HTTPError(404, "No, <b>really</b>, not found!")
139	143	noexist._cp_config = {'error_page.404': "nonexistent.html"}
140
	144
141	145	def page_method(self):
142	146	raise ValueError()
143
	147
144	148	def page_yield(self):
145	149	yield "howdy"
146	150	raise ValueError()
147
	151
148	152	def page_streamed(self):
149	153	yield "word up"
150	154	raise ValueError()
151	155	yield "very oops"
152	156	page_streamed._cp_config = {"response.stream": True}
153
	157
154	158	def cause_err_in_finalize(self):
155	159	# Since status must start with an int, this should error.
156	160	cherrypy.response.status = "ZOO OK"
157		cause_err_in_finalize._cp_config = {'request.show_tracebacks': False}
158
	161	cause_err_in_finalize._cp_config = {
	162	'request.show_tracebacks': False}
	163
159	164	def rethrow(self):
160		"""Test that an error raised here will be thrown out to the server."""
	165	"""Test that an error raised here will be thrown out to
	166	the server.
	167	"""
161	168	raise ValueError()
162	169	rethrow._cp_config = {'request.throw_errors': True}
163
164
	170
165	171	class Expect(Test):
166
	172
167	173	def expectation_failed(self):
168	174	expect = cherrypy.request.headers.elements("Expect")
169	175	if expect and expect[0].value != '100-continue':

171	177	raise cherrypy.HTTPError(417, 'Expectation Failed')
172	178
173	179	class Headers(Test):
174
	180
175	181	def default(self, headername):
176	182	"""Spit back out the value for the requested header."""
177	183	return cherrypy.request.headers[headername]
178
	184
179	185	def doubledheaders(self):
180		# From http://www.cherrypy.org/ticket/165:
181		# "header field names should not be case sensitive sayes the rfc.
182		# if i set a headerfield in complete lowercase i end up with two
183		# header fields, one in lowercase, the other in mixed-case."
184
	186	# From https://bitbucket.org/cherrypy/cherrypy/issue/165:
	187	# "header field names should not be case sensitive sayes the
	188	# rfc. if i set a headerfield in complete lowercase i end up
	189	# with two header fields, one in lowercase, the other in
	190	# mixed-case."
	191
185	192	# Set the most common headers
186	193	hMap = cherrypy.response.headers
187	194	hMap['content-type'] = "text/html"

191	198	% (cherrypy.request.local.ip,
192	199	cherrypy.request.local.port,
193	200	cherrypy.request.scheme))
194
	201
195	202	# Set a rare header for fun
196	203	hMap['Expires'] = 'Thu, 01 Dec 2194 16:00:00 GMT'
197
	204
198	205	return "double header test"
199
	206
200	207	def ifmatch(self):
201	208	val = cherrypy.request.headers['If-Match']
202	209	assert isinstance(val, unicodestr)
203	210	cherrypy.response.headers['ETag'] = val
204	211	return val
205
206
	212
207	213	class HeaderElements(Test):
208
	214
209	215	def get_elements(self, headername):
210	216	e = cherrypy.request.headers.elements(headername)
211	217	return "\n".join([unicodestr(x) for x in e])
212
213
	218
214	219	class Method(Test):
215
	220
216	221	def index(self):
217	222	m = cherrypy.request.method
218	223	if m in defined_http_methods or m == "CONNECT":
219	224	return m
220
	225
221	226	if m == "LINK":
222	227	raise cherrypy.HTTPError(405)
223	228	else:
224	229	raise cherrypy.HTTPError(501)
225
	230
226	231	def parameterized(self, data):
227	232	return data
228
	233
229	234	def request_body(self):
230	235	# This should be a file object (temp file),
231	236	# which CP will just pipe back out if we tell it to.
232	237	return cherrypy.request.body
233
	238
234	239	def reachable(self):
235	240	return "success"
236	241
237	242	class Divorce:
	243
238	244	"""HTTP Method handlers shouldn't collide with normal method names.
239		For example, a GET-handler shouldn't collide with a method named 'get'.
240
241		If you build HTTP method dispatching into CherryPy, rewrite this class
242		to use your new dispatch mechanism and make sure that:
	245	For example, a GET-handler shouldn't collide with a method named
	246	'get'.
	247
	248	If you build HTTP method dispatching into CherryPy, rewrite this
	249	class to use your new dispatch mechanism and make sure that:
243	250	"GET /divorce HTTP/1.1" maps to divorce.index() and
244	251	"GET /divorce/get?ID=13 HTTP/1.1" maps to divorce.get()
245	252	"""
246
	253
247	254	documents = {}
248
	255
249	256	def index(self):
250	257	yield "<h1>Choose your document</h1>\n"
251	258	yield "<ul>\n"
252	259	for id, contents in self.documents.items():
253		yield (" <li><a href='/divorce/get?ID=%s'>%s</a>: %s</li>\n"
254		% (id, id, contents))
	260	yield (
	261	" <li><a href='/divorce/get?ID=%s'>%s</a>:"
	262	" %s</li>\n" % (id, id, contents))
255	263	yield "</ul>"
256	264	index.exposed = True
257
	265
258	266	def get(self, ID):
259	267	return ("Divorce document %s: %s" %
260	268	(ID, self.documents.get(ID, "empty")))

262	270
263	271	root.divorce = Divorce()
264	272
265
266	273	class ThreadLocal(Test):
267
	274
268	275	def index(self):
269	276	existing = repr(getattr(cherrypy.request, "asdf", None))
270	277	cherrypy.request.asdf = "rassfrassin"
271	278	return existing
272
	279
273	280	appconf = {
274		'/method': {'request.methods_with_bodies': ("POST", "PUT", "PROPFIND")},
275		}
	281	'/method': {
	282	'request.methods_with_bodies': ("POST", "PUT", "PROPFIND")
	283	},
	284	}
276	285	cherrypy.tree.mount(root, config=appconf)
277	286	setup_server = staticmethod(setup_server)
278	287

292	301	def testParams(self):
293	302	self.getPage("/params/?thing=a")
294	303	self.assertBody(repr(ntou("a")))
295
	304
296	305	self.getPage("/params/?thing=a&thing=b&thing=c")
297	306	self.assertBody(repr([ntou('a'), ntou('b'), ntou('c')]))
298	307

302	311	self.assertInBody("Missing parameters: thing")
303	312	self.getPage("/params/?thing=meeting&notathing=meeting")
304	313	self.assertInBody("Unexpected query string parameters: notathing")
305
	314
306	315	# Test ability to turn off friendly error messages
307	316	cherrypy.config.update({"request.show_mismatched_params": False})
308	317	self.getPage("/params/?notathing=meeting")

314	323	self.getPage("/params/%d4%20%e3/cheese?Gruy%E8re=Bulgn%e9ville")
315	324	self.assertBody("args: %s kwargs: %s" %
316	325	(('\xd4 \xe3', 'cheese'),
317		{'Gruy\xe8re': ntou('Bulgn\xe9ville')}))
318
	326	[('Gruy\xe8re', ntou('Bulgn\xe9ville'))]))
	327
319	328	# Make sure that encoded = and & get parsed correctly
320		self.getPage("/params/code?url=http%3A//cherrypy.org/index%3Fa%3D1%26b%3D2")
	329	self.getPage(
	330	"/params/code?url=http%3A//cherrypy.org/index%3Fa%3D1%26b%3D2")
321	331	self.assertBody("args: %s kwargs: %s" %
322	332	(('code',),
323		{'url': ntou('http://cherrypy.org/index?a=1&b=2')}))
324
	333	[('url', ntou('http://cherrypy.org/index?a=1&b=2'))]))
	334
325	335	# Test coordinates sent by <img ismap>
326	336	self.getPage("/params/ismap?223,114")
327	337	self.assertBody("Coordinates: 223, 114")
328
	338
329	339	# Test "name[key]" dict-like params
330	340	self.getPage("/params/dictlike?a[1]=1&a[2]=2&b=foo&b[bar]=baz")
331	341	self.assertBody("args: %s kwargs: %s" %
332	342	(('dictlike',),
333		{'a[1]': ntou('1'), 'b[bar]': ntou('baz'),
334		'b': ntou('foo'), 'a[2]': ntou('2')}))
	343	[('a[1]', ntou('1')), ('a[2]', ntou('2')),
	344	('b', ntou('foo')), ('b[bar]', ntou('baz'))]))
335	345
336	346	def testParamErrors(self):
337	347
338		# test that all of the handlers work when given
	348	# test that all of the handlers work when given
339	349	# the correct parameters in order to ensure that the
340	350	# errors below aren't coming from some other source.
341	351	for uri in (

343	353	'/paramerrors/one_positional_args?param1=foo',
344	354	'/paramerrors/one_positional_args/foo',
345	355	'/paramerrors/one_positional_args/foo/bar/baz',
346		'/paramerrors/one_positional_args_kwargs?param1=foo&param2=bar',
347		'/paramerrors/one_positional_args_kwargs/foo?param2=bar&param3=baz',
348		'/paramerrors/one_positional_args_kwargs/foo/bar/baz?param2=bar&param3=baz',
349		'/paramerrors/one_positional_kwargs?param1=foo&param2=bar&param3=baz',
350		'/paramerrors/one_positional_kwargs/foo?param4=foo&param2=bar&param3=baz',
	356	'/paramerrors/one_positional_args_kwargs?'
	357	'param1=foo&param2=bar',
	358	'/paramerrors/one_positional_args_kwargs/foo?'
	359	'param2=bar&param3=baz',
	360	'/paramerrors/one_positional_args_kwargs/foo/bar/baz?'
	361	'param2=bar&param3=baz',
	362	'/paramerrors/one_positional_kwargs?'
	363	'param1=foo&param2=bar&param3=baz',
	364	'/paramerrors/one_positional_kwargs/foo?'
	365	'param4=foo&param2=bar&param3=baz',
351	366	'/paramerrors/no_positional',
352	367	'/paramerrors/no_positional_args/foo',
353	368	'/paramerrors/no_positional_args/foo/bar/baz',
354	369	'/paramerrors/no_positional_args_kwargs?param1=foo&param2=bar',
355	370	'/paramerrors/no_positional_args_kwargs/foo?param2=bar',
356		'/paramerrors/no_positional_args_kwargs/foo/bar/baz?param2=bar&param3=baz',
	371	'/paramerrors/no_positional_args_kwargs/foo/bar/baz?'
	372	'param2=bar&param3=baz',
357	373	'/paramerrors/no_positional_kwargs?param1=foo&param2=bar',
358	374	'/paramerrors/callable_object',
359		):
	375	):
360	376	self.getPage(uri)
361	377	self.assertStatus(200)
362	378
363	379	# query string parameters are part of the URI, so if they are wrong
364	380	# for a particular handler, the status MUST be a 404.
365	381	error_msgs = [
366		'Missing parameters',
367		'Nothing matches the given URI',
368		'Multiple values for parameters',
369		'Unexpected query string parameters',
370		'Unexpected body parameters',
371		]
	382	'Missing parameters',
	383	'Nothing matches the given URI',
	384	'Multiple values for parameters',
	385	'Unexpected query string parameters',
	386	'Unexpected body parameters',
	387	]
372	388	for uri, msg in (
373	389	('/paramerrors/one_positional', error_msgs[0]),
374	390	('/paramerrors/one_positional?foo=foo', error_msgs[0]),
375	391	('/paramerrors/one_positional/foo/bar/baz', error_msgs[1]),
376	392	('/paramerrors/one_positional/foo?param1=foo', error_msgs[2]),
377		('/paramerrors/one_positional/foo?param1=foo&param2=foo', error_msgs[2]),
378		('/paramerrors/one_positional_args/foo?param1=foo&param2=foo', error_msgs[2]),
379		('/paramerrors/one_positional_args/foo/bar/baz?param2=foo', error_msgs[3]),
380		('/paramerrors/one_positional_args_kwargs/foo/bar/baz?param1=bar&param3=baz', error_msgs[2]),
381		('/paramerrors/one_positional_kwargs/foo?param1=foo&param2=bar&param3=baz', error_msgs[2]),
	393	('/paramerrors/one_positional/foo?param1=foo&param2=foo',
	394	error_msgs[2]),
	395	('/paramerrors/one_positional_args/foo?param1=foo&param2=foo',
	396	error_msgs[2]),
	397	('/paramerrors/one_positional_args/foo/bar/baz?param2=foo',
	398	error_msgs[3]),
	399	('/paramerrors/one_positional_args_kwargs/foo/bar/baz?'
	400	'param1=bar&param3=baz',
	401	error_msgs[2]),
	402	('/paramerrors/one_positional_kwargs/foo?'
	403	'param1=foo&param2=bar&param3=baz',
	404	error_msgs[2]),
382	405	('/paramerrors/no_positional/boo', error_msgs[1]),
383	406	('/paramerrors/no_positional?param1=foo', error_msgs[3]),
384	407	('/paramerrors/no_positional_args/boo?param1=foo', error_msgs[3]),
385		('/paramerrors/no_positional_kwargs/boo?param1=foo', error_msgs[1]),
	408	('/paramerrors/no_positional_kwargs/boo?param1=foo',
	409	error_msgs[1]),
386	410	('/paramerrors/callable_object?param1=foo', error_msgs[3]),
387	411	('/paramerrors/callable_object/boo', error_msgs[1]),
388		):
	412	):
389	413	for show_mismatched_params in (True, False):
390		cherrypy.config.update({'request.show_mismatched_params': show_mismatched_params})
	414	cherrypy.config.update(
	415	{'request.show_mismatched_params': show_mismatched_params})
391	416	self.getPage(uri)
392	417	self.assertStatus(404)
393	418	if show_mismatched_params:

397	422
398	423	# if body parameters are wrong, a 400 must be returned.
399	424	for uri, body, msg in (
400		('/paramerrors/one_positional/foo', 'param1=foo', error_msgs[2]),
401		('/paramerrors/one_positional/foo', 'param1=foo&param2=foo', error_msgs[2]),
402		('/paramerrors/one_positional_args/foo', 'param1=foo&param2=foo', error_msgs[2]),
403		('/paramerrors/one_positional_args/foo/bar/baz', 'param2=foo', error_msgs[4]),
404		('/paramerrors/one_positional_args_kwargs/foo/bar/baz', 'param1=bar&param3=baz', error_msgs[2]),
405		('/paramerrors/one_positional_kwargs/foo', 'param1=foo&param2=bar&param3=baz', error_msgs[2]),
	425	('/paramerrors/one_positional/foo',
	426	'param1=foo', error_msgs[2]),
	427	('/paramerrors/one_positional/foo',
	428	'param1=foo&param2=foo', error_msgs[2]),
	429	('/paramerrors/one_positional_args/foo',
	430	'param1=foo&param2=foo', error_msgs[2]),
	431	('/paramerrors/one_positional_args/foo/bar/baz',
	432	'param2=foo', error_msgs[4]),
	433	('/paramerrors/one_positional_args_kwargs/foo/bar/baz',
	434	'param1=bar&param3=baz', error_msgs[2]),
	435	('/paramerrors/one_positional_kwargs/foo',
	436	'param1=foo&param2=bar&param3=baz', error_msgs[2]),
406	437	('/paramerrors/no_positional', 'param1=foo', error_msgs[4]),
407		('/paramerrors/no_positional_args/boo', 'param1=foo', error_msgs[4]),
	438	('/paramerrors/no_positional_args/boo',
	439	'param1=foo', error_msgs[4]),
408	440	('/paramerrors/callable_object', 'param1=foo', error_msgs[4]),
409		):
	441	):
410	442	for show_mismatched_params in (True, False):
411		cherrypy.config.update({'request.show_mismatched_params': show_mismatched_params})
	443	cherrypy.config.update(
	444	{'request.show_mismatched_params': show_mismatched_params})
412	445	self.getPage(uri, method='POST', body=body)
413	446	self.assertStatus(400)
414	447	if show_mismatched_params:

416	449	else:
417	450	self.assertInBody("400 Bad")
418	451
419
420		# even if body parameters are wrong, if we get the uri wrong, then
	452	# even if body parameters are wrong, if we get the uri wrong, then
421	453	# it's a 404
422	454	for uri, body, msg in (
423		('/paramerrors/one_positional?param2=foo', 'param1=foo', error_msgs[3]),
424		('/paramerrors/one_positional/foo/bar', 'param2=foo', error_msgs[1]),
425		('/paramerrors/one_positional_args/foo/bar?param2=foo', 'param3=foo', error_msgs[3]),
426		('/paramerrors/one_positional_kwargs/foo/bar', 'param2=bar&param3=baz', error_msgs[1]),
427		('/paramerrors/no_positional?param1=foo', 'param2=foo', error_msgs[3]),
428		('/paramerrors/no_positional_args/boo?param2=foo', 'param1=foo', error_msgs[3]),
429		('/paramerrors/callable_object?param2=bar', 'param1=foo', error_msgs[3]),
430		):
	455	('/paramerrors/one_positional?param2=foo',
	456	'param1=foo', error_msgs[3]),
	457	('/paramerrors/one_positional/foo/bar',
	458	'param2=foo', error_msgs[1]),
	459	('/paramerrors/one_positional_args/foo/bar?param2=foo',
	460	'param3=foo', error_msgs[3]),
	461	('/paramerrors/one_positional_kwargs/foo/bar',
	462	'param2=bar&param3=baz', error_msgs[1]),
	463	('/paramerrors/no_positional?param1=foo',
	464	'param2=foo', error_msgs[3]),
	465	('/paramerrors/no_positional_args/boo?param2=foo',
	466	'param1=foo', error_msgs[3]),
	467	('/paramerrors/callable_object?param2=bar',
	468	'param1=foo', error_msgs[3]),
	469	):
431	470	for show_mismatched_params in (True, False):
432		cherrypy.config.update({'request.show_mismatched_params': show_mismatched_params})
	471	cherrypy.config.update(
	472	{'request.show_mismatched_params': show_mismatched_params})
433	473	self.getPage(uri, method='POST', body=body)
434	474	self.assertStatus(404)
435	475	if show_mismatched_params:

443	483	'/paramerrors/raise_type_error',
444	484	'/paramerrors/raise_type_error_with_default_param?x=0',
445	485	'/paramerrors/raise_type_error_with_default_param?x=0&y=0',
446		):
	486	):
447	487	self.getPage(uri, method='GET')
448	488	self.assertStatus(500)
449	489	self.assertTrue('Client Error', self.body)

452	492	self.getPage("/error/missing")
453	493	self.assertStatus(404)
454	494	self.assertErrorPage(404, "The path '/error/missing' was not found.")
455
	495
456	496	ignore = helper.webtest.ignored_exceptions
457	497	ignore.append(ValueError)
458	498	try:
459	499	valerr = '\n raise ValueError()\nValueError'
460	500	self.getPage("/error/page_method")
461	501	self.assertErrorPage(500, pattern=valerr)
462
	502
463	503	self.getPage("/error/page_yield")
464	504	self.assertErrorPage(500, pattern=valerr)
465
	505
466	506	if (cherrypy.server.protocol_version == "HTTP/1.0" or
467		getattr(cherrypy.server, "using_apache", False)):
	507	getattr(cherrypy.server, "using_apache", False)):
468	508	self.getPage("/error/page_streamed")
469	509	# Because this error is raised after the response body has
470	510	# started, the status should not change to an error status.

475	515	# The HTTP client will choke when the output is incomplete.
476	516	self.assertRaises((ValueError, IncompleteRead), self.getPage,
477	517	"/error/page_streamed")
478
	518
479	519	# No traceback should be present
480	520	self.getPage("/error/cause_err_in_finalize")
481	521	msg = "Illegal response status from server ('ZOO' is non-numeric)."
482	522	self.assertErrorPage(500, msg, None)
483	523	finally:
484	524	ignore.pop()
485
	525
486	526	# Test HTTPError with a reason-phrase in the status arg.
487	527	self.getPage('/error/reason_phrase')
488	528	self.assertStatus("410 Gone fishin'")
489
	529
490	530	# Test custom error page for a specific error.
491	531	self.getPage("/error/custom")
492	532	self.assertStatus(404)
493	533	self.assertBody("Hello, world\r\n" + (" " * 499))
494
	534
495	535	# Test custom error page for a specific error.
496	536	self.getPage("/error/custom?err=401")
497	537	self.assertStatus(401)
498		self.assertBody("Error 401 Unauthorized - Well, I'm very sorry but you haven't paid!")
499
	538	self.assertBody(
	539	"Error 401 Unauthorized - "
	540	"Well, I'm very sorry but you haven't paid!")
	541
500	542	# Test default custom error page.
501	543	self.getPage("/error/custom_default")
502	544	self.assertStatus(500)
503		self.assertBody("Error 500 Internal Server Error - Well, I'm very sorry but you haven't paid!".ljust(513))
504
	545	self.assertBody(
	546	"Error 500 Internal Server Error - "
	547	"Well, I'm very sorry but you haven't paid!".ljust(513))
	548
505	549	# Test error in custom error page (ticket #305).
506	550	# Note that the message is escaped for HTML (ticket #310).
507	551	self.getPage("/error/noexist")
508	552	self.assertStatus(404)
	553	if sys.version_info >= (3, 3):
	554	exc_name = "FileNotFoundError"
	555	else:
	556	exc_name = "IOError"
509	557	msg = ("No, <b>really</b>, not found!<br />"
510	558	"In addition, the custom error page failed:\n<br />"
511		"IOError: [Errno 2] No such file or directory: 'nonexistent.html'")
	559	"%s: [Errno 2] "
	560	"No such file or directory: 'nonexistent.html'") % (exc_name,)
512	561	self.assertInBody(msg)
513
	562
514	563	if getattr(cherrypy.server, "using_apache", False):
515	564	pass
516	565	else:
517	566	# Test throw_errors (ticket #186).
518	567	self.getPage("/error/rethrow")
519	568	self.assertInBody("raise ValueError()")
520
	569
521	570	def testExpect(self):
522	571	e = ('Expect', '100-continue')
523	572	self.getPage("/headerelements/get_elements?headername=Expect", [e])
524	573	self.assertBody('100-continue')
525
	574
526	575	self.getPage("/expect/expectation_failed", [e])
527	576	self.assertStatus(417)
528
	577
529	578	def testHeaderElements(self):
530	579	# Accept-* header elements should be sorted, with most preferred first.
531	580	h = [('Accept', 'audio/*; q=0.2, audio/basic')]

533	582	self.assertStatus(200)
534	583	self.assertBody("audio/basic\n"
535	584	"audio/*;q=0.2")
536
537		h = [('Accept', 'text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c')]
	585
	586	h = [
	587	('Accept',
	588	'text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c')
	589	]
538	590	self.getPage("/headerelements/get_elements?headername=Accept", h)
539	591	self.assertStatus(200)
540	592	self.assertBody("text/x-c\n"
541	593	"text/html\n"
542	594	"text/x-dvi;q=0.8\n"
543	595	"text/plain;q=0.5")
544
	596
545	597	# Test that more specific media ranges get priority.
546	598	h = [('Accept', 'text/, text/html, text/html;level=1, /*')]
547	599	self.getPage("/headerelements/get_elements?headername=Accept", h)

550	602	"text/html\n"
551	603	"text/*\n"
552	604	"/")
553
	605
554	606	# Test Accept-Charset
555	607	h = [('Accept-Charset', 'iso-8859-5, unicode-1-1;q=0.8')]
556		self.getPage("/headerelements/get_elements?headername=Accept-Charset", h)
	608	self.getPage(
	609	"/headerelements/get_elements?headername=Accept-Charset", h)
557	610	self.assertStatus("200 OK")
558	611	self.assertBody("iso-8859-5\n"
559	612	"unicode-1-1;q=0.8")
560
	613
561	614	# Test Accept-Encoding
562	615	h = [('Accept-Encoding', 'gzip;q=1.0, identity; q=0.5, *;q=0')]
563		self.getPage("/headerelements/get_elements?headername=Accept-Encoding", h)
	616	self.getPage(
	617	"/headerelements/get_elements?headername=Accept-Encoding", h)
564	618	self.assertStatus("200 OK")
565	619	self.assertBody("gzip;q=1.0\n"
566	620	"identity;q=0.5\n"
567	621	"*;q=0")
568
	622
569	623	# Test Accept-Language
570	624	h = [('Accept-Language', 'da, en-gb;q=0.8, en;q=0.7')]
571		self.getPage("/headerelements/get_elements?headername=Accept-Language", h)
	625	self.getPage(
	626	"/headerelements/get_elements?headername=Accept-Language", h)
572	627	self.assertStatus("200 OK")
573	628	self.assertBody("da\n"
574	629	"en-gb;q=0.8\n"
575	630	"en;q=0.7")
576
577		# Test malformed header parsing. See http://www.cherrypy.org/ticket/763.
	631
	632	# Test malformed header parsing. See
	633	# https://bitbucket.org/cherrypy/cherrypy/issue/763.
578	634	self.getPage("/headerelements/get_elements?headername=Content-Type",
579	635	# Note the illegal trailing ";"
580	636	headers=[('Content-Type', 'text/html; charset=utf-8;')])
581	637	self.assertStatus(200)
582	638	self.assertBody("text/html;charset=utf-8")
583
	639
584	640	def test_repeated_headers(self):
585	641	# Test that two request headers are collapsed into one.
586		# See http://www.cherrypy.org/ticket/542.
	642	# See https://bitbucket.org/cherrypy/cherrypy/issue/542.
587	643	self.getPage("/headers/Accept-Charset",
588	644	headers=[("Accept-Charset", "iso-8859-5"),
589	645	("Accept-Charset", "unicode-1-1;q=0.8")])
590	646	self.assertBody("iso-8859-5, unicode-1-1;q=0.8")
591
	647
592	648	# Tests that each header only appears once, regardless of case.
593	649	self.getPage("/headers/doubledheaders")
594	650	self.assertBody("double header test")

596	652	for key in ['Content-Length', 'Content-Type', 'Date',
597	653	'Expires', 'Location', 'Server']:
598	654	self.assertEqual(hnames.count(key), 1, self.headers)
599
	655
600	656	def test_encoded_headers(self):
601	657	# First, make sure the innards work like expected.
602		self.assertEqual(httputil.decode_TEXT(ntou("=?utf-8?q?f=C3=BCr?=")), ntou("f\xfcr"))
603
	658	self.assertEqual(
	659	httputil.decode_TEXT(ntou("=?utf-8?q?f=C3=BCr?=")), ntou("f\xfcr"))
	660
604	661	if cherrypy.server.protocol_version == "HTTP/1.1":
605	662	# Test RFC-2047-encoded request and response header values
606	663	u = ntou('\u212bngstr\xf6m', 'escape')
607	664	c = ntou("=E2=84=ABngstr=C3=B6m")
608		self.getPage("/headers/ifmatch", [('If-Match', ntou('=?utf-8?q?%s?=') % c)])
	665	self.getPage("/headers/ifmatch",
	666	[('If-Match', ntou('=?utf-8?q?%s?=') % c)])
609	667	# The body should be utf-8 encoded.
610	668	self.assertBody(ntob("\xe2\x84\xabngstr\xc3\xb6m"))
611	669	# But the Etag header should be RFC-2047 encoded (binary)
612	670	self.assertHeader("ETag", ntou('=?utf-8?b?4oSrbmdzdHLDtm0=?='))
613
	671
614	672	# Test a LONG RFC-2047-encoded request and response header value
615	673	self.getPage("/headers/ifmatch",
616	674	[('If-Match', ntou('=?utf-8?q?%s?=') % (c * 10))])
617	675	self.assertBody(ntob("\xe2\x84\xabngstr\xc3\xb6m") * 10)
618	676	# Note: this is different output for Python3, but it decodes fine.
619		etag = self.assertHeader("ETag",
	677	etag = self.assertHeader(
	678	"ETag",
620	679	'=?utf-8?b?4oSrbmdzdHLDtm3ihKtuZ3N0csO2beKEq25nc3Ryw7Zt'
621	680	'4oSrbmdzdHLDtm3ihKtuZ3N0csO2beKEq25nc3Ryw7Zt'
622	681	'4oSrbmdzdHLDtm3ihKtuZ3N0csO2beKEq25nc3Ryw7Zt'
623	682	'4oSrbmdzdHLDtm0=?=')
624	683	self.assertEqual(httputil.decode_TEXT(etag), u * 10)
625
	684
626	685	def test_header_presence(self):
627	686	# If we don't pass a Content-Type header, it should not be present
628	687	# in cherrypy.request.headers
629	688	self.getPage("/headers/Content-Type",
630	689	headers=[])
631	690	self.assertStatus(500)
632
	691
633	692	# If Content-Type is present in the request, it should be present in
634	693	# cherrypy.request.headers
635	694	self.getPage("/headers/Content-Type",
636	695	headers=[("Content-type", "application/json")])
637	696	self.assertBody("application/json")
638
	697
639	698	def test_basic_HTTPMethods(self):
640	699	helper.webtest.methods_with_bodies = ("POST", "PUT", "PROPFIND")
641
	700
642	701	# Test that all defined HTTP methods work.
643	702	for m in defined_http_methods:
644	703	self.getPage("/method/", method=m)
645
	704
646	705	# HEAD requests should not return any body.
647	706	if m == "HEAD":
648	707	self.assertBody("")

651	710	self.assertEqual(self.body[:5], ntob("TRACE"))
652	711	else:
653	712	self.assertBody(m)
654
	713
655	714	# Request a PUT method with a form-urlencoded body
656	715	self.getPage("/method/parameterized", method="PUT",
657		body="data=on+top+of+other+things")
	716	body="data=on+top+of+other+things")
658	717	self.assertBody("on top of other things")
659
	718
660	719	# Request a PUT method with a file body
661	720	b = "one thing on top of another"
662	721	h = [("Content-Type", "text/plain"),

664	723	self.getPage("/method/request_body", headers=h, method="PUT", body=b)
665	724	self.assertStatus(200)
666	725	self.assertBody(b)
667
	726
668	727	# Request a PUT method with a file body but no Content-Type.
669		# See http://www.cherrypy.org/ticket/790.
	728	# See https://bitbucket.org/cherrypy/cherrypy/issue/790.
670	729	b = ntob("one thing on top of another")
671	730	self.persistent = True
672	731	try:

683	742	self.assertBody(b)
684	743	finally:
685	744	self.persistent = False
686
	745
687	746	# Request a PUT method with no body whatsoever (not an empty one).
688		# See http://www.cherrypy.org/ticket/650.
	747	# See https://bitbucket.org/cherrypy/cherrypy/issue/650.
689	748	# Provide a C-T or webtest will provide one (and a C-L) for us.
690	749	h = [("Content-Type", "text/plain")]
691	750	self.getPage("/method/reachable", headers=h, method="PUT")
692	751	self.assertStatus(411)
693
	752
694	753	# Request a custom method with a request body
695	754	b = ('<?xml version="1.0" encoding="utf-8" ?>\n\n'
696	755	'<propfind xmlns="DAV:"><prop><getlastmodified/>'
697	756	'</prop></propfind>')
698	757	h = [('Content-Type', 'text/xml'),
699	758	('Content-Length', str(len(b)))]
700		self.getPage("/method/request_body", headers=h, method="PROPFIND", body=b)
	759	self.getPage("/method/request_body", headers=h,
	760	method="PROPFIND", body=b)
701	761	self.assertStatus(200)
702	762	self.assertBody(b)
703
	763
704	764	# Request a disallowed method
705	765	self.getPage("/method/", method="LINK")
706	766	self.assertStatus(405)
707
	767
708	768	# Request an unknown method
709	769	self.getPage("/method/", method="SEARCH")
710	770	self.assertStatus(501)
711
	771
712	772	# For method dispatchers: make sure that an HTTP method doesn't
713	773	# collide with a virtual path atom. If you build HTTP-method
714	774	# dispatching into the core, rewrite these handlers to use

719	779	self.getPage("/divorce/", method="GET")
720	780	self.assertBody('<h1>Choose your document</h1>\n<ul>\n</ul>')
721	781	self.assertStatus(200)
722
	782
723	783	def test_CONNECT_method(self):
724	784	if getattr(cherrypy.server, "using_apache", False):
725	785	return self.skip("skipped due to known Apache differences... ")
726
	786
727	787	self.getPage("/method/", method="CONNECT")
728	788	self.assertBody("CONNECT")
729
	789
730	790	def testEmptyThreadlocals(self):
731	791	results = []
732	792	for x in range(20):
733	793	self.getPage("/threadlocal/")
734	794	results.append(self.body)
735	795	self.assertEqual(results, [ntob("None")] * 20)
736

+20

-14

cherrypy/test/test_routes.py less more

4	4
5	5	from cherrypy.test import helper
6	6	import nose
	7
7	8
8	9	class RoutesDispatchTest(helper.CPWebCase):
9	10

15	16	raise nose.SkipTest('Install routes to test RoutesDispatcher code')
16	17
17	18	class Dummy:
	19
18	20	def index(self):
19	21	return "I said good day!"
20
	22
21	23	class City:
22
	24
23	25	def __init__(self, name):
24	26	self.name = name
25	27	self.population = 10000
26
	28
27	29	def index(self, **kwargs):
28	30	return "Welcome to %s, pop. %s" % (self.name, self.population)
29		index._cp_config = {'tools.response_headers.on': True,
30		'tools.response_headers.headers': [('Content-Language', 'en-GB')]}
31
	31	index._cp_config = {
	32	'tools.response_headers.on': True,
	33	'tools.response_headers.headers': [
	34	('Content-Language', 'en-GB')
	35	]
	36	}
	37
32	38	def update(self, **kwargs):
33	39	self.population = kwargs['pop']
34	40	return "OK"
35
	41
36	42	d = cherrypy.dispatch.RoutesDispatcher()
37	43	d.connect(action='index', name='hounslow', route='/hounslow',
38	44	controller=City('Hounslow'))
39		d.connect(name='surbiton', route='/surbiton', controller=City('Surbiton'),
40		action='index', conditions=dict(method=['GET']))
	45	d.connect(
	46	name='surbiton', route='/surbiton', controller=City('Surbiton'),
	47	action='index', conditions=dict(method=['GET']))
41	48	d.mapper.connect('/surbiton', controller='surbiton',
42	49	action='update', conditions=dict(method=['POST']))
43	50	d.connect('main', ':action', controller=Dummy())
44
	51
45	52	conf = {'/': {'request.dispatch': d}}
46	53	cherrypy.tree.mount(root=None, config=conf)
47	54	setup_server = staticmethod(setup_server)

50	57	self.getPage("/hounslow")
51	58	self.assertStatus("200 OK")
52	59	self.assertBody("Welcome to Hounslow, pop. 10000")
53
	60
54	61	self.getPage("/foo")
55	62	self.assertStatus("404 Not Found")
56
	63
57	64	self.getPage("/surbiton")
58	65	self.assertStatus("200 OK")
59	66	self.assertBody("Welcome to Surbiton, pop. 10000")
60
	67
61	68	self.getPage("/surbiton", method="POST", body="pop=1327")
62	69	self.assertStatus("200 OK")
63	70	self.assertBody("OK")

65	72	self.assertStatus("200 OK")
66	73	self.assertHeader("Content-Language", "en-GB")
67	74	self.assertBody("Welcome to Surbiton, pop. 1327")
68

+89

-79

cherrypy/test/test_session.py less more

8	8	from cherrypy.lib import sessions
9	9	from cherrypy.lib.httputil import response_codes
10	10
	11
11	12	def http_methods_allowed(methods=['GET', 'HEAD']):
12	13	method = cherrypy.request.method.upper()
13	14	if method not in methods:

18	19
19	20
20	21	def setup_server():
21
	22
22	23	class Root:
23
	24
24	25	_cp_config = {'tools.sessions.on': True,
25		'tools.sessions.storage_type' : 'ram',
26		'tools.sessions.storage_path' : localDir,
	26	'tools.sessions.storage_type': 'ram',
	27	'tools.sessions.storage_path': localDir,
27	28	'tools.sessions.timeout': (1.0 / 60),
28	29	'tools.sessions.clean_freq': (1.0 / 60),
29	30	}
30
	31
31	32	def clear(self):
32	33	cherrypy.session.cache.clear()
33	34	clear.exposed = True
34
	35
35	36	def data(self):
36	37	cherrypy.session['aha'] = 'foo'
37	38	return repr(cherrypy.session._data)
38	39	data.exposed = True
39
	40
40	41	def testGen(self):
41	42	counter = cherrypy.session.get('counter', 0) + 1
42	43	cherrypy.session['counter'] = counter
43	44	yield str(counter)
44	45	testGen.exposed = True
45
	46
46	47	def testStr(self):
47	48	counter = cherrypy.session.get('counter', 0) + 1
48	49	cherrypy.session['counter'] = counter
49	50	return str(counter)
50	51	testStr.exposed = True
51
	52
52	53	def setsessiontype(self, newtype):
53		self.__class__._cp_config.update({'tools.sessions.storage_type': newtype})
	54	self.__class__._cp_config.update(
	55	{'tools.sessions.storage_type': newtype})
54	56	if hasattr(cherrypy, "session"):
55	57	del cherrypy.session
56	58	cls = getattr(sessions, newtype.title() + 'Session')

60	62	del cls.clean_thread
61	63	setsessiontype.exposed = True
62	64	setsessiontype._cp_config = {'tools.sessions.on': False}
63
	65
64	66	def index(self):
65	67	sess = cherrypy.session
66	68	c = sess.get('counter', 0) + 1

68	70	sess['counter'] = c
69	71	return str(c)
70	72	index.exposed = True
71
	73
72	74	def keyin(self, key):
73	75	return str(key in cherrypy.session)
74	76	keyin.exposed = True
75
	77
76	78	def delete(self):
77	79	cherrypy.session.delete()
78	80	sessions.expire()
79	81	return "done"
80	82	delete.exposed = True
81
	83
82	84	def delkey(self, key):
83	85	del cherrypy.session[key]
84	86	return "OK"
85	87	delkey.exposed = True
86
	88
87	89	def blah(self):
88	90	return self._cp_config['tools.sessions.storage_type']
89	91	blah.exposed = True
90
	92
91	93	def iredir(self):
92	94	raise cherrypy.InternalRedirect('/blah')
93	95	iredir.exposed = True
94
	96
95	97	def restricted(self):
96	98	return cherrypy.request.method
97	99	restricted.exposed = True
98	100	restricted._cp_config = {'tools.allow.on': True,
99	101	'tools.allow.methods': ['GET']}
100
	102
101	103	def regen(self):
102	104	cherrypy.tools.sessions.regenerate()
103	105	return "logged in"
104	106	regen.exposed = True
105
	107
106	108	def length(self):
107	109	return str(len(cherrypy.session))
108	110	length.exposed = True
109
	111
110	112	def session_cookie(self):
111	113	# Must load() to start the clean thread.
112	114	cherrypy.session.load()

116	118	'tools.sessions.path': '/session_cookie',
117	119	'tools.sessions.name': 'temp',
118	120	'tools.sessions.persistent': False}
119
	121
120	122	cherrypy.tree.mount(Root())
121	123
122	124
123	125	from cherrypy.test import helper
	126
124	127
125	128	class SessionTest(helper.CPWebCase):
126	129	setup_server = staticmethod(setup_server)
127
	130
128	131	def tearDown(self):
129	132	# Clean up sessions.
130	133	for fname in os.listdir(localDir):
131	134	if fname.startswith(sessions.FileSession.SESSION_PREFIX):
132	135	os.unlink(os.path.join(localDir, fname))
133
	136
134	137	def test_0_Session(self):
135	138	self.getPage('/setsessiontype/ram')
136	139	self.getPage('/clear')
137
	140
138	141	# Test that a normal request gets the same id in the cookies.
139	142	# Note: this wouldn't work if /data didn't load the session.
140	143	self.getPage('/data')

142	145	c = self.cookies[0]
143	146	self.getPage('/data', self.cookies)
144	147	self.assertEqual(self.cookies[0], c)
145
	148
146	149	self.getPage('/testStr')
147	150	self.assertBody('1')
148	151	cookie_parts = dict([p.strip().split('=')

160	163	self.assertBody('2')
161	164	self.getPage('/delkey?key=counter', self.cookies)
162	165	self.assertStatus(200)
163
	166
164	167	self.getPage('/setsessiontype/file')
165	168	self.getPage('/testStr')
166	169	self.assertBody('1')

170	173	self.assertBody('3')
171	174	self.getPage('/delkey?key=counter', self.cookies)
172	175	self.assertStatus(200)
173
	176
174	177	# Wait for the session.timeout (1 second)
175	178	time.sleep(2)
176	179	self.getPage('/')
177	180	self.assertBody('1')
178	181	self.getPage('/length', self.cookies)
179	182	self.assertBody('1')
180
	183
181	184	# Test session __contains__
182	185	self.getPage('/keyin?key=counter', self.cookies)
183	186	self.assertBody("True")
184	187	cookieset1 = self.cookies
185
	188
186	189	# Make a new session and test __len__ again
187	190	self.getPage('/')
188	191	self.getPage('/length', self.cookies)
189	192	self.assertBody('2')
190
	193
191	194	# Test session delete
192	195	self.getPage('/delete', self.cookies)
193	196	self.assertBody("done")
194	197	self.getPage('/delete', cookieset1)
195	198	self.assertBody("done")
196		f = lambda: [x for x in os.listdir(localDir) if x.startswith('session-')]
	199	f = lambda: [
	200	x for x in os.listdir(localDir) if x.startswith('session-')]
197	201	self.assertEqual(f(), [])
198
	202
199	203	# Wait for the cleanup thread to delete remaining session files
200	204	self.getPage('/')
201		f = lambda: [x for x in os.listdir(localDir) if x.startswith('session-')]
	205	f = lambda: [
	206	x for x in os.listdir(localDir) if x.startswith('session-')]
202	207	self.assertNotEqual(f(), [])
203	208	time.sleep(2)
204	209	self.assertEqual(f(), [])
205
	210
206	211	def test_1_Ram_Concurrency(self):
207	212	self.getPage('/setsessiontype/ram')
208	213	self._test_Concurrency()
209
	214
210	215	def test_2_File_Concurrency(self):
211	216	self.getPage('/setsessiontype/file')
212	217	self._test_Concurrency()
213
	218
214	219	def _test_Concurrency(self):
215	220	client_thread_count = 5
216	221	request_count = 30
217
	222
218	223	# Get initial cookie
219	224	self.getPage("/")
220	225	self.assertBody("1")
221	226	cookies = self.cookies
222
	227
223	228	data_dict = {}
224	229	errors = []
225
	230
226	231	def request(index):
227	232	if self.scheme == 'https':
228	233	c = HTTPSConnection('%s:%s' % (self.interface(), self.PORT))

241	246	data_dict[index] = max(data_dict[index], int(body))
242	247	# Uncomment the following line to prove threads overlap.
243	248	## sys.stdout.write("%d " % index)
244
	249
245	250	# Start <request_count> requests from each of
246	251	# <client_thread_count> concurrent clients
247	252	ts = []

250	255	t = threading.Thread(target=request, args=(c,))
251	256	ts.append(t)
252	257	t.start()
253
	258
254	259	for t in ts:
255	260	t.join()
256
	261
257	262	hitcount = max(data_dict.values())
258	263	expected = 1 + (client_thread_count * request_count)
259
	264
260	265	for e in errors:
261	266	print(e)
262	267	self.assertEqual(hitcount, expected)
263
	268
264	269	def test_3_Redirect(self):
265	270	# Start a new session
266	271	self.getPage('/testStr')
267	272	self.getPage('/iredir', self.cookies)
268	273	self.assertBody("file")
269
	274
270	275	def test_4_File_deletion(self):
271	276	# Start a new session
272	277	self.getPage('/testStr')

275	280	path = os.path.join(localDir, "session-" + id)
276	281	os.unlink(path)
277	282	self.getPage('/testStr', self.cookies)
278
	283
279	284	def test_5_Error_paths(self):
280	285	self.getPage('/unknown/page')
281	286	self.assertErrorPage(404, "The path '/unknown/page' was not found.")
282
	287
283	288	# Note: this path is not the same as above. The above
284	289	# takes a normal route through the session code; this one
285	290	# skips the session code's before_handler and only calls

287	292	# code has to survive calling save/close without init.
288	293	self.getPage('/restricted', self.cookies, method='POST')
289	294	self.assertErrorPage(405, response_codes[405][1])
290
	295
291	296	def test_6_regenerate(self):
292	297	self.getPage('/testStr')
293	298	# grab the cookie ID

296	301	self.assertBody('logged in')
297	302	id2 = self.cookies[0][1].split(";", 1)[0].split("=", 1)[1]
298	303	self.assertNotEqual(id1, id2)
299
	304
300	305	self.getPage('/testStr')
301	306	# grab the cookie ID
302	307	id1 = self.cookies[0][1].split(";", 1)[0].split("=", 1)[1]
303	308	self.getPage('/testStr',
304		headers=[('Cookie',
305		'session_id=maliciousid; '
306		'expires=Sat, 27 Oct 2017 04:18:28 GMT; Path=/;')])
	309	headers=[
	310	('Cookie',
	311	'session_id=maliciousid; '
	312	'expires=Sat, 27 Oct 2017 04:18:28 GMT; Path=/;')])
307	313	id2 = self.cookies[0][1].split(";", 1)[0].split("=", 1)[1]
308	314	self.assertNotEqual(id1, id2)
309	315	self.assertNotEqual(id2, 'maliciousid')
310
	316
311	317	def test_7_session_cookies(self):
312	318	self.getPage('/setsessiontype/ram')
313	319	self.getPage('/clear')
314	320	self.getPage('/session_cookie')
315	321	# grab the cookie ID
316		cookie_parts = dict([p.strip().split('=') for p in self.cookies[0][1].split(";")])
	322	cookie_parts = dict([p.strip().split('=')
	323	for p in self.cookies[0][1].split(";")])
317	324	# Assert there is no 'expires' param
318	325	self.assertEqual(set(cookie_parts.keys()), set(['temp', 'Path']))
319	326	id1 = cookie_parts['temp']
320	327	self.assertEqual(copykeys(sessions.RamSession.cache), [id1])
321
	328
322	329	# Send another request in the same "browser session".
323	330	self.getPage('/session_cookie', self.cookies)
324		cookie_parts = dict([p.strip().split('=') for p in self.cookies[0][1].split(";")])
	331	cookie_parts = dict([p.strip().split('=')
	332	for p in self.cookies[0][1].split(";")])
325	333	# Assert there is no 'expires' param
326	334	self.assertEqual(set(cookie_parts.keys()), set(['temp', 'Path']))
327	335	self.assertBody(id1)
328	336	self.assertEqual(copykeys(sessions.RamSession.cache), [id1])
329
	337
330	338	# Simulate a browser close by just not sending the cookies
331	339	self.getPage('/session_cookie')
332	340	# grab the cookie ID
333		cookie_parts = dict([p.strip().split('=') for p in self.cookies[0][1].split(";")])
	341	cookie_parts = dict([p.strip().split('=')
	342	for p in self.cookies[0][1].split(";")])
334	343	# Assert there is no 'expires' param
335	344	self.assertEqual(set(cookie_parts.keys()), set(['temp', 'Path']))
336	345	# Assert a new id has been generated...
337	346	id2 = cookie_parts['temp']
338	347	self.assertNotEqual(id1, id2)
339		self.assertEqual(set(sessions.RamSession.cache.keys()), set([id1, id2]))
340
	348	self.assertEqual(set(sessions.RamSession.cache.keys()),
	349	set([id1, id2]))
	350
341	351	# Wait for the session.timeout on both sessions
342	352	time.sleep(2.5)
343	353	cache = copykeys(sessions.RamSession.cache)

351	361	import socket
352	362	try:
353	363	import memcache
354
	364
355	365	host, port = '127.0.0.1', 11211
356	366	for res in socket.getaddrinfo(host, port, socket.AF_UNSPEC,
357	367	socket.SOCK_STREAM):

372	382	except (ImportError, socket.error):
373	383	class MemcachedSessionTest(helper.CPWebCase):
374	384	setup_server = staticmethod(setup_server)
375
	385
376	386	def test(self):
377	387	return self.skip("memcached not reachable ")
378	388	else:
379	389	class MemcachedSessionTest(helper.CPWebCase):
380	390	setup_server = staticmethod(setup_server)
381
	391
382	392	def test_0_Session(self):
383	393	self.getPage('/setsessiontype/memcached')
384
	394
385	395	self.getPage('/testStr')
386	396	self.assertBody('1')
387	397	self.getPage('/testGen', self.cookies)

393	403	self.assertInBody("NotImplementedError")
394	404	self.getPage('/delkey?key=counter', self.cookies)
395	405	self.assertStatus(200)
396
	406
397	407	# Wait for the session.timeout (1 second)
398	408	time.sleep(1.25)
399	409	self.getPage('/')
400	410	self.assertBody('1')
401
	411
402	412	# Test session __contains__
403	413	self.getPage('/keyin?key=counter', self.cookies)
404	414	self.assertBody("True")
405
	415
406	416	# Test session delete
407	417	self.getPage('/delete', self.cookies)
408	418	self.assertBody("done")
409
	419
410	420	def test_1_Concurrency(self):
411	421	client_thread_count = 5
412	422	request_count = 30
413
	423
414	424	# Get initial cookie
415	425	self.getPage("/")
416	426	self.assertBody("1")
417	427	cookies = self.cookies
418
	428
419	429	data_dict = {}
420
	430
421	431	def request(index):
422	432	for i in range(request_count):
423	433	self.getPage("/", cookies)

426	436	if not self.body.isdigit():
427	437	self.fail(self.body)
428	438	data_dict[index] = v = int(self.body)
429
	439
430	440	# Start <request_count> concurrent requests from
431	441	# each of <client_thread_count> clients
432	442	ts = []

435	445	t = threading.Thread(target=request, args=(c,))
436	446	ts.append(t)
437	447	t.start()
438
	448
439	449	for t in ts:
440	450	t.join()
441
	451
442	452	hitcount = max(data_dict.values())
443	453	expected = 1 + (client_thread_count * request_count)
444	454	self.assertEqual(hitcount, expected)
445
	455
446	456	def test_3_Redirect(self):
447	457	# Start a new session
448	458	self.getPage('/testStr')
449	459	self.getPage('/iredir', self.cookies)
450	460	self.assertBody("memcached")
451
	461
452	462	def test_5_Error_paths(self):
453	463	self.getPage('/unknown/page')
454		self.assertErrorPage(404, "The path '/unknown/page' was not found.")
455
	464	self.assertErrorPage(
	465	404, "The path '/unknown/page' was not found.")
	466
456	467	# Note: this path is not the same as above. The above
457	468	# takes a normal route through the session code; this one
458	469	# skips the session code's before_handler and only calls

460	471	# code has to survive calling save/close without init.
461	472	self.getPage('/restricted', self.cookies, method='POST')
462	473	self.assertErrorPage(405, response_codes[405][1])
463

+20

-21

cherrypy/test/test_sessionauthenticate.py less more

4	4	class SessionAuthenticateTest(helper.CPWebCase):
5	5
6	6	def setup_server():
7
	7
8	8	def check(username, password):
9	9	# Dummy check_username_and_password function
10	10	if username != 'test' or password != 'password':
11	11	return 'Wrong login/password'
12
	12
13	13	def augment_params():
14	14	# A simple tool to add some things to request.params
15		# This is to check to make sure that session_auth can handle request
16		# params (ticket #780)
	15	# This is to check to make sure that session_auth can handle
	16	# request params (ticket #780)
17	17	cherrypy.request.params["test"] = "test"
18	18
19		cherrypy.tools.augment_params = cherrypy.Tool('before_handler',
20		augment_params, None, priority=30)
	19	cherrypy.tools.augment_params = cherrypy.Tool(
	20	'before_handler', augment_params, None, priority=30)
21	21
22	22	class Test:
23
24		_cp_config = {'tools.sessions.on': True,
25		'tools.session_auth.on': True,
26		'tools.session_auth.check_username_and_password': check,
27		'tools.augment_params.on': True,
28		}
29
	23
	24	_cp_config = {
	25	'tools.sessions.on': True,
	26	'tools.session_auth.on': True,
	27	'tools.session_auth.check_username_and_password': check,
	28	'tools.augment_params.on': True,
	29	}
	30
30	31	def index(self, **kwargs):
31	32	return "Hi %s, you are logged in" % cherrypy.request.login
32	33	index.exposed = True
33
	34
34	35	cherrypy.tree.mount(Test())
35	36	setup_server = staticmethod(setup_server)
36	37
37
38	38	def testSessionAuthenticate(self):
39	39	# request a page and check for login form
40	40	self.getPage('/')
41	41	self.assertInBody('<form method="post" action="do_login">')
42
	42
43	43	# setup credentials
44	44	login_body = 'username=test&password=password&from_page=/'
45
	45
46	46	# attempt a login
47	47	self.getPage('/do_login', method='POST', body=login_body)
48	48	self.assertStatus((302, 303))
49
	49
50	50	# get the page now that we are logged in
51	51	self.getPage('/', self.cookies)
52	52	self.assertBody('Hi test, you are logged in')
53
	53
54	54	# do a logout
55	55	self.getPage('/do_logout', self.cookies, method='POST')
56	56	self.assertStatus((302, 303))
57
	57
58	58	# verify we are logged out
59	59	self.getPage('/', self.cookies)
60	60	self.assertInBody('<form method="post" action="do_login">')
61

+122

-50

cherrypy/test/test_states.py less more

	0	import os
	1	import signal
	2	import socket
	3	import sys
	4	import time
	5	import unittest
	6	import warnings
	7
	8	import cherrypy
	9	import cherrypy.process.servers
0	10	from cherrypy._cpcompat import BadStatusLine, ntob
1		import os
2		import sys
3		import threading
4		import time
5
6		import cherrypy
	11	from cherrypy.test import helper
	12
7	13	engine = cherrypy.engine
8	14	thisdir = os.path.join(os.getcwd(), os.path.dirname(__file__))
9	15

42	48
43	49	db_connection = Dependency(engine)
44	50
	51
45	52	def setup_server():
46	53	class Root:
	54
47	55	def index(self):
48	56	return "Hello World"
49	57	index.exposed = True

74	82	cherrypy.config.update({
75	83	'environment': 'test_suite',
76	84	'engine.deadlock_poll_freq': 0.1,
77		})
	85	})
78	86
79	87	db_connection.subscribe()
80	88
81
82
83	89	# ------------ Enough helpers. Time for real live test cases. ------------ #
84	90
85
86		from cherrypy.test import helper
87	91
88	92	class ServerStateTests(helper.CPWebCase):
89	93	setup_server = staticmethod(setup_server)

244	248	engine.exit()
245	249
246	250	def test_4_Autoreload(self):
	251	# If test_3 has not been executed, the server won't be stopped,
	252	# so we'll have to do it.
	253	if engine.state != engine.states.EXITING:
	254	engine.exit()
	255
247	256	# Start the demo script in a new process
248		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'))
249		p.write_conf(
250		extra='test_case_name: "test_4_Autoreload"')
	257	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'))
	258	p.write_conf(extra='test_case_name: "test_4_Autoreload"')
251	259	p.start(imports='cherrypy.test._test_states_demo')
252	260	try:
253	261	self.getPage("/start")

275	283	p.join()
276	284
277	285	def test_5_Start_Error(self):
	286	# If test_3 has not been executed, the server won't be stopped,
	287	# so we'll have to do it.
	288	if engine.state != engine.states.EXITING:
	289	engine.exit()
	290
278	291	# If a process errors during start, it should stop the engine
279	292	# and exit with a non-zero exit code.
280		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'),
	293	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
281	294	wait=True)
282	295	p.write_conf(
283		extra="""starterror: True
	296	extra="""starterror: True
284	297	test_case_name: "test_5_Start_Error"
285	298	"""
286	299	)

290	303
291	304
292	305	class PluginTests(helper.CPWebCase):
	306
293	307	def test_daemonize(self):
294	308	if os.name not in ['posix']:
295	309	return self.skip("skipped (not on posix) ")

298	312	# Spawn the process and wait, when this returns, the original process
299	313	# is finished. If it daemonized properly, we should still be able
300	314	# to access pages.
301		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'),
	315	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
302	316	wait=True, daemonize=True,
303	317	socket_host='127.0.0.1',
304	318	socket_port=8081)
305	319	p.write_conf(
306		extra='test_case_name: "test_daemonize"')
	320	extra='test_case_name: "test_daemonize"')
307	321	p.start(imports='cherrypy.test._test_states_demo')
308	322	try:
309	323	# Just get the pid of the daemonization process.

323	337
324	338
325	339	class SignalHandlingTests(helper.CPWebCase):
	340
326	341	def test_SIGHUP_tty(self):
327	342	# When not daemonized, SIGHUP should shut down the server.
328	343	try:

331	346	return self.skip("skipped (no SIGHUP) ")
332	347
333	348	# Spawn the process.
334		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'))
	349	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'))
335	350	p.write_conf(
336		extra='test_case_name: "test_SIGHUP_tty"')
	351	extra='test_case_name: "test_SIGHUP_tty"')
337	352	p.start(imports='cherrypy.test._test_states_demo')
338	353	# Send a SIGHUP
339	354	os.kill(p.get_pid(), SIGHUP)

353	368	# Spawn the process and wait, when this returns, the original process
354	369	# is finished. If it daemonized properly, we should still be able
355	370	# to access pages.
356		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'),
	371	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
357	372	wait=True, daemonize=True)
358	373	p.write_conf(
359		extra='test_case_name: "test_SIGHUP_daemonized"')
	374	extra='test_case_name: "test_SIGHUP_daemonized"')
360	375	p.start(imports='cherrypy.test._test_states_demo')
361	376
362	377	pid = p.get_pid()

374	389	self.getPage("/exit")
375	390	p.join()
376	391
	392	def _require_signal_and_kill(self, signal_name):
	393	if not hasattr(signal, signal_name):
	394	self.skip("skipped (no %(signal_name)s)" % vars())
	395
	396	if not hasattr(os, 'kill'):
	397	self.skip("skipped (no os.kill)")
	398
377	399	def test_SIGTERM(self):
378		# SIGTERM should shut down the server whether daemonized or not.
379		try:
380		from signal import SIGTERM
381		except ImportError:
382		return self.skip("skipped (no SIGTERM) ")
383
384		try:
385		from os import kill
386		except ImportError:
387		return self.skip("skipped (no os.kill) ")
	400	"SIGTERM should shut down the server whether daemonized or not."
	401	self._require_signal_and_kill('SIGTERM')
388	402
389	403	# Spawn a normal, undaemonized process.
390		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'))
	404	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'))
391	405	p.write_conf(
392		extra='test_case_name: "test_SIGTERM"')
	406	extra='test_case_name: "test_SIGTERM"')
393	407	p.start(imports='cherrypy.test._test_states_demo')
394	408	# Send a SIGTERM
395		os.kill(p.get_pid(), SIGTERM)
	409	os.kill(p.get_pid(), signal.SIGTERM)
396	410	# This might hang if things aren't working right, but meh.
397	411	p.join()
398	412
399	413	if os.name in ['posix']:
400	414	# Spawn a daemonized process and test again.
401		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'),
	415	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
402	416	wait=True, daemonize=True)
403	417	p.write_conf(
404		extra='test_case_name: "test_SIGTERM_2"')
	418	extra='test_case_name: "test_SIGTERM_2"')
405	419	p.start(imports='cherrypy.test._test_states_demo')
406	420	# Send a SIGTERM
407		os.kill(p.get_pid(), SIGTERM)
	421	os.kill(p.get_pid(), signal.SIGTERM)
408	422	# This might hang if things aren't working right, but meh.
409	423	p.join()
410	424
411	425	def test_signal_handler_unsubscribe(self):
412		try:
413		from signal import SIGTERM
414		except ImportError:
415		return self.skip("skipped (no SIGTERM) ")
416
417		try:
418		from os import kill
419		except ImportError:
420		return self.skip("skipped (no os.kill) ")
	426	self._require_signal_and_kill('SIGTERM')
	427
	428	# Although Windows has `os.kill` and SIGTERM is defined, the
	429	# platform does not implement signals and sending SIGTERM
	430	# will result in a forced termination of the process.
	431	# Therefore, this test is not suitable for Windows.
	432	if os.name == 'nt':
	433	self.skip("SIGTERM not available")
421	434
422	435	# Spawn a normal, undaemonized process.
423		p = helper.CPProcess(ssl=(self.scheme.lower()=='https'))
	436	p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'))
424	437	p.write_conf(
425	438	extra="""unsubsig: True
426	439	test_case_name: "test_signal_handler_unsubscribe"
427	440	""")
428	441	p.start(imports='cherrypy.test._test_states_demo')
429		# Send a SIGTERM
430		os.kill(p.get_pid(), SIGTERM)
	442	# Ask the process to quit
	443	os.kill(p.get_pid(), signal.SIGTERM)
431	444	# This might hang if things aren't working right, but meh.
432	445	p.join()
433	446

436	449	if not ntob("I am an old SIGTERM handler.") in target_line:
437	450	self.fail("Old SIGTERM handler did not run.\n%r" % target_line)
438	451
	452
	453	class WaitTests(unittest.TestCase):
	454
	455	def test_wait_for_occupied_port_INADDR_ANY(self):
	456	"""
	457	Wait on INADDR_ANY should not raise IOError
	458
	459	In cases where the loopback interface does not exist, CherryPy cannot
	460	effectively determine if a port binding to INADDR_ANY was effected.
	461	In this situation, CherryPy should assume that it failed to detect
	462	the binding (not that the binding failed) and only warn that it could
	463	not verify it.
	464	"""
	465	# At such a time that CherryPy can reliably determine one or more
	466	# viable IP addresses of the host, this test may be removed.
	467
	468	# Simulate the behavior we observe when no loopback interface is
	469	# present by: finding a port that's not occupied, then wait on it.
	470
	471	free_port = self.find_free_port()
	472
	473	servers = cherrypy.process.servers
	474
	475	def with_shorter_timeouts(func):
	476	"""
	477	A context where occupied_port_timeout is much smaller to speed
	478	test runs.
	479	"""
	480	# When we have Python 2.5, simplify using the with_statement.
	481	orig_timeout = servers.occupied_port_timeout
	482	servers.occupied_port_timeout = .07
	483	try:
	484	func()
	485	finally:
	486	servers.occupied_port_timeout = orig_timeout
	487
	488	def do_waiting():
	489	# Wait on the free port that's unbound
	490	with warnings.catch_warnings(record=True) as w:
	491	servers.wait_for_occupied_port('0.0.0.0', free_port)
	492	self.assertEqual(len(w), 1)
	493	self.assertTrue(isinstance(w[0], warnings.WarningMessage))
	494	self.assertTrue(
	495	'Unable to verify that the server is bound on ' in str(w[0]))
	496
	497	# The wait should still raise an IO error if INADDR_ANY was
	498	# not supplied.
	499	self.assertRaises(IOError, servers.wait_for_occupied_port,
	500	'127.0.0.1', free_port)
	501
	502	with_shorter_timeouts(do_waiting)
	503
	504	def find_free_port(self):
	505	"Find a free port by binding to port 0 then unbinding."
	506	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	507	sock.bind(('', 0))
	508	free_port = sock.getsockname()[1]
	509	sock.close()
	510	return free_port

+70

-51

cherrypy/test/test_static.py less more

	0	import os
	1	import sys
	2
0	3	from cherrypy._cpcompat import HTTPConnection, HTTPSConnection, ntob
1	4	from cherrypy._cpcompat import BytesIO
2	5
3		import os
4	6	curdir = os.path.join(os.getcwd(), os.path.dirname(__file__))
5	7	has_space_filepath = os.path.join(curdir, 'static', 'has space.html')
6	8	bigfile_filepath = os.path.join(curdir, "static", "bigfile.log")
7	9	BIGFILE_SIZE = 1024 * 1024
8		import threading
9	10
10	11	import cherrypy
11	12	from cherrypy.lib import static

19	20	open(has_space_filepath, 'wb').write(ntob('Hello, world\r\n'))
20	21	if not os.path.exists(bigfile_filepath):
21	22	open(bigfile_filepath, 'wb').write(ntob("x" * BIGFILE_SIZE))
22
	23
23	24	class Root:
24
	25
25	26	def bigfile(self):
26	27	from cherrypy.lib import static
27	28	self.f = static.serve_file(bigfile_filepath)
28	29	return self.f
29	30	bigfile.exposed = True
30	31	bigfile._cp_config = {'response.stream': True}
31
	32
32	33	def tell(self):
33	34	if self.f.input.closed:
34	35	return ''
35	36	return repr(self.f.input.tell()).rstrip('L')
36	37	tell.exposed = True
37
	38
38	39	def fileobj(self):
39	40	f = open(os.path.join(curdir, 'style.css'), 'rb')
40	41	return static.serve_fileobj(f, content_type='text/css')
41	42	fileobj.exposed = True
42
	43
43	44	def bytesio(self):
44	45	f = BytesIO(ntob('Fee\nfie\nfo\nfum'))
45	46	return static.serve_fileobj(f, content_type='text/plain')
46	47	bytesio.exposed = True
47
	48
48	49	class Static:
49
	50
50	51	def index(self):
51	52	return 'You want the Baron? You can have the Baron!'
52	53	index.exposed = True
53
	54
54	55	def dynamic(self):
55	56	return "This is a DYNAMIC page"
56	57	dynamic.exposed = True
57
58
	58
59	59	root = Root()
60	60	root.static = Static()
61
	61
62	62	rootconf = {
63	63	'/static': {
64	64	'tools.staticdir.on': True,

79	79	'tools.staticdir.on': True,
80	80	'request.show_tracebacks': True,
81	81	},
	82	'/404test': {
	83	'tools.staticdir.on': True,
	84	'tools.staticdir.root': curdir,
	85	'tools.staticdir.dir': 'static',
	86	'error_page.404': error_page_404,
82	87	}
	88	}
83	89	rootApp = cherrypy.Application(root)
84	90	rootApp.merge(rootconf)
85
	91
86	92	test_app_conf = {
87	93	'/test': {
88	94	'tools.staticdir.index': 'index.html',
89	95	'tools.staticdir.on': True,
90	96	'tools.staticdir.root': curdir,
91	97	'tools.staticdir.dir': 'static',
92		},
93		}
	98	},
	99	}
94	100	testApp = cherrypy.Application(Static())
95	101	testApp.merge(test_app_conf)
96
	102
97	103	vhost = cherrypy._cpwsgi.VirtualHost(rootApp, {'virt.net': testApp})
98	104	cherrypy.tree.graft(vhost)
99	105	setup_server = staticmethod(setup_server)
100
101	106
102	107	def teardown_server():
103	108	for f in (has_space_filepath, bigfile_filepath):

108	113	pass
109	114	teardown_server = staticmethod(teardown_server)
110	115
111
112	116	def testStatic(self):
113	117	self.getPage("/static/index.html")
114	118	self.assertStatus('200 OK')
115	119	self.assertHeader('Content-Type', 'text/html')
116	120	self.assertBody('Hello, world\r\n')
117
	121
118	122	# Using a staticdir.root value in a subdir...
119	123	self.getPage("/docroot/index.html")
120	124	self.assertStatus('200 OK')
121	125	self.assertHeader('Content-Type', 'text/html')
122	126	self.assertBody('Hello, world\r\n')
123
	127
124	128	# Check a filename with spaces in it
125	129	self.getPage("/static/has%20space.html")
126	130	self.assertStatus('200 OK')
127	131	self.assertHeader('Content-Type', 'text/html')
128	132	self.assertBody('Hello, world\r\n')
129
	133
130	134	self.getPage("/style.css")
131	135	self.assertStatus('200 OK')
132	136	self.assertHeader('Content-Type', 'text/css')

135	139	# into \r\n on Windows when extracting the CherryPy tarball so
136	140	# we just check the content
137	141	self.assertMatchesBody('^Dummy stylesheet')
138
	142
139	143	def test_fallthrough(self):
140	144	# Test that NotFound will then try dynamic handlers (see [878]).
141	145	self.getPage("/static/dynamic")
142	146	self.assertBody("This is a DYNAMIC page")
143
	147
144	148	# Check a directory via fall-through to dynamic handler.
145	149	self.getPage("/static/")
146	150	self.assertStatus('200 OK')
147	151	self.assertHeader('Content-Type', 'text/html;charset=utf-8')
148	152	self.assertBody('You want the Baron? You can have the Baron!')
149
	153
150	154	def test_index(self):
151	155	# Check a directory via "staticdir.index".
152	156	self.getPage("/docroot/")

157	161	self.getPage("/docroot")
158	162	self.assertStatus(301)
159	163	self.assertHeader('Location', '%s/docroot/' % self.base())
160		self.assertMatchesBody("This resource .* <a href='%s/docroot/'>"
	164	self.assertMatchesBody("This resource .* <a href=(['\"])%s/docroot/\\1>"
161	165	"%s/docroot/</a>." % (self.base(), self.base()))
162
	166
163	167	def test_config_errors(self):
164	168	# Check that we get an error if no .file or .dir
165	169	self.getPage("/error/thing.html")
166	170	self.assertErrorPage(500)
167		self.assertMatchesBody(ntob("TypeError: staticdir takes at least 2 "
168		"(positional )?arguments $0 given$"))
169
	171	if sys.version_info >= (3, 3):
	172	errmsg = ntob("TypeError: staticdir missing 2 "
	173	"required positional arguments")
	174	else:
	175	errmsg = ntob("TypeError: staticdir takes at least 2 "
	176	"(positional )?arguments $0 given$")
	177	self.assertMatchesBody(errmsg)
	178
170	179	def test_security(self):
171	180	# Test up-level security
172	181	self.getPage("/static/../../test/style.css")
173	182	self.assertStatus((400, 403))
174
	183
175	184	def test_modif(self):
176	185	# Test modified-since on a reasonably-large file
177	186	self.getPage("/static/dirback.jpg")

187	196	self.assertNoHeader("Content-Length")
188	197	self.assertNoHeader("Content-Disposition")
189	198	self.assertBody("")
190
	199
191	200	def test_755_vhost(self):
192	201	self.getPage("/test/", [('Host', 'virt.net')])
193	202	self.assertStatus(200)
194	203	self.getPage("/test", [('Host', 'virt.net')])
195	204	self.assertStatus(301)
196	205	self.assertHeader('Location', self.scheme + '://virt.net/test/')
197
	206
198	207	def test_serve_fileobj(self):
199	208	self.getPage("/fileobj")
200	209	self.assertStatus('200 OK')
201	210	self.assertHeader('Content-Type', 'text/css;charset=utf-8')
202	211	self.assertMatchesBody('^Dummy stylesheet')
203
	212
204	213	def test_serve_bytesio(self):
205	214	self.getPage("/bytesio")
206	215	self.assertStatus('200 OK')
207	216	self.assertHeader('Content-Type', 'text/plain;charset=utf-8')
208	217	self.assertHeader('Content-Length', 14)
209	218	self.assertMatchesBody('Fee\nfie\nfo\nfum')
210
	219
211	220	def test_file_stream(self):
212	221	if cherrypy.server.protocol_version != "HTTP/1.1":
213	222	return self.skip()
214
	223
215	224	self.PROTOCOL = "HTTP/1.1"
216
	225
217	226	# Make an initial request
218	227	self.persistent = True
219	228	conn = self.HTTP_CONN

223	232	response = conn.response_class(conn.sock, method="GET")
224	233	response.begin()
225	234	self.assertEqual(response.status, 200)
226
	235
227	236	body = ntob('')
228	237	remaining = BIGFILE_SIZE
229	238	while remaining > 0:

232	241	break
233	242	body += data
234	243	remaining -= len(data)
235
	244
236	245	if self.scheme == "https":
237	246	newconn = HTTPSConnection
238	247	else:

245	254	tell_position = BIGFILE_SIZE
246	255	else:
247	256	tell_position = int(b)
248
	257
249	258	expected = len(body)
250	259	if tell_position >= BIGFILE_SIZE:
251		# We can't exactly control how much content the server asks for.
	260	# We can't exactly control how much content the server asks
	261	# for.
252	262	# Fudge it by only checking the first half of the reads.
253	263	if expected < (BIGFILE_SIZE / 2):
254	264	self.fail(
255		"The file should have advanced to position %r, but has "
256		"already advanced to the end of the file. It may not be "
257		"streamed as intended, or at the wrong chunk size (64k)" %
258		expected)
	265	"The file should have advanced to position %r, but "
	266	"has already advanced to the end of the file. It "
	267	"may not be streamed as intended, or at the wrong "
	268	"chunk size (64k)" % expected)
259	269	elif tell_position < expected:
260	270	self.fail(
261	271	"The file should have advanced to position %r, but has "
262	272	"only advanced to position %r. It may not be streamed "
263	273	"as intended, or at the wrong chunk size (65536)" %
264	274	(expected, tell_position))
265
	275
266	276	if body != ntob("x" * BIGFILE_SIZE):
267	277	self.fail("Body != 'x' * %d. Got %r instead (%d bytes)." %
268	278	(BIGFILE_SIZE, body[:50], len(body)))
269	279	conn.close()
270
	280
271	281	def test_file_stream_deadlock(self):
272	282	if cherrypy.server.protocol_version != "HTTP/1.1":
273	283	return self.skip()
274
	284
275	285	self.PROTOCOL = "HTTP/1.1"
276
	286
277	287	# Make an initial request but abort early.
278	288	self.persistent = True
279	289	conn = self.HTTP_CONN

289	299	(65536, body[:50], len(body)))
290	300	response.close()
291	301	conn.close()
292
	302
293	303	# Make a second request, which should fetch the whole file.
294	304	self.persistent = False
295	305	self.getPage("/bigfile")
296	306	if self.body != ntob("x" * BIGFILE_SIZE):
297	307	self.fail("Body != 'x' * %d. Got %r instead (%d bytes)." %
298	308	(BIGFILE_SIZE, self.body[:50], len(body)))
299
	309
	310	def test_error_page_with_serve_file(self):
	311	self.getPage("/404test/yunyeen")
	312	self.assertStatus(404)
	313	self.assertInBody("I couldn't find that thing")
	314
	315	def error_page_404(status, message, traceback, version):
	316	import os.path
	317	return static.serve_file(os.path.join(curdir, 'static', '404.html'),
	318	content_type='text/html')

+96

-69

cherrypy/test/test_tools.py less more

1	1
2	2	import gzip
3	3	import sys
	4	import unittest
4	5	from cherrypy._cpcompat import BytesIO, copyitems, itervalues
5	6	from cherrypy._cpcompat import IncompleteRead, ntob, ntou, py3k, xrange
	7	from cherrypy._cpcompat import bytestr, unicodestr
6	8	import time
7	9	timeout = 0.2
8	10	import types

20	22
21	23
22	24	class ToolTests(helper.CPWebCase):
	25
23	26	def setup_server():
24
	27
25	28	# Put check_access in a custom toolbox with its own namespace
26	29	myauthtools = cherrypy._cptools.Toolbox("myauth")
27
	30
28	31	def check_access(default=False):
29	32	if not getattr(cherrypy.request, "userid", default):
30	33	raise cherrypy.HTTPError(401)
31		myauthtools.check_access = cherrypy.Tool('before_request_body', check_access)
32
	34	myauthtools.check_access = cherrypy.Tool(
	35	'before_request_body', check_access)
	36
33	37	def numerify():
34	38	def number_it(body):
35	39	for chunk in body:

37	41	chunk = chunk.replace(k, v)
38	42	yield chunk
39	43	cherrypy.response.body = number_it(cherrypy.response.body)
40
	44
41	45	class NumTool(cherrypy.Tool):
	46
42	47	def _setup(self):
43	48	def makemap():
44	49	m = self._merged_args().get("map", {})
45	50	cherrypy.request.numerify_map = copyitems(m)
46	51	cherrypy.request.hooks.attach('on_start_resource', makemap)
47
	52
48	53	def critical():
49		cherrypy.request.error_response = cherrypy.HTTPError(502).set_response
	54	cherrypy.request.error_response = cherrypy.HTTPError(
	55	502).set_response
50	56	critical.failsafe = True
51
	57
52	58	cherrypy.request.hooks.attach('on_start_resource', critical)
53	59	cherrypy.request.hooks.attach(self._point, self.callable)
54
	60
55	61	tools.numerify = NumTool('before_finalize', numerify)
56
	62
57	63	# It's not mandatory to inherit from cherrypy.Tool.
58	64	class NadsatTool:
59
	65
60	66	def __init__(self):
61	67	self.ended = {}
62	68	self._name = "nadsat"
63
	69
64	70	def nadsat(self):
65	71	def nadsat_it_up(body):
66	72	for chunk in body:

69	75	yield chunk
70	76	cherrypy.response.body = nadsat_it_up(cherrypy.response.body)
71	77	nadsat.priority = 0
72
	78
73	79	def cleanup(self):
74	80	# This runs after the request has been completely written out.
75	81	cherrypy.response.body = [ntob("razdrez")]

77	83	if id:
78	84	self.ended[id] = True
79	85	cleanup.failsafe = True
80
	86
81	87	def _setup(self):
82	88	cherrypy.request.hooks.attach('before_finalize', self.nadsat)
83	89	cherrypy.request.hooks.attach('on_end_request', self.cleanup)
84	90	tools.nadsat = NadsatTool()
85
	91
86	92	def pipe_body():
87	93	cherrypy.request.process_request_body = False
88	94	clen = int(cherrypy.request.headers['Content-Length'])
89	95	cherrypy.request.body = cherrypy.request.rfile.read(clen)
90
	96
91	97	# Assert that we can use a callable object instead of a function.
92	98	class Rotator(object):
	99
93	100	def __call__(self, scale):
94	101	r = cherrypy.response
95	102	r.collapse_body()

98	105	else:
99	106	r.body = [chr((ord(x) + scale) % 256) for x in r.body[0]]
100	107	cherrypy.tools.rotator = cherrypy.Tool('before_finalize', Rotator())
101
	108
102	109	def stream_handler(next_handler, args, *kwargs):
103	110	cherrypy.response.output = o = BytesIO()
104	111	try:
105	112	response = next_handler(args, *kwargs)
106		# Ignore the response and return our accumulated output instead.
	113	# Ignore the response and return our accumulated output
	114	# instead.
107	115	return o.getvalue()
108	116	finally:
109	117	o.close()
110		cherrypy.tools.streamer = cherrypy._cptools.HandlerWrapperTool(stream_handler)
111
	118	cherrypy.tools.streamer = cherrypy._cptools.HandlerWrapperTool(
	119	stream_handler)
	120
112	121	class Root:
	122
113	123	def index(self):
114	124	return "Howdy earth!"
115	125	index.exposed = True
116
	126
117	127	def tarfile(self):
118	128	cherrypy.response.output.write(ntob('I am '))
119	129	cherrypy.response.output.write(ntob('a tarfile'))
120	130	tarfile.exposed = True
121	131	tarfile._cp_config = {'tools.streamer.on': True}
122
	132
123	133	def euro(self):
124	134	hooks = list(cherrypy.request.hooks['before_finalize'])
125	135	hooks.sort()

131	141	yield ntou("world")
132	142	yield europoundUnicode
133	143	euro.exposed = True
134
	144
135	145	# Bare hooks
136	146	def pipe(self):
137	147	return cherrypy.request.body
138	148	pipe.exposed = True
139	149	pipe._cp_config = {'hooks.before_request_body': pipe_body}
140
	150
141	151	# Multiple decorators; include kwargs just for fun.
142	152	# Note that rotator must run before gzip.
143	153	def decorated_euro(self, *vpath):

147	157	decorated_euro.exposed = True
148	158	decorated_euro = tools.gzip(compress_level=6)(decorated_euro)
149	159	decorated_euro = tools.rotator(scale=3)(decorated_euro)
150
	160
151	161	root = Root()
152
153
	162
154	163	class TestType(type):
155		"""Metaclass which automatically exposes all functions in each subclass,
156		and adds an instance of the subclass as an attribute of root.
	164	"""Metaclass which automatically exposes all functions in each
	165	subclass, and adds an instance of the subclass as an attribute
	166	of root.
157	167	"""
158	168	def __init__(cls, name, bases, dct):
159	169	type.__init__(cls, name, bases, dct)

162	172	value.exposed = True
163	173	setattr(root, name.lower(), cls())
164	174	Test = TestType('Test', (object,), {})
165
166
	175
167	176	# METHOD ONE:
168	177	# Declare Tools in _cp_config
169	178	class Demo(Test):
170
	179
171	180	_cp_config = {"tools.nadsat.on": True}
172
	181
173	182	def index(self, id=None):
174	183	return "A good piece of cherry pie"
175
	184
176	185	def ended(self, id):
177	186	return repr(tools.nadsat.ended[id])
178
	187
179	188	def err(self, id=None):
180	189	raise ValueError()
181
	190
182	191	def errinstream(self, id=None):
183	192	yield "nonconfidential"
184	193	raise ValueError()
185	194	yield "confidential"
186
	195
187	196	# METHOD TWO: decorator using Tool()
188		# We support Python 2.3, but the @-deco syntax would look like this:
	197	# We support Python 2.3, but the @-deco syntax would look like
	198	# this:
189	199	# @tools.check_access()
190	200	def restricted(self):
191	201	return "Welcome!"
192	202	restricted = myauthtools.check_access()(restricted)
193	203	userid = restricted
194
	204
195	205	def err_in_onstart(self):
196	206	return "success!"
197
	207
198	208	def stream(self, id=None):
199	209	for x in xrange(100000000):
200	210	yield str(x)
201	211	stream._cp_config = {'response.stream': True}
202
203
	212
204	213	conf = {
205	214	# METHOD THREE:
206	215	# Declare Tools in detached config

236	245	}
237	246	app = cherrypy.tree.mount(root, config=conf)
238	247	app.request_class.namespaces['myauth'] = myauthtools
239
	248
240	249	if sys.version_info >= (2, 5):
241	250	from cherrypy.test import _test_decorators
242	251	root.tooldecs = _test_decorators.ToolExamples()

250	259	time.sleep(0.1)
251	260	self.getPage("/demo/ended/1")
252	261	self.assertBody("True")
253
	262
254	263	valerr = '\n raise ValueError()\nValueError'
255	264	self.getPage("/demo/err?id=3")
256	265	# If body is "razdrez", then on_end_request is being called too early.

259	268	time.sleep(0.1)
260	269	self.getPage("/demo/ended/3")
261	270	self.assertBody("True")
262
	271
263	272	# If body is "razdrez", then on_end_request is being called too early.
264	273	if (cherrypy.server.protocol_version == "HTTP/1.0" or
265		getattr(cherrypy.server, "using_apache", False)):
	274	getattr(cherrypy.server, "using_apache", False)):
266	275	self.getPage("/demo/errinstream?id=5")
267	276	# Because this error is raised after the response body has
268	277	# started, the status should not change to an error status.

278	287	time.sleep(0.1)
279	288	self.getPage("/demo/ended/5")
280	289	self.assertBody("True")
281
	290
282	291	# Test the "__call__" technique (compile-time decorator).
283	292	self.getPage("/demo/restricted")
284	293	self.assertErrorPage(401)
285
	294
286	295	# Test compile-time decorator with kwargs from config.
287	296	self.getPage("/demo/userid")
288	297	self.assertBody("Welcome!")
289
	298
290	299	def testEndRequestOnDrop(self):
291	300	old_timeout = None
292	301	try:

294	303	old_timeout = httpserver.timeout
295	304	except (AttributeError, IndexError):
296	305	return self.skip()
297
	306
298	307	try:
299	308	httpserver.timeout = timeout
300
	309
301	310	# Test that on_end_request is called even if the client drops.
302	311	self.persistent = True
303	312	try:

319	328	finally:
320	329	if old_timeout is not None:
321	330	httpserver.timeout = old_timeout
322
	331
323	332	def testGuaranteedHooks(self):
324	333	# The 'critical' on_start_resource hook is 'failsafe' (guaranteed
325	334	# to run even if there are failures in other on_start methods).

328	337	# but our 'critical' hook should run and set the error to 502.
329	338	self.getPage("/demo/err_in_onstart")
330	339	self.assertErrorPage(502)
331		self.assertInBody("AttributeError: 'str' object has no attribute 'items'")
332
	340	self.assertInBody(
	341	"AttributeError: 'str' object has no attribute 'items'")
	342
333	343	def testCombinedTools(self):
334		expectedResult = (ntou("Hello,world") + europoundUnicode).encode('utf-8')
	344	expectedResult = (ntou("Hello,world") +
	345	europoundUnicode).encode('utf-8')
335	346	zbuf = BytesIO()
336	347	zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)
337	348	zfile.write(expectedResult)
338	349	zfile.close()
339
340		self.getPage("/euro", headers=[("Accept-Encoding", "gzip"),
341		("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7")])
	350
	351	self.getPage("/euro",
	352	headers=[
	353	("Accept-Encoding", "gzip"),
	354	("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7")])
342	355	self.assertInBody(zbuf.getvalue()[:3])
343
	356
344	357	zbuf = BytesIO()
345	358	zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=6)
346	359	zfile.write(expectedResult)
347	360	zfile.close()
348
	361
349	362	self.getPage("/decorated_euro", headers=[("Accept-Encoding", "gzip")])
350	363	self.assertInBody(zbuf.getvalue()[:3])
351
	364
352	365	# This returns a different value because gzip's priority was
353	366	# lowered in conf, allowing the rotator to run after gzip.
354	367	# Of course, we don't want breakage in production apps,

358	371	if py3k:
359	372	self.assertInBody(bytes([(x + 3) % 256 for x in zbuf.getvalue()]))
360	373	else:
361		self.assertInBody(''.join([chr((ord(x) + 3) % 256) for x in zbuf.getvalue()]))
362
	374	self.assertInBody(''.join([chr((ord(x) + 3) % 256)
	375	for x in zbuf.getvalue()]))
	376
363	377	def testBareHooks(self):
364	378	content = "bit of a pain in me gulliver"
365	379	self.getPage("/pipe",

367	381	("Content-Type", "text/plain")],
368	382	method="POST", body=content)
369	383	self.assertBody(content)
370
	384
371	385	def testHandlerWrapperTool(self):
372	386	self.getPage("/tarfile")
373	387	self.assertBody("I am a tarfile")
374
	388
375	389	def testToolWithConfig(self):
376	390	if not sys.version_info >= (2, 5):
377	391	return self.skip("skipped (Python 2.5+ only)")
378
	392
379	393	self.getPage('/tooldecs/blah')
380	394	self.assertHeader('Content-Type', 'application/data')
381
	395
382	396	def testWarnToolOn(self):
383	397	# get
384	398	try:
385		numon = cherrypy.tools.numerify.on
	399	cherrypy.tools.numerify.on
386	400	except AttributeError:
387	401	pass
388	402	else:
389	403	raise AssertionError("Tool.on did not error as it should have.")
390
	404
391	405	# set
392	406	try:
393	407	cherrypy.tools.numerify.on = True

396	410	else:
397	411	raise AssertionError("Tool.on did not error as it should have.")
398	412
	413
	414	class SessionAuthTest(unittest.TestCase):
	415
	416	def test_login_screen_returns_bytes(self):
	417	"""
	418	login_screen must return bytes even if unicode parameters are passed.
	419	Issue 1132 revealed that login_screen would return unicode if the
	420	username and password were unicode.
	421	"""
	422	sa = cherrypy.lib.cptools.SessionAuth()
	423	res = sa.login_screen(None, username=unicodestr('nobody'),
	424	password=unicodestr('anypass'))
	425	self.assertTrue(isinstance(res, bytestr))

+57

-54

cherrypy/test/test_tutorials.py less more

6	6	class TutorialTest(helper.CPWebCase):
7	7
8	8	def setup_server(cls):
9
	9
10	10	conf = cherrypy.config.copy()
11
	11
12	12	def load_tut_module(name):
13	13	"""Import or reload tutorial module as needed."""
14	14	cherrypy.config.reset()
15	15	cherrypy.config.update(conf)
16
	16
17	17	target = "cherrypy.tutorial." + name
18	18	if target in sys.modules:
19	19	module = reload(sys.modules[target])

21	21	module = __import__(target, globals(), locals(), [''])
22	22	# The above import will probably mount a new app at "".
23	23	app = cherrypy.tree.apps[""]
24
	24
25	25	app.root.load_tut_module = load_tut_module
26	26	app.root.sessions = sessions
27	27	app.root.traceback_setting = traceback_setting
28
	28
29	29	cls.supervisor.sync_apps()
30	30	load_tut_module.exposed = True
31
	31
32	32	def sessions():
33	33	cherrypy.config.update({"tools.sessions.on": True})
34	34	sessions.exposed = True
35
	35
36	36	def traceback_setting():
37	37	return repr(cherrypy.request.show_tracebacks)
38	38	traceback_setting.exposed = True
39
	39
40	40	class Dummy:
41	41	pass
42	42	root = Dummy()

44	44	cherrypy.tree.mount(root)
45	45	setup_server = classmethod(setup_server)
46	46
47
48	47	def test01HelloWorld(self):
49	48	self.getPage("/load_tut_module/tut01_helloworld")
50	49	self.getPage("/")
51	50	self.assertBody('Hello world!')
52
	51
53	52	def test02ExposeMethods(self):
54	53	self.getPage("/load_tut_module/tut02_expose_methods")
55		self.getPage("/showMessage")
	54	self.getPage("/show_msg")
56	55	self.assertBody('Hello world!')
57
	56
58	57	def test03GetAndPost(self):
59	58	self.getPage("/load_tut_module/tut03_get_and_post")
60
	59
61	60	# Try different GET queries
62	61	self.getPage("/greetUser?name=Bob")
63	62	self.assertBody("Hey Bob, what's up?")
64
	63
65	64	self.getPage("/greetUser")
66	65	self.assertBody('Please enter your name <a href="./">here</a>.')
67
	66
68	67	self.getPage("/greetUser?name=")
69	68	self.assertBody('No, really, enter your name <a href="./">here</a>.')
70
	69
71	70	# Try the same with POST
72	71	self.getPage("/greetUser", method="POST", body="name=Bob")
73	72	self.assertBody("Hey Bob, what's up?")
74
	73
75	74	self.getPage("/greetUser", method="POST", body="name=")
76	75	self.assertBody('No, really, enter your name <a href="./">here</a>.')
77
	76
78	77	def test04ComplexSite(self):
79	78	self.getPage("/load_tut_module/tut04_complex_site")
80	79	msg = '''
81	80	<p>Here are some extra useful links:</p>
82
	81
83	82	<ul>
84	83	<li><a href="http://del.icio.us">del.icio.us</a></li>
85		<li><a href="http://www.mornography.de">Hendrik's weblog</a></li>
	84	<li><a href="http://www.cherrypy.org">CherryPy</a></li>
86	85	</ul>
87
	86
88	87	<p>[<a href="../">Return to links page</a>]</p>'''
89	88	self.getPage("/links/extra/")
90	89	self.assertBody(msg)
91
	90
92	91	def test05DerivedObjects(self):
93	92	self.getPage("/load_tut_module/tut05_derived_objects")
94	93	msg = '''

98	97	<head>
99	98	<body>
100	99	<h2>Another Page</h2>
101
	100
102	101	<p>
103	102	And this is the amazing second page!
104	103	</p>
105
	104
106	105	</body>
107	106	</html>
108	107	'''
	108	# the tutorial has some annoying spaces in otherwise blank lines
	109	msg = msg.replace('</h2>\n\n', '</h2>\n \n')
	110	msg = msg.replace('</p>\n\n', '</p>\n \n')
109	111	self.getPage("/another/")
110	112	self.assertBody(msg)
111
	113
112	114	def test06DefaultMethod(self):
113	115	self.getPage("/load_tut_module/tut06_default_method")
114	116	self.getPage('/hendrik')
115	117	self.assertBody('Hendrik Mans, CherryPy co-developer & crazy German '
116	118	'(<a href="./">back</a>)')
117
	119
118	120	def test07Sessions(self):
119	121	self.getPage("/load_tut_module/tut07_sessions")
120	122	self.getPage("/sessions")
121
	123
122	124	self.getPage('/')
123		self.assertBody("\n During your current session, you've viewed this"
124		"\n page 1 times! Your life is a patio of fun!"
125		"\n ")
126
	125	self.assertBody(
	126	"\n During your current session, you've viewed this"
	127	"\n page 1 times! Your life is a patio of fun!"
	128	"\n ")
	129
127	130	self.getPage('/', self.cookies)
128		self.assertBody("\n During your current session, you've viewed this"
129		"\n page 2 times! Your life is a patio of fun!"
130		"\n ")
131
	131	self.assertBody(
	132	"\n During your current session, you've viewed this"
	133	"\n page 2 times! Your life is a patio of fun!"
	134	"\n ")
	135
132	136	def test08GeneratorsAndYield(self):
133	137	self.getPage("/load_tut_module/tut08_generators_and_yield")
134	138	self.getPage('/')
135	139	self.assertBody('<html><body><h2>Generators rule!</h2>'
136		'<h3>List of users:</h3>'
137		'Remi<br/>Carlos<br/>Hendrik<br/>Lorenzo Lamas<br/>'
138		'</body></html>')
139
	140	'<h3>List of users:</h3>'
	141	'Remi<br/>Carlos<br/>Hendrik<br/>Lorenzo Lamas<br/>'
	142	'</body></html>')
	143
140	144	def test09Files(self):
141	145	self.getPage("/load_tut_module/tut09_files")
142
	146
143	147	# Test upload
144	148	filesize = 5
145	149	h = [("Content-type", "multipart/form-data; boundary=x"),
146	150	("Content-Length", str(105 + filesize))]
147		b = '--x\n' + \
148		'Content-Disposition: form-data; name="myFile"; filename="hello.txt"\r\n' + \
149		'Content-Type: text/plain\r\n' + \
150		'\r\n' + \
151		'a' * filesize + '\n' + \
152		'--x--\n'
	151	b = ('--x\n'
	152	'Content-Disposition: form-data; name="myFile"; '
	153	'filename="hello.txt"\r\n'
	154	'Content-Type: text/plain\r\n'
	155	'\r\n')
	156	b += 'a' * filesize + '\n' + '--x--\n'
153	157	self.getPage('/upload', h, "POST", b)
154	158	self.assertBody('''<html>
155	159	<body>

158	162	myFile mime-type: text/plain
159	163	</body>
160	164	</html>''' % filesize)
161
	165
162	166	# Test download
163	167	self.getPage('/download')
164	168	self.assertStatus("200 OK")

167	171	# Make sure the filename is quoted.
168	172	'attachment; filename="pdf_file.pdf"')
169	173	self.assertEqual(len(self.body), 85698)
170
	174
171	175	def test10HTTPErrors(self):
172	176	self.getPage("/load_tut_module/tut10_http_errors")
173
	177
174	178	self.getPage("/")
175	179	self.assertInBody("""<a href="toggleTracebacks">""")
176	180	self.assertInBody("""<a href="/doesNotExist">""")
177	181	self.assertInBody("""<a href="/error?code=403">""")
178	182	self.assertInBody("""<a href="/error?code=500">""")
179	183	self.assertInBody("""<a href="/messageArg">""")
180
	184
181	185	self.getPage("/traceback_setting")
182	186	setting = self.body
183	187	self.getPage("/toggleTracebacks")
184	188	self.assertStatus((302, 303))
185	189	self.getPage("/traceback_setting")
186	190	self.assertBody(str(not eval(setting)))
187
	191
188	192	self.getPage("/error?code=500")
189	193	self.assertStatus(500)
190	194	self.assertInBody("The server encountered an unexpected condition "
191	195	"which prevented it from fulfilling the request.")
192
	196
193	197	self.getPage("/error?code=403")
194	198	self.assertStatus(403)
195	199	self.assertInBody("<h2>You can't do that!</h2>")
196
	200
197	201	self.getPage("/messageArg")
198	202	self.assertStatus(500)
199	203	self.assertInBody("If you construct an HTTPError with a 'message'")
200

+30

-25

cherrypy/test/test_virtualhost.py less more

8	8
9	9	def setup_server():
10	10	class Root:
	11
11	12	def index(self):
12	13	return "Hello, world"
13	14	index.exposed = True
14
	15
15	16	def dom4(self):
16	17	return "Under construction"
17	18	dom4.exposed = True
18
	19
19	20	def method(self, value):
20	21	return "You sent %s" % value
21	22	method.exposed = True
22
	23
23	24	class VHost:
	25
24	26	def __init__(self, sitename):
25	27	self.sitename = sitename
26
	28
27	29	def index(self):
28	30	return "Welcome to %s" % self.sitename
29	31	index.exposed = True
30
	32
31	33	def vmethod(self, value):
32	34	return "You sent %s" % value
33	35	vmethod.exposed = True
34
	36
35	37	def url(self):
36	38	return cherrypy.url("nextpage")
37	39	url.exposed = True
38
	40
39	41	# Test static as a handler (section must NOT include vhost prefix)
40		static = cherrypy.tools.staticdir.handler(section='/static', dir=curdir)
41
	42	static = cherrypy.tools.staticdir.handler(
	43	section='/static', dir=curdir)
	44
42	45	root = Root()
43	46	root.mydom2 = VHost("Domain 2")
44	47	root.mydom3 = VHost("Domain 3")

47	50	'www.mydom4.com': '/dom4',
48	51	}
49	52	cherrypy.tree.mount(root, config={
50		'/': {'request.dispatch': cherrypy.dispatch.VirtualHost(**hostmap)},
	53	'/': {
	54	'request.dispatch': cherrypy.dispatch.VirtualHost(**hostmap)
	55	},
51	56	# Test static in config (section must include vhost prefix)
52		'/mydom2/static2': {'tools.staticdir.on': True,
53		'tools.staticdir.root': curdir,
54		'tools.staticdir.dir': 'static',
55		'tools.staticdir.index': 'index.html',
56		},
57		})
	57	'/mydom2/static2': {
	58	'tools.staticdir.on': True,
	59	'tools.staticdir.root': curdir,
	60	'tools.staticdir.dir': 'static',
	61	'tools.staticdir.index': 'index.html',
	62	},
	63	})
58	64	setup_server = staticmethod(setup_server)
59
	65
60	66	def testVirtualHost(self):
61	67	self.getPage("/", [('Host', 'www.mydom1.com')])
62	68	self.assertBody('Hello, world')
63	69	self.getPage("/mydom2/", [('Host', 'www.mydom1.com')])
64	70	self.assertBody('Welcome to Domain 2')
65
	71
66	72	self.getPage("/", [('Host', 'www.mydom2.com')])
67	73	self.assertBody('Welcome to Domain 2')
68	74	self.getPage("/", [('Host', 'www.mydom3.com')])
69	75	self.assertBody('Welcome to Domain 3')
70	76	self.getPage("/", [('Host', 'www.mydom4.com')])
71	77	self.assertBody('Under construction')
72
	78
73	79	# Test GET, POST, and positional params
74	80	self.getPage("/method?value=root")
75	81	self.assertBody("You sent root")

80	86	self.assertBody("You sent dom3 POST")
81	87	self.getPage("/vmethod/pos", [('Host', 'www.mydom3.com')])
82	88	self.assertBody("You sent pos")
83
	89
84	90	# Test that cherrypy.url uses the browser url, not the virtual url
85	91	self.getPage("/url", [('Host', 'www.mydom2.com')])
86	92	self.assertBody("%s://www.mydom2.com/nextpage" % self.scheme)
87
	93
88	94	def test_VHost_plus_Static(self):
89	95	# Test static as a handler
90	96	self.getPage("/static/style.css", [('Host', 'www.mydom2.com')])
91	97	self.assertStatus('200 OK')
92	98	self.assertHeader('Content-Type', 'text/css;charset=utf-8')
93
	99
94	100	# Test static in config
95	101	self.getPage("/static2/dirback.jpg", [('Host', 'www.mydom2.com')])
96	102	self.assertStatus('200 OK')
97		self.assertHeader('Content-Type', 'image/jpeg')
98
	103	self.assertHeaderIn('Content-Type', ['image/jpeg', 'image/pjpeg'])
	104
99	105	# Test static config with "index" arg
100	106	self.getPage("/static2/", [('Host', 'www.mydom2.com')])
101	107	self.assertStatus('200 OK')

103	109	# Since tools.trailing_slash is on by default, this should redirect
104	110	self.getPage("/static2", [('Host', 'www.mydom2.com')])
105	111	self.assertStatus(301)
106

+23

-20

cherrypy/test/test_wsgi_ns.py less more

5	5	class WSGI_Namespace_Test(helper.CPWebCase):
6	6
7	7	def setup_server():
8
	8
9	9	class WSGIResponse(object):
10
	10
11	11	def __init__(self, appresults):
12	12	self.appresults = appresults
13	13	self.iter = iter(appresults)
14
	14
15	15	def __iter__(self):
16	16	return self
17
	17
18	18	def next(self):
19	19	return self.iter.next()
	20
20	21	def __next__(self):
21	22	return next(self.iter)
22
	23
23	24	def close(self):
24	25	if hasattr(self.appresults, "close"):
25	26	self.appresults.close()
26
27
	27
28	28	class ChangeCase(object):
29
	29
30	30	def __init__(self, app, to=None):
31	31	self.app = app
32	32	self.to = to
33
	33
34	34	def __call__(self, environ, start_response):
35	35	res = self.app(environ, start_response)
	36
36	37	class CaseResults(WSGIResponse):
	38
37	39	def next(this):
38	40	return getattr(this.iter.next(), self.to)()
	41
39	42	def __next__(this):
40	43	return getattr(next(this.iter), self.to)()
41	44	return CaseResults(res)
42
	45
43	46	class Replacer(object):
44
	47
45	48	def __init__(self, app, map={}):
46	49	self.app = app
47	50	self.map = map
48
	51
49	52	def __call__(self, environ, start_response):
50	53	res = self.app(environ, start_response)
	54
51	55	class ReplaceResults(WSGIResponse):
	56
52	57	def next(this):
53	58	line = this.iter.next()
54	59	for k, v in self.map.iteritems():
55	60	line = line.replace(k, v)
56	61	return line
	62
57	63	def __next__(this):
58	64	line = next(this.iter)
59	65	for k, v in self.map.items():
60	66	line = line.replace(k, v)
61	67	return line
62	68	return ReplaceResults(res)
63
	69
64	70	class Root(object):
65
	71
66	72	def index(self):
67	73	return "HellO WoRlD!"
68	74	index.exposed = True
69
70
	75
71	76	root_conf = {'wsgi.pipeline': [('replace', Replacer)],
72	77	'wsgi.replace.map': {ntob('L'): ntob('X'),
73	78	ntob('l'): ntob('r')},
74	79	}
75
	80
76	81	app = cherrypy.Application(Root())
77	82	app.wsgiapp.pipeline.append(('changecase', ChangeCase))
78	83	app.wsgiapp.config['changecase'] = {'to': 'upper'}
79	84	cherrypy.tree.mount(app, config={'/': root_conf})
80	85	setup_server = staticmethod(setup_server)
81	86
82
83	87	def test_pipeline(self):
84	88	if not cherrypy.server.httpserver:
85	89	return self.skip()
86
	90
87	91	self.getPage("/")
88	92	# If body is "HEXXO WORXD!", the middleware was applied out of order.
89	93	self.assertBody("HERRO WORRD!")
90

+10

-11

cherrypy/test/test_wsgi_vhost.py less more

4	4	class WSGI_VirtualHost_Test(helper.CPWebCase):
5	5
6	6	def setup_server():
7
	7
8	8	class ClassOfRoot(object):
9
	9
10	10	def __init__(self, name):
11	11	self.name = name
12
	12
13	13	def index(self):
14	14	return "Welcome to the %s website!" % self.name
15	15	index.exposed = True
16
17
	16
18	17	default = cherrypy.Application(None)
19
	18
20	19	domains = {}
21	20	for year in range(1997, 2008):
22	21	app = cherrypy.Application(ClassOfRoot('Class of %s' % year))
23	22	domains['www.classof%s.example' % year] = app
24
	23
25	24	cherrypy.tree.graft(cherrypy._cpwsgi.VirtualHost(default, domains))
26	25	setup_server = staticmethod(setup_server)
27
	26
28	27	def test_welcome(self):
29	28	if not cherrypy.server.using_wsgi:
30	29	return self.skip("skipped (not using WSGI)... ")
31
	30
32	31	for year in range(1997, 2008):
33		self.getPage("/", headers=[('Host', 'www.classof%s.example' % year)])
	32	self.getPage(
	33	"/", headers=[('Host', 'www.classof%s.example' % year)])
34	34	self.assertBody("Welcome to the Class of %s website!" % year)
35

+42

-34

cherrypy/test/test_wsgiapps.py less more

	0	import sys
	1
0	2	from cherrypy._cpcompat import ntob
1	3	from cherrypy.test import helper
2	4

6	8	def setup_server():
7	9	import os
8	10	curdir = os.path.join(os.getcwd(), os.path.dirname(__file__))
9
	11
10	12	import cherrypy
11
	13
12	14	def test_app(environ, start_response):
13	15	status = '200 OK'
14	16	response_headers = [('Content-type', 'text/plain')]

18	20	keys = list(environ.keys())
19	21	keys.sort()
20	22	for k in keys:
21		output.append('%s: %s\n' % (k,environ[k]))
	23	output.append('%s: %s\n' % (k, environ[k]))
22	24	return [ntob(x, 'utf-8') for x in output]
23
	25
24	26	def test_empty_string_app(environ, start_response):
25	27	status = '200 OK'
26	28	response_headers = [('Content-type', 'text/plain')]
27	29	start_response(status, response_headers)
28		return [ntob('Hello'), ntob(''), ntob(' '), ntob(''), ntob('world')]
29
30
	30	return [
	31	ntob('Hello'), ntob(''), ntob(' '), ntob(''), ntob('world')
	32	]
	33
31	34	class WSGIResponse(object):
32
	35
33	36	def __init__(self, appresults):
34	37	self.appresults = appresults
35	38	self.iter = iter(appresults)
36
	39
37	40	def __iter__(self):
38	41	return self
39
40		def next(self):
41		return self.iter.next()
42		def __next__(self):
43		return next(self.iter)
44
	42
	43	if sys.version_info >= (3, 0):
	44	def __next__(self):
	45	return next(self.iter)
	46	else:
	47	def next(self):
	48	return self.iter.next()
	49
45	50	def close(self):
46	51	if hasattr(self.appresults, "close"):
47	52	self.appresults.close()
48
49
	53
50	54	class ReversingMiddleware(object):
51
	55
52	56	def __init__(self, app):
53	57	self.app = app
54
	58
55	59	def __call__(self, environ, start_response):
56	60	results = app(environ, start_response)
	61
57	62	class Reverser(WSGIResponse):
58		def next(this):
59		line = list(this.iter.next())
60		line.reverse()
61		return "".join(line)
62		def __next__(this):
63		line = list(next(this.iter))
64		line.reverse()
65		return bytes(line)
	63
	64	if sys.version_info >= (3, 0):
	65	def __next__(this):
	66	line = list(next(this.iter))
	67	line.reverse()
	68	return bytes(line)
	69	else:
	70	def next(this):
	71	line = list(this.iter.next())
	72	line.reverse()
	73	return "".join(line)
	74
66	75	return Reverser(results)
67
	76
68	77	class Root:
	78
69	79	def index(self):
70	80	return ntob("I'm a regular CherryPy page handler!")
71	81	index.exposed = True
72
73
	82
74	83	cherrypy.tree.mount(Root())
75
	84
76	85	cherrypy.tree.graft(test_app, '/hosted/app1')
77	86	cherrypy.tree.graft(test_empty_string_app, '/hosted/app3')
78
	87
79	88	# Set script_name explicitly to None to signal CP that it should
80	89	# be pulled from the WSGI environ each time.
81	90	app = cherrypy.Application(Root(), script_name=None)

88	97	def test_01_standard_app(self):
89	98	self.getPage("/")
90	99	self.assertBody("I'm a regular CherryPy page handler!")
91
	100
92	101	def test_04_pure_wsgi(self):
93	102	import cherrypy
94	103	if not cherrypy.server.using_wsgi:

114	123	self.getPage("/hosted/app3")
115	124	self.assertHeader("Content-Type", "text/plain")
116	125	self.assertInBody('Hello world')
117

+36

-29

cherrypy/test/test_xmlrpc.py less more

1	1	from cherrypy._cpcompat import py3k
2	2
3	3	try:
4		from xmlrpclib import DateTime, Fault, ProtocolError, ServerProxy, SafeTransport
	4	from xmlrpclib import DateTime, Fault, ProtocolError, ServerProxy
	5	from xmlrpclib import SafeTransport
5	6	except ImportError:
6		from xmlrpc.client import DateTime, Fault, ProtocolError, ServerProxy, SafeTransport
	7	from xmlrpc.client import DateTime, Fault, ProtocolError, ServerProxy
	8	from xmlrpc.client import SafeTransport
7	9
8	10	if py3k:
9	11	HTTPSTransport = SafeTransport

14	16	socket.ssl = True
15	17	else:
16	18	class HTTPSTransport(SafeTransport):
17		"""Subclass of SafeTransport to fix sock.recv errors (by using file)."""
18
	19
	20	"""Subclass of SafeTransport to fix sock.recv errors (by using file).
	21	"""
	22
19	23	def request(self, host, handler, request_body, verbose=0):
20	24	# issue XML-RPC request
21	25	h = self.make_connection(host)
22	26	if verbose:
23	27	h.set_debuglevel(1)
24
	28
25	29	self.send_request(h, handler, request_body)
26	30	self.send_host(h, host)
27	31	self.send_user_agent(h)
28	32	self.send_content(h, request_body)
29
	33
30	34	errcode, errmsg, headers = h.getreply()
31	35	if errcode != 200:
32	36	raise ProtocolError(host + handler, errcode, errmsg, headers)
33
	37
34	38	self.verbose = verbose
35
	39
36	40	# Here's where we differ from the superclass. It says:
37	41	# try:
38	42	# sock = h._conn.sock
39	43	# except AttributeError:
40	44	# sock = None
41	45	# return self._parse_response(h.getfile(), sock)
42
	46
43	47	return self.parse_response(h.getfile())
44	48
45	49	import cherrypy

47	51
48	52	def setup_server():
49	53	from cherrypy import _cptools
50
	54
51	55	class Root:
	56
52	57	def index(self):
53	58	return "I'm a standard index!"
54	59	index.exposed = True
55	60
	61	class XmlRpc(_cptools.XMLRPCController):
56	62
57		class XmlRpc(_cptools.XMLRPCController):
58
59	63	def foo(self):
60	64	return "Hello world!"
61	65	foo.exposed = True
62
	66
63	67	def return_single_item_list(self):
64	68	return [42]
65	69	return_single_item_list.exposed = True
66
	70
67	71	def return_string(self):
68	72	return "here is a string"
69	73	return_string.exposed = True
70
	74
71	75	def return_tuple(self):
72	76	return ('here', 'is', 1, 'tuple')
73	77	return_tuple.exposed = True
74
	78
75	79	def return_dict(self):
76	80	return dict(a=1, b=2, c=3)
77	81	return_dict.exposed = True
78
	82
79	83	def return_composite(self):
80		return dict(a=1,z=26), 'hi', ['welcome', 'friend']
	84	return dict(a=1, z=26), 'hi', ['welcome', 'friend']
81	85	return_composite.exposed = True
82	86
83	87	def return_int(self):

109	113	cherrypy.tree.mount(root, config={'/': {
110	114	'request.dispatch': cherrypy.dispatch.XMLRPCDispatcher(),
111	115	'tools.xmlrpc.allow_none': 0,
112		}})
	116	}})
113	117
114	118
115	119	from cherrypy.test import helper
116	120
	121
117	122	class XmlRpcTest(helper.CPWebCase):
118	123	setup_server = staticmethod(setup_server)
	124
119	125	def testXmlRpc(self):
120
	126
121	127	scheme = self.scheme
122	128	if scheme == "https":
123	129	url = 'https://%s:%s/xmlrpc/' % (self.interface(), self.PORT)

125	131	else:
126	132	url = 'http://%s:%s/xmlrpc/' % (self.interface(), self.PORT)
127	133	proxy = ServerProxy(url)
128
	134
129	135	# begin the tests ...
130	136	self.getPage("/xmlrpc/foo")
131	137	self.assertBody("Hello world!")
132
	138
133	139	self.assertEqual(proxy.return_single_item_list(), [42])
134	140	self.assertNotEqual(proxy.return_single_item_list(), 'one bazillion')
135	141	self.assertEqual(proxy.return_string(), "here is a string")
136		self.assertEqual(proxy.return_tuple(), list(('here', 'is', 1, 'tuple')))
	142	self.assertEqual(proxy.return_tuple(),
	143	list(('here', 'is', 1, 'tuple')))
137	144	self.assertEqual(proxy.return_dict(), {'a': 1, 'c': 3, 'b': 2})
138	145	self.assertEqual(proxy.return_composite(),
139	146	[{'a': 1, 'z': 26}, 'hi', ['welcome', 'friend']])

143	150	DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1)))
144	151	self.assertEqual(proxy.return_boolean(), True)
145	152	self.assertEqual(proxy.test_argument_passing(22), 22 * 2)
146
	153
147	154	# Test an error in the page handler (should raise an xmlrpclib.Fault)
148	155	try:
149	156	proxy.test_argument_passing({})

154	161	"for *: 'dict' and 'int'"))
155	162	else:
156	163	self.fail("Expected xmlrpclib.Fault")
157
158		# http://www.cherrypy.org/ticket/533
	164
	165	# https://bitbucket.org/cherrypy/cherrypy/issue/533
159	166	# if a method is not found, an xmlrpclib.Fault should be raised
160	167	try:
161	168	proxy.non_method()
162	169	except Exception:
163	170	x = sys.exc_info()[1]
164	171	self.assertEqual(x.__class__, Fault)
165		self.assertEqual(x.faultString, 'method "non_method" is not supported')
	172	self.assertEqual(x.faultString,
	173	'method "non_method" is not supported')
166	174	else:
167	175	self.fail("Expected xmlrpclib.Fault")
168
	176
169	177	# Test returning a Fault from the page handler.
170	178	try:
171	179	proxy.test_returning_Fault()

175	183	self.assertEqual(x.faultString, ("custom Fault response"))
176	184	else:
177	185	self.fail("Expected xmlrpclib.Fault")
178

+61

-28

cherrypy/test/webtest.py less more

15	15	be of further significance to your tests).
16	16	"""
17	17
18		import os
19	18	import pprint
20	19	import re
21	20	import socket

27	26	from unittest import *
28	27	from unittest import _TextTestResult
29	28
30		from cherrypy._cpcompat import basestring, ntob, py3k, HTTPConnection, HTTPSConnection, unicodestr
31
	29	from cherrypy._cpcompat import basestring, ntob, py3k, HTTPConnection
	30	from cherrypy._cpcompat import HTTPSConnection, unicodestr
32	31
33	32
34	33	def interface(host):

57	56
58	57
59	58	class TerseTestRunner(TextTestRunner):
	59
60	60	"""A test runner class that displays results in textual form."""
61	61
62	62	def _makeResult(self):

74	74	if failed:
75	75	self.stream.write("failures=%d" % failed)
76	76	if errored:
77		if failed: self.stream.write(", ")
	77	if failed:
	78	self.stream.write(", ")
78	79	self.stream.write("errors=%d" % errored)
79	80	self.stream.writeln(")")
80	81	return result

110	111	parts = unused_parts
111	112	break
112	113	except ImportError:
113		unused_parts.insert(0,parts_copy[-1])
	114	unused_parts.insert(0, parts_copy[-1])
114	115	del parts_copy[-1]
115	116	if not parts_copy:
116	117	raise

119	120	for part in parts:
120	121	obj = getattr(obj, part)
121	122
122		if type(obj) == types.ModuleType:
	123	if isinstance(obj, types.ModuleType):
123	124	return self.loadTestsFromModule(obj)
124	125	elif (((py3k and isinstance(obj, type))
125	126	or isinstance(obj, (type, types.ClassType)))
126	127	and issubclass(obj, TestCase)):
127	128	return self.loadTestsFromTestCase(obj)
128		elif type(obj) == types.UnboundMethodType:
	129	elif isinstance(obj, types.UnboundMethodType):
129	130	if py3k:
130	131	return obj.__self__.__class__(obj.__name__)
131	132	else:

135	136	if not isinstance(test, TestCase) and \
136	137	not isinstance(test, TestSuite):
137	138	raise ValueError("calling %s returned %s, "
138		"not a test" % (obj,test))
	139	"not a test" % (obj, test))
139	140	return test
140	141	else:
141	142	raise ValueError("do not know how to make test from: %s" % obj)

150	151	else:
151	152	# On Windows, msvcrt.getch reads a single char without output.
152	153	import msvcrt
	154
153	155	def getchar():
154	156	return msvcrt.getch()
155	157	except ImportError:
156	158	# Unix getchr
157		import tty, termios
	159	import tty
	160	import termios
	161
158	162	def getchar():
159	163	fd = sys.stdin.fileno()
160	164	old_settings = termios.tcgetattr(fd)

178	182	status = None
179	183	headers = None
180	184	body = None
181
	185
182	186	encoding = 'utf-8'
183
	187
184	188	time = None
185	189
186	190	def get_conn(self, auto_open=False):

220	224
221	225	def _get_persistent(self):
222	226	return hasattr(self.HTTP_CONN, "__class__")
	227
223	228	def _set_persistent(self, on):
224	229	self.set_persistent(on)
225	230	persistent = property(_get_persistent, _set_persistent)

231	236	or '::' (IN6ADDR_ANY), this will return the proper localhost."""
232	237	return interface(self.HOST)
233	238
234		def getPage(self, url, headers=None, method="GET", body=None, protocol=None):
235		"""Open the url with debugging support. Return status, headers, body."""
	239	def getPage(self, url, headers=None, method="GET", body=None,
	240	protocol=None):
	241	"""Open the url with debugging support. Return status, headers, body.
	242	"""
236	243	ServerError.on = False
237
	244
238	245	if isinstance(url, unicodestr):
239	246	url = url.encode('utf-8')
240	247	if isinstance(body, unicodestr):
241	248	body = body.encode('utf-8')
242
	249
243	250	self.url = url
244	251	self.time = None
245	252	start = time.time()

266	273	if not self.interactive:
267	274	raise self.failureException(msg)
268	275
269		p = " Show: [B]ody [H]eaders [S]tatus [U]RL; [I]gnore, [R]aise, or sys.e[X]it >> "
	276	p = (" Show: "
	277	"[B]ody [H]eaders [S]tatus [U]RL; "
	278	"[I]gnore, [R]aise, or sys.e[X]it >> ")
270	279	sys.stdout.write(p)
271	280	sys.stdout.flush()
272	281	while True:

350	359	msg = '%r:%r not in headers' % (key, value)
351	360	self._handlewebError(msg)
352	361
	362	def assertHeaderIn(self, key, values, msg=None):
	363	"""Fail if header indicated by key doesn't have one of the values."""
	364	lowkey = key.lower()
	365	for k, v in self.headers:
	366	if k.lower() == lowkey:
	367	matches = [value for value in values if str(value) == v]
	368	if matches:
	369	return matches
	370
	371	if msg is None:
	372	msg = '%(key)r not in %(values)r' % vars()
	373	self._handlewebError(msg)
	374
353	375	def assertHeaderItemValue(self, key, value, msg=None):
354	376	"""Fail if the header does not contain the specified value"""
355	377	actual_value = self.assertHeader(key, msg=msg)

376	398	value = value.encode(self.encoding)
377	399	if value != self.body:
378	400	if msg is None:
379		msg = 'expected body:\n%r\n\nactual body:\n%r' % (value, self.body)
	401	msg = 'expected body:\n%r\n\nactual body:\n%r' % (
	402	value, self.body)
380	403	self._handlewebError(msg)
381	404
382	405	def assertInBody(self, value, msg=None):

408	431
409	432
410	433	methods_with_bodies = ("POST", "PUT")
	434
411	435
412	436	def cleanHeaders(headers, method, body, host, port):
413	437	"""Return request headers, with required headers added (if missing)."""

435	459	found = True
436	460	break
437	461	if not found:
438		headers.append(("Content-Type", "application/x-www-form-urlencoded"))
	462	headers.append(
	463	("Content-Type", "application/x-www-form-urlencoded"))
439	464	headers.append(("Content-Length", str(len(body or ""))))
440	465
441	466	return headers

491	516	return
492	517	self.__class__.putheader(self, header, value)
493	518	import new
494		conn.putheader = new.instancemethod(putheader, conn, conn.__class__)
	519	conn.putheader = new.instancemethod(
	520	putheader, conn, conn.__class__)
495	521	conn.putrequest(method.upper(), url, skip_host=True)
496	522	elif not py3k:
497	523	conn.putrequest(method.upper(), url, skip_host=True,

499	525	else:
500	526	import http.client
501	527	# Replace the stdlib method, which only accepts ASCII url's
	528
502	529	def putrequest(self, method, url):
503		if self._HTTPConnection__response and self._HTTPConnection__response.isclosed():
	530	if (
	531	self._HTTPConnection__response and
	532	self._HTTPConnection__response.isclosed()
	533	):
504	534	self._HTTPConnection__response = None
505
	535
506	536	if self._HTTPConnection__state == http.client._CS_IDLE:
507		self._HTTPConnection__state = http.client._CS_REQ_STARTED
	537	self._HTTPConnection__state = (
	538	http.client._CS_REQ_STARTED)
508	539	else:
509	540	raise http.client.CannotSendRequest()
510
	541
511	542	self._method = method
512	543	if not url:
513	544	url = ntob('/')
514		request = ntob(' ').join((method.encode("ASCII"), url,
515		self._http_vsn_str.encode("ASCII")))
	545	request = ntob(' ').join(
	546	(method.encode("ASCII"),
	547	url,
	548	self._http_vsn_str.encode("ASCII")))
516	549	self._output(request)
517	550	import types
518	551	conn.putrequest = types.MethodType(putrequest, conn)
519
	552
520	553	conn.putrequest(method.upper(), url)
521	554
522	555	for key, value in headers:
523		conn.putheader(key, ntob(value, "Latin-1"))
	556	conn.putheader(key, value.encode("Latin-1"))
524	557	conn.endheaders()
525	558
526	559	if body is not None:

550	583	# that each response will immediately follow each request;
551	584	# for example, when handling requests via multiple threads.
552	585	ignore_all = False
	586
553	587
554	588	class ServerError(Exception):
555	589	on = False

571	605	print("")
572	606	print("".join(traceback.format_exception(*exc)))
573	607	return True
574

-1

cherrypy/tutorial/__init__.py less more

0	0
1	1	# This is used in test_config to test unrepr of "from A import B"
2		thing2 = object()⏎
	2	thing2 = object()

-168

~~cherrypy/tutorial/bonus-sqlobject.py~~ less more

0		'''
1		Bonus Tutorial: Using SQLObject
2
3		This is a silly little contacts manager application intended to
4		demonstrate how to use SQLObject from within a CherryPy2 project. It
5		also shows how to use inline Cheetah templates.
6
7		SQLObject is an Object/Relational Mapper that allows you to access
8		data stored in an RDBMS in a pythonic fashion. You create data objects
9		as Python classes and let SQLObject take care of all the nasty details.
10
11		This code depends on the latest development version (0.6+) of SQLObject.
12		You can get it from the SQLObject Subversion server. You can find all
13		necessary information at <http://www.sqlobject.org>. This code will NOT
14		work with the 0.5.x version advertised on their website!
15
16		This code also depends on a recent version of Cheetah. You can find
17		Cheetah at <http://www.cheetahtemplate.org>.
18
19		After starting this application for the first time, you will need to
20		access the /reset URI in order to create the database table and some
21		sample data. Accessing /reset again will drop and re-create the table,
22		so you may want to be careful. :-)
23
24		This application isn't supposed to be fool-proof, it's not even supposed
25		to be very GOOD. Play around with it some, browse the source code, smile.
26
27		:)
28
29		-- Hendrik Mans <hendrik@mans.de>
30		'''
31
32		import cherrypy
33		from Cheetah.Template import Template
34		from sqlobject import *
35
36		# configure your database connection here
37		__connection__ = 'mysql://root:@localhost/test'
38
39		# this is our (only) data class.
40		class Contact(SQLObject):
41		lastName = StringCol(length = 50, notNone = True)
42		firstName = StringCol(length = 50, notNone = True)
43		phone = StringCol(length = 30, notNone = True, default = '')
44		email = StringCol(length = 30, notNone = True, default = '')
45		url = StringCol(length = 100, notNone = True, default = '')
46
47
48		class ContactManager:
49		def index(self):
50		# Let's display a list of all stored contacts.
51		contacts = Contact.select()
52
53		template = Template('''
54		<h2>All Contacts</h2>
55
56		#for $contact in $contacts
57		<a href="mailto:$contact.email">$contact.lastName, $contact.firstName</a>
58		[<a href="./edit?id=$contact.id">Edit</a>]
59		[<a href="./delete?id=$contact.id">Delete</a>]
60		<br/>
61		#end for
62
63		<p>[<a href="./edit">Add new contact</a>]</p>
64		''', [locals(), globals()])
65
66		return template.respond()
67
68		index.exposed = True
69
70
71		def edit(self, id = 0):
72		# we really want id as an integer. Since GET/POST parameters
73		# are always passed as strings, let's convert it.
74		id = int(id)
75
76		if id > 0:
77		# if an id is specified, we're editing an existing contact.
78		contact = Contact.get(id)
79		title = "Edit Contact"
80		else:
81		# if no id is specified, we're entering a new contact.
82		contact = None
83		title = "New Contact"
84
85
86		# In the following template code, please note that we use
87		# Cheetah's $getVar() construct for the form values. We have
88		# to do this because contact may be set to None (see above).
89		template = Template('''
90		<h2>$title</h2>
91
92		<form action="./store" method="POST">
93		<input type="hidden" name="id" value="$id" />
94		Last Name: <input name="lastName" value="$getVar('contact.lastName', '')" /><br/>
95		First Name: <input name="firstName" value="$getVar('contact.firstName', '')" /><br/>
96		Phone: <input name="phone" value="$getVar('contact.phone', '')" /><br/>
97		Email: <input name="email" value="$getVar('contact.email', '')" /><br/>
98		URL: <input name="url" value="$getVar('contact.url', '')" /><br/>
99		<input type="submit" value="Store" />
100		</form>
101		''', [locals(), globals()])
102
103		return template.respond()
104
105		edit.exposed = True
106
107
108		def delete(self, id):
109		# Delete the specified contact
110		contact = Contact.get(int(id))
111		contact.destroySelf()
112		return 'Deleted. <a href="./">Return to Index</a>'
113
114		delete.exposed = True
115
116
117		def store(self, lastName, firstName, phone, email, url, id = None):
118		if id and int(id) > 0:
119		# If an id was specified, update an existing contact.
120		contact = Contact.get(int(id))
121
122		# We could set one field after another, but that would
123		# cause multiple UPDATE clauses. So we'll just do it all
124		# in a single pass through the set() method.
125		contact.set(
126		lastName = lastName,
127		firstName = firstName,
128		phone = phone,
129		email = email,
130		url = url)
131		else:
132		# Otherwise, add a new contact.
133		contact = Contact(
134		lastName = lastName,
135		firstName = firstName,
136		phone = phone,
137		email = email,
138		url = url)
139
140		return 'Stored. <a href="./">Return to Index</a>'
141
142		store.exposed = True
143
144
145		def reset(self):
146		# Drop existing table
147		Contact.dropTable(True)
148
149		# Create new table
150		Contact.createTable()
151
152		# Create some sample data
153		Contact(
154		firstName = 'Hendrik',
155		lastName = 'Mans',
156		email = 'hendrik@mans.de',
157		phone = '++49 89 12345678',
158		url = 'http://www.mornography.de')
159
160		return "reset completed!"
161
162		reset.exposed = True
163
164
165		print("If you're running this application for the first time, please go to http://localhost:8080/reset once in order to create the database!")
166
167		cherrypy.quickstart(ContactManager())

-0

cherrypy/tutorial/tut01_helloworld.py less more

6	6	# Import CherryPy global namespace
7	7	import cherrypy
8	8
	9
9	10	class HelloWorld:
	11
10	12	""" Sample request handler class. """
11	13
12	14	def index(self):

-5

cherrypy/tutorial/tut02_expose_methods.py less more

6	6
7	7	import cherrypy
8	8
	9
9	10	class HelloWorld:
10
	11
11	12	def index(self):
12	13	# Let's link to another method here.
13		return 'We have an <a href="showMessage">important message</a> for you!'
	14	return 'We have an <a href="show_msg">important message</a> for you!'
14	15	index.exposed = True
15
16		def showMessage(self):
	16
	17	def show_msg(self):
17	18	# Here's the important message!
18	19	return "Hello world!"
19		showMessage.exposed = True
	20	show_msg.exposed = True
20	21
21	22	import os.path
22	23	tutconf = os.path.join(os.path.dirname(__file__), 'tutorial.conf')

-3

cherrypy/tutorial/tut03_get_and_post.py less more

17	17	<input type="submit" />
18	18	</form>'''
19	19	index.exposed = True
20
21		def greetUser(self, name = None):
	20
	21	def greetUser(self, name=None):
22	22	# CherryPy passes all GET and POST variables as method parameters.
23	23	# It doesn't make a difference where the variables come from, how
24	24	# large their contents are, and so on.

26	26	# You can define default parameter values as usual. In this
27	27	# example, the "name" parameter defaults to None so we can check
28	28	# if a name was actually specified.
29
	29
30	30	if name:
31	31	# Greet the user!
32	32	return "Hey %s, what's up?" % name

+18

-11

cherrypy/tutorial/tut04_complex_site.py less more

8	8
9	9
10	10	class HomePage:
	11
11	12	def index(self):
12	13	return '''
13	14	<p>Hi, this is the home page! Check out the other
14	15	fun stuff on this site:</p>
15
	16
16	17	<ul>
17	18	<li><a href="/joke/">A silly joke</a></li>
18	19	<li><a href="/links/">Useful links</a></li>

21	22
22	23
23	24	class JokePage:
	25
24	26	def index(self):
25	27	return '''
26	28	<p>"In Python, how do you create a string of random

30	32
31	33
32	34	class LinksPage:
	35
33	36	def __init__(self):
34	37	# Request handler objects can create their own nested request
35	38	# handler objects. Simply create them inside their __init__
36	39	# methods!
37	40	self.extra = ExtraLinksPage()
38
	41
39	42	def index(self):
40	43	# Note the way we link to the extra links page (and back).
41	44	# As you can see, this object doesn't really care about its

43	46	# links exclusively.
44	47	return '''
45	48	<p>Here are some useful links:</p>
46
	49
47	50	<ul>
48		<li><a href="http://www.cherrypy.org">The CherryPy Homepage</a></li>
49		<li><a href="http://www.python.org">The Python Homepage</a></li>
	51	<li>
	52	<a href="http://www.cherrypy.org">The CherryPy Homepage</a>
	53	</li>
	54	<li>
	55	<a href="http://www.python.org">The Python Homepage</a>
	56	</li>
50	57	</ul>
51
	58
52	59	<p>You can check out some extra useful
53	60	links <a href="./extra/">here</a>.</p>
54
	61
55	62	<p>[<a href="../">Return</a>]</p>
56	63	'''
57	64	index.exposed = True
58	65
59	66
60	67	class ExtraLinksPage:
	68
61	69	def index(self):
62	70	# Note the relative link back to the Links page!
63	71	return '''
64	72	<p>Here are some extra useful links:</p>
65
	73
66	74	<ul>
67	75	<li><a href="http://del.icio.us">del.icio.us</a></li>
68		<li><a href="http://www.mornography.de">Hendrik's weblog</a></li>
	76	<li><a href="http://www.cherrypy.org">CherryPy</a></li>
69	77	</ul>
70
	78
71	79	<p>[<a href="../">Return to links page</a>]</p>'''
72	80	index.exposed = True
73	81

94	102	else:
95	103	# This branch is for the test suite; you can ignore it.
96	104	cherrypy.tree.mount(root, config=tutconf)
97

-7

cherrypy/tutorial/tut05_derived_objects.py less more

12	12	class Page:
13	13	# Store the page title in a class attribute
14	14	title = 'Untitled Page'
15
	15
16	16	def header(self):
17	17	return '''
18	18	<html>

22	22	<body>
23	23	<h2>%s</h2>
24	24	''' % (self.title, self.title)
25
	25
26	26	def footer(self):
27	27	return '''
28	28	</body>
29	29	</html>
30	30	'''
31
	31
32	32	# Note that header and footer don't get their exposed attributes
33	33	# set to True. This isn't necessary since the user isn't supposed
34	34	# to call header or footer directly; instead, we'll call them from

39	39	class HomePage(Page):
40	40	# Different title for this page
41	41	title = 'Tutorial 5'
42
	42
43	43	def __init__(self):
44	44	# create a subpage
45	45	self.another = AnotherPage()
46
	46
47	47	def index(self):
48	48	# Note that we call the header and footer methods inherited
49	49	# from the Page class!

58	58
59	59	class AnotherPage(Page):
60	60	title = 'Another Page'
61
	61
62	62	def index(self):
63	63	return self.header() + '''
64	64	<p>

79	79	else:
80	80	# This branch is for the test suite; you can ignore it.
81	81	cherrypy.tree.mount(HomePage(), config=tutconf)
82

-4

cherrypy/tutorial/tut06_default_method.py less more

19	19
20	20
21	21	class UsersPage:
22
	22
23	23	def index(self):
24	24	# Since this is just a stupid little example, we'll simply
25	25	# display a list of links to random, made-up users. In a real

30	30	<a href="./lorenzo">Lorenzo Lamas</a><br/>
31	31	'''
32	32	index.exposed = True
33
	33
34	34	def default(self, user):
35	35	# Here we react depending on the virtualPath -- the part of the
36	36	# path that could not be mapped to an object method. In a real

44	44	out = "Lorenzo Lamas, famous actor and singer!"
45	45	else:
46	46	out = "Unknown user. :-("
47
	47
48	48	return '%s (<a href="./">back</a>)' % out
49	49	default.exposed = True
50	50

60	60	else:
61	61	# This branch is for the test suite; you can ignore it.
62	62	cherrypy.tree.mount(UsersPage(), config=tutconf)
63

-5

cherrypy/tutorial/tut07_sessions.py less more

11	11
12	12
13	13	class HitCounter:
14
	14
15	15	_cp_config = {'tools.sessions.on': True}
16
	16
17	17	def index(self):
18	18	# Increase the silly hit counter
19	19	count = cherrypy.session.get('count', 0) + 1
20
	20
21	21	# Store the new value in the session dictionary
22	22	cherrypy.session['count'] = count
23
	23
24	24	# And display a silly hit count message!
25	25	return '''
26	26	During your current session, you've viewed this

40	40	else:
41	41	# This branch is for the test suite; you can ignore it.
42	42	cherrypy.tree.mount(HitCounter(), config=tutconf)
43

-7

cherrypy/tutorial/tut08_generators_and_yield.py less more

10	10
11	11
12	12	class GeneratorDemo:
13
	13
14	14	def header(self):
15	15	return "<html><body><h2>Generators rule!</h2>"
16
	16
17	17	def footer(self):
18	18	return "</body></html>"
19
	19
20	20	def index(self):
21	21	# Let's make up a list of users for presentation purposes
22	22	users = ['Remi', 'Carlos', 'Hendrik', 'Lorenzo Lamas']
23
	23
24	24	# Every yield line adds one part to the total result body.
25	25	yield self.header()
26	26	yield "<h3>List of users:</h3>"
27
	27
28	28	for user in users:
29	29	yield "%s<br/>" % user
30
	30
31	31	yield self.footer()
32	32	index.exposed = True
33	33

43	43	else:
44	44	# This branch is for the test suite; you can ignore it.
45	45	cherrypy.tree.mount(GeneratorDemo(), config=tutconf)
46

-5

cherrypy/tutorial/tut09_files.py less more

48	48
49	49
50	50	class FileDemo(object):
51
	51
52	52	def index(self):
53	53	return """
54	54	<html><body>

62	62	</body></html>
63	63	"""
64	64	index.exposed = True
65
	65
66	66	def upload(self, myFile):
67	67	out = """<html>
68	68	<body>

71	71	myFile mime-type: %s
72	72	</body>
73	73	</html>"""
74
	74
75	75	# Although this just counts the file length, it demonstrates
76	76	# how to read large files in chunks instead of all at once.
77	77	# CherryPy reads the uploaded file into a temporary file;

82	82	if not data:
83	83	break
84	84	size += len(data)
85
	85
86	86	return out % (size, myFile.filename, myFile.content_type)
87	87	upload.exposed = True
88
	88
89	89	def download(self):
90	90	path = os.path.join(absDir, "pdf_file.pdf")
91	91	return static.serve_file(path, "application/x-download",

+16

-11

cherrypy/tutorial/tut10_http_errors.py less more

15	15
16	16
17	17	class HTTPErrorDemo(object):
18
	18
19	19	# Set a custom response for 403 errors.
20		_cp_config = {'error_page.403' : os.path.join(curpath, "custom_error.html")}
21
	20	_cp_config = {'error_page.403':
	21	os.path.join(curpath, "custom_error.html")}
	22
22	23	def index(self):
23	24	# display some links that will result in errors
24	25	tracebacks = cherrypy.request.show_tracebacks

26	27	trace = 'off'
27	28	else:
28	29	trace = 'on'
29
	30
30	31	return """
31	32	<html><body>
32	33	<p>Toggle tracebacks <a href="toggleTracebacks">%s</a></p>
33	34	<p><a href="/doesNotExist">Click me; I'm a broken link!</a></p>
34		<p><a href="/error?code=403">Use a custom error page from a file.</a></p>
	35	<p>
	36	<a href="/error?code=403">
	37	Use a custom error page from a file.
	38	</a>
	39	</p>
35	40	<p>These errors are explicitly raised by the application:</p>
36	41	<ul>
37	42	<li><a href="/error?code=400">400</a></li>

44	49	</body></html>
45	50	""" % trace
46	51	index.exposed = True
47
	52
48	53	def toggleTracebacks(self):
49		# simple function to toggle tracebacks on and off
	54	# simple function to toggle tracebacks on and off
50	55	tracebacks = cherrypy.request.show_tracebacks
51	56	cherrypy.config.update({'request.show_tracebacks': not tracebacks})
52
	57
53	58	# redirect back to the index
54	59	raise cherrypy.HTTPRedirect('/')
55	60	toggleTracebacks.exposed = True
56
	61
57	62	def error(self, code):
58	63	# raise an error based on the get query
59		raise cherrypy.HTTPError(status = code)
	64	raise cherrypy.HTTPError(status=code)
60	65	error.exposed = True
61
	66
62	67	def messageArg(self):
63	68	message = ("If you construct an HTTPError with a 'message' "
64	69	"argument, it wil be placed on the error page "

+14

-13

cherrypy/wsgiserver/ssl_builtin.py less more

24	24
25	25
26	26	class BuiltinSSLAdapter(wsgiserver.SSLAdapter):
	27
27	28	"""A wrapper for integrating Python's builtin ssl module with CherryPy."""
28
	29
29	30	certificate = None
30	31	"""The filename of the server SSL certificate."""
31
	32
32	33	private_key = None
33	34	"""The filename of the server's private key file."""
34
	35
35	36	def __init__(self, certificate, private_key, certificate_chain=None):
36	37	if ssl is None:
37	38	raise ImportError("You must install the ssl module to use HTTPS.")
38	39	self.certificate = certificate
39	40	self.private_key = private_key
40	41	self.certificate_chain = certificate_chain
41
	42
42	43	def bind(self, sock):
43	44	"""Wrap and return the given socket."""
44	45	return sock
45
	46
46	47	def wrap(self, sock):
47	48	"""Wrap and return the given socket, plus WSGI environ entries."""
48	49	try:
49	50	s = ssl.wrap_socket(sock, do_handshake_on_connect=True,
50		server_side=True, certfile=self.certificate,
51		keyfile=self.private_key, ssl_version=ssl.PROTOCOL_SSLv23)
	51	server_side=True, certfile=self.certificate,
	52	keyfile=self.private_key,
	53	ssl_version=ssl.PROTOCOL_SSLv23)
52	54	except ssl.SSLError:
53	55	e = sys.exc_info()[1]
54	56	if e.errno == ssl.SSL_ERROR_EOF:

66	68	return None, {}
67	69	raise
68	70	return s, self.get_environ(s)
69
	71
70	72	# TODO: fill this out more with mod ssl env
71	73	def get_environ(self, sock):
72	74	"""Create WSGI environ entries to be merged into each request."""

76	78	"HTTPS": "on",
77	79	'SSL_PROTOCOL': cipher[1],
78	80	'SSL_CIPHER': cipher[0]
79		## SSL_VERSION_INTERFACE string The mod_ssl program version
80		## SSL_VERSION_LIBRARY string The OpenSSL program version
81		}
	81	# SSL_VERSION_INTERFACE string The mod_ssl program version
	82	# SSL_VERSION_LIBRARY string The OpenSSL program version
	83	}
82	84	return ssl_environ
83
	85
84	86	if sys.version_info >= (3, 0):
85	87	def makefile(self, sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE):
86	88	return wsgiserver.CP_makefile(sock, mode, bufsize)
87	89	else:
88	90	def makefile(self, sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE):
89	91	return wsgiserver.CP_fileobject(sock, mode, bufsize)
90

+47

-50

cherrypy/wsgiserver/ssl_pyopenssl.py less more

0	0	"""A library for integrating pyOpenSSL with CherryPy.
1	1
2	2	The OpenSSL module must be importable for SSL functionality.
3		You can obtain it from http://pyopenssl.sourceforge.net/
	3	You can obtain it from `here <https://launchpad.net/pyopenssl>`_.
4	4
5	5	To use this module, set CherryPyWSGIServer.ssl_adapter to an instance of
6	6	SSLAdapter. There are two ways to use SSL:

43	43
44	44
45	45	class SSL_fileobject(wsgiserver.CP_fileobject):
	46
46	47	"""SSL file object attached to a socket object."""
47
	48
48	49	ssl_timeout = 3
49	50	ssl_retry = .01
50
	51
51	52	def _safe_call(self, is_reader, call, args, *kwargs):
52	53	"""Wrap the given call with SSL error-trapping.
53
	54
54	55	is_reader: if False EOF errors will be raised. If True, EOF errors
55	56	will return "" (to emulate normal sockets).
56	57	"""

69	70	except SSL.SysCallError, e:
70	71	if is_reader and e.args == (-1, 'Unexpected EOF'):
71	72	return ""
72
	73
73	74	errnum = e.args[0]
74	75	if is_reader and errnum in wsgiserver.socket_errors_to_ignore:
75	76	return ""

77	78	except SSL.Error, e:
78	79	if is_reader and e.args == (-1, 'Unexpected EOF'):
79	80	return ""
80
	81
81	82	thirdarg = None
82	83	try:
83	84	thirdarg = e.args[0][0][2]
84	85	except IndexError:
85	86	pass
86
	87
87	88	if thirdarg == 'http request':
88	89	# The client is talking HTTP to an HTTPS server.
89	90	raise wsgiserver.NoSSLError()
90
	91
91	92	raise wsgiserver.FatalSSLAlert(*e.args)
92	93	except:
93	94	raise
94
	95
95	96	if time.time() - start > self.ssl_timeout:
96	97	raise socket.timeout("timed out")
97
98		def recv(self, args, *kwargs):
99		buf = []
100		r = super(SSL_fileobject, self).recv
101		while True:
102		data = self._safe_call(True, r, args, *kwargs)
103		buf.append(data)
104		p = self._sock.pending()
105		if not p:
106		return "".join(buf)
107
	98
	99	def recv(self, size):
	100	return self._safe_call(True, super(SSL_fileobject, self).recv, size)
	101
108	102	def sendall(self, args, *kwargs):
109	103	return self._safe_call(False, super(SSL_fileobject, self).sendall,
110	104	args, *kwargs)

115	109
116	110
117	111	class SSLConnection:
	112
118	113	"""A thread-safe wrapper for an SSL.Connection.
119
	114
120	115	``args``: the arguments to create the wrapped ``SSL.Connection(args)``.
121	116	"""
122
	117
123	118	def __init__(self, *args):
124	119	self._ssl_conn = SSL.Connection(*args)
125	120	self._lock = threading.RLock()
126
	121
127	122	for f in ('get_context', 'pending', 'send', 'write', 'recv', 'read',
128	123	'renegotiate', 'bind', 'listen', 'connect', 'accept',
129	124	'setblocking', 'fileno', 'close', 'get_cipher_list',

139	134	finally:
140	135	self._lock.release()
141	136	""" % (f, f))
142
	137
143	138	def shutdown(self, *args):
144	139	self._lock.acquire()
145	140	try:

150	145
151	146
152	147	class pyOpenSSLAdapter(wsgiserver.SSLAdapter):
	148
153	149	"""A wrapper for integrating pyOpenSSL with CherryPy."""
154
	150
155	151	context = None
156	152	"""An instance of SSL.Context."""
157
	153
158	154	certificate = None
159	155	"""The filename of the server SSL certificate."""
160
	156
161	157	private_key = None
162	158	"""The filename of the server's private key file."""
163
	159
164	160	certificate_chain = None
165	161	"""Optional. The filename of CA's intermediate certificate bundle.
166
	162
167	163	This is needed for cheaper "chained root" SSL certificates, and should be
168	164	left as None if not required."""
169
	165
170	166	def __init__(self, certificate, private_key, certificate_chain=None):
171	167	if SSL is None:
172	168	raise ImportError("You must install pyOpenSSL to use HTTPS.")
173
	169
174	170	self.context = None
175	171	self.certificate = certificate
176	172	self.private_key = private_key
177	173	self.certificate_chain = certificate_chain
178	174	self._environ = None
179
	175
180	176	def bind(self, sock):
181	177	"""Wrap and return the given socket."""
182	178	if self.context is None:

184	180	conn = SSLConnection(self.context, sock)
185	181	self._environ = self.get_environ()
186	182	return conn
187
	183
188	184	def wrap(self, sock):
189	185	"""Wrap and return the given socket, plus WSGI environ entries."""
190	186	return sock, self._environ.copy()
191
	187
192	188	def get_context(self):
193	189	"""Return an SSL.Context from self attributes."""
194	190	# See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/442473

198	194	c.load_verify_locations(self.certificate_chain)
199	195	c.use_certificate_file(self.certificate)
200	196	return c
201
	197
202	198	def get_environ(self):
203	199	"""Return WSGI environ entries to be merged into each request."""
204	200	ssl_environ = {
205	201	"HTTPS": "on",
206	202	# pyOpenSSL doesn't provide access to any of these AFAICT
207		## 'SSL_PROTOCOL': 'SSLv2',
208		## SSL_CIPHER string The cipher specification name
209		## SSL_VERSION_INTERFACE string The mod_ssl program version
210		## SSL_VERSION_LIBRARY string The OpenSSL program version
211		}
212
	203	# 'SSL_PROTOCOL': 'SSLv2',
	204	# SSL_CIPHER string The cipher specification name
	205	# SSL_VERSION_INTERFACE string The mod_ssl program version
	206	# SSL_VERSION_LIBRARY string The OpenSSL program version
	207	}
	208
213	209	if self.certificate:
214	210	# Server certificate attributes
215	211	cert = open(self.certificate, 'rb').read()

217	213	ssl_environ.update({
218	214	'SSL_SERVER_M_VERSION': cert.get_version(),
219	215	'SSL_SERVER_M_SERIAL': cert.get_serial_number(),
220		## 'SSL_SERVER_V_START': Validity of server's certificate (start time),
221		## 'SSL_SERVER_V_END': Validity of server's certificate (end time),
222		})
223
	216	# 'SSL_SERVER_V_START':
	217	# Validity of server's certificate (start time),
	218	# 'SSL_SERVER_V_END':
	219	# Validity of server's certificate (end time),
	220	})
	221
224	222	for prefix, dn in [("I", cert.get_issuer()),
225	223	("S", cert.get_subject())]:
226	224	# X509Name objects don't seem to have a way to get the
227	225	# complete DN string. Use str() and slice it instead,
228	226	# because str(dn) == "<X509Name object '/C=US/ST=...'>"
229	227	dnstr = str(dn)[18:-2]
230
	228
231	229	wsgikey = 'SSL_SERVER_%s_DN' % prefix
232	230	ssl_environ[wsgikey] = dnstr
233
	231
234	232	# The DN should be of the form: /k1=v1/k2=v2, but we must allow
235	233	# for any value to contain slashes itself (in a URL).
236	234	while dnstr:

241	239	if key and value:
242	240	wsgikey = 'SSL_SERVER_%s_DN_%s' % (prefix, key)
243	241	ssl_environ[wsgikey] = value
244
	242
245	243	return ssl_environ
246
	244
247	245	def makefile(self, sock, mode='r', bufsize=-1):
248	246	if SSL and isinstance(sock, SSL.ConnectionType):
249	247	timeout = sock.gettimeout()

252	250	return f
253	251	else:
254	252	return wsgiserver.CP_fileobject(sock, mode, bufsize)
255

+531

-382

cherrypy/wsgiserver/wsgiserver2.py less more

3	3	(without using CherryPy's application machinery)::
4	4
5	5	from cherrypy import wsgiserver
6
	6
7	7	def my_crazy_app(environ, start_response):
8	8	status = '200 OK'
9	9	response_headers = [('Content-type','text/plain')]
10	10	start_response(status, response_headers)
11	11	return ['Hello world!']
12
	12
13	13	server = wsgiserver.CherryPyWSGIServer(
14	14	('0.0.0.0', 8070), my_crazy_app,
15	15	server_name='www.cherrypy.example')
16	16	server.start()
17
18		The CherryPy WSGI server can serve as many WSGI applications
	17
	18	The CherryPy WSGI server can serve as many WSGI applications
19	19	as you want in one instance by using a WSGIPathInfoDispatcher::
20
	20
21	21	d = WSGIPathInfoDispatcher({'/': my_crazy_app, '/blog': my_blog_app})
22	22	server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', 80), d)
23
	23
24	24	Want SSL support? Just set server.ssl_adapter to an SSLAdapter instance.
25	25
26	26	This won't call the CherryPy engine (application side) at all, only the

85	85	import rfc822
86	86	import socket
87	87	import sys
88		if 'win' in sys.platform and not hasattr(socket, 'IPPROTO_IPV6'):
89		socket.IPPROTO_IPV6 = 41
	88	if 'win' in sys.platform and hasattr(socket, "AF_INET6"):
	89	if not hasattr(socket, 'IPPROTO_IPV6'):
	90	socket.IPPROTO_IPV6 = 41
	91	if not hasattr(socket, 'IPV6_V6ONLY'):
	92	socket.IPV6_V6ONLY = 27
90	93	try:
91	94	import cStringIO as StringIO
92	95	except ImportError:
93	96	import StringIO
94	97	DEFAULT_BUFFER_SIZE = -1
95	98
96		_fileobject_uses_str_type = isinstance(socket._fileobject(None)._rbuf, basestring)
	99
	100	class FauxSocket(object):
	101
	102	"""Faux socket with the minimal interface required by pypy"""
	103
	104	def _reuse(self):
	105	pass
	106
	107	_fileobject_uses_str_type = isinstance(
	108	socket._fileobject(FauxSocket())._rbuf, basestring)
	109	del FauxSocket # this class is not longer required for anything.
97	110
98	111	import threading
99	112	import time
100	113	import traceback
	114
	115
101	116	def format_exc(limit=None):
102	117	"""Like print_exc() but return a string. Backport for Python 2.3."""
103	118	try:

106	121	finally:
107	122	etype = value = tb = None
108	123
	124	import operator
109	125
110	126	from urllib import unquote
111		from urlparse import urlparse
112	127	import warnings
113	128
114	129	if sys.version_info >= (3, 0):
115	130	bytestr = bytes
116	131	unicodestr = str
117	132	basestring = (bytes, str)
	133
118	134	def ntob(n, encoding='ISO-8859-1'):
119		"""Return the given native string as a byte string in the given encoding."""
	135	"""Return the given native string as a byte string in the given
	136	encoding.
	137	"""
120	138	# In Python 3, the native string type is unicode
121	139	return n.encode(encoding)
122	140	else:
123	141	bytestr = str
124	142	unicodestr = unicode
125	143	basestring = basestring
	144
126	145	def ntob(n, encoding='ISO-8859-1'):
127		"""Return the given native string as a byte string in the given encoding."""
	146	"""Return the given native string as a byte string in the given
	147	encoding.
	148	"""
128	149	# In Python 2, the native string type is bytes. Assume it's already
129	150	# in the given encoding, which for ISO-8859-1 is almost always what
130	151	# was intended.

145	166
146	167	import errno
147	168
	169
148	170	def plat_specific_errors(*errnames):
149	171	"""Return error numbers for all errors in errnames on this platform.
150
	172
151	173	The 'errno' module contains different global constants depending on
152	174	the specific platform (OS). This function will return the list of
153	175	numeric values for a given list of potential names.

169	191	"ECONNABORTED", "WSAECONNABORTED",
170	192	"ENETRESET", "WSAENETRESET",
171	193	"EHOSTDOWN", "EHOSTUNREACH",
172		)
	194	)
173	195	socket_errors_to_ignore.append("timed out")
174	196	socket_errors_to_ignore.append("The read operation timed out")
175	197
176	198	socket_errors_nonblocking = plat_specific_errors(
177	199	'EAGAIN', 'EWOULDBLOCK', 'WSAEWOULDBLOCK')
178	200
179		comma_separated_headers = [ntob(h) for h in
	201	comma_separated_headers = [
	202	ntob(h) for h in
180	203	['Accept', 'Accept-Charset', 'Accept-Encoding',
181	204	'Accept-Language', 'Accept-Ranges', 'Allow', 'Cache-Control',
182	205	'Connection', 'Content-Encoding', 'Content-Language', 'Expect',
183	206	'If-Match', 'If-None-Match', 'Pragma', 'Proxy-Authenticate', 'TE',
184	207	'Trailer', 'Transfer-Encoding', 'Upgrade', 'Vary', 'Via', 'Warning',
185		'WWW-Authenticate']]
	208	'WWW-Authenticate']
	209	]
186	210
187	211
188	212	import logging
189		if not hasattr(logging, 'statistics'): logging.statistics = {}
	213	if not hasattr(logging, 'statistics'):
	214	logging.statistics = {}
190	215
191	216
192	217	def read_headers(rfile, hdict=None):
193	218	"""Read headers from the given stream into the given header dict.
194
	219
195	220	If hdict is None, a new header dict is created. Returns the populated
196	221	header dict.
197
	222
198	223	Headers which are repeated are folded together using a comma if their
199	224	specification so dictates.
200
	225
201	226	This function raises ValueError when the read bytes violate the HTTP spec.
202	227	You should probably return "400 Bad Request" if this happens.
203	228	"""
204	229	if hdict is None:
205	230	hdict = {}
206
	231
207	232	while True:
208	233	line = rfile.readline()
209	234	if not line:
210	235	# No more data--illegal end of headers
211	236	raise ValueError("Illegal end of headers.")
212
	237
213	238	if line == CRLF:
214	239	# Normal end of headers
215	240	break
216	241	if not line.endswith(CRLF):
217	242	raise ValueError("HTTP requires CRLF terminators")
218
	243
219	244	if line[0] in (SPACE, TAB):
220	245	# It's a continuation line.
221	246	v = line.strip()

228	253	k = k.strip().title()
229	254	v = v.strip()
230	255	hname = k
231
	256
232	257	if k in comma_separated_headers:
233	258	existing = hdict.get(hname)
234	259	if existing:
235	260	v = ", ".join((existing, v))
236	261	hdict[hname] = v
237
	262
238	263	return hdict
239	264
240	265
241	266	class MaxSizeExceeded(Exception):
242	267	pass
243	268
	269
244	270	class SizeCheckWrapper(object):
	271
245	272	"""Wraps a file-like object, raising MaxSizeExceeded if too large."""
246
	273
247	274	def __init__(self, rfile, maxlen):
248	275	self.rfile = rfile
249	276	self.maxlen = maxlen
250	277	self.bytes_read = 0
251
	278
252	279	def _check_length(self):
253	280	if self.maxlen and self.bytes_read > self.maxlen:
254	281	raise MaxSizeExceeded()
255
	282
256	283	def read(self, size=None):
257	284	data = self.rfile.read(size)
258	285	self.bytes_read += len(data)
259	286	self._check_length()
260	287	return data
261
	288
262	289	def readline(self, size=None):
263	290	if size is not None:
264	291	data = self.rfile.readline(size)
265	292	self.bytes_read += len(data)
266	293	self._check_length()
267	294	return data
268
	295
269	296	# User didn't specify a size ...
270	297	# We read the line in chunks to make sure it's not a 100MB line !
271	298	res = []

274	301	self.bytes_read += len(data)
275	302	self._check_length()
276	303	res.append(data)
277		# See http://www.cherrypy.org/ticket/421
278		if len(data) < 256 or data[-1:] == "\n":
	304	# See https://bitbucket.org/cherrypy/cherrypy/issue/421
	305	if len(data) < 256 or data[-1:] == LF:
279	306	return EMPTY.join(res)
280
	307
281	308	def readlines(self, sizehint=0):
282	309	# Shamelessly stolen from StringIO
283	310	total = 0

290	317	break
291	318	line = self.readline()
292	319	return lines
293
	320
294	321	def close(self):
295	322	self.rfile.close()
296
	323
297	324	def __iter__(self):
298	325	return self
299
	326
300	327	def __next__(self):
301	328	data = next(self.rfile)
302	329	self.bytes_read += len(data)
303	330	self._check_length()
304	331	return data
305
	332
306	333	def next(self):
307	334	data = self.rfile.next()
308	335	self.bytes_read += len(data)

311	338
312	339
313	340	class KnownLengthRFile(object):
	341
314	342	"""Wraps a file-like object, returning an empty string when exhausted."""
315
	343
316	344	def __init__(self, rfile, content_length):
317	345	self.rfile = rfile
318	346	self.remaining = content_length
319
	347
320	348	def read(self, size=None):
321	349	if self.remaining == 0:
322	350	return ''

324	352	size = self.remaining
325	353	else:
326	354	size = min(size, self.remaining)
327
	355
328	356	data = self.rfile.read(size)
329	357	self.remaining -= len(data)
330	358	return data
331
	359
332	360	def readline(self, size=None):
333	361	if self.remaining == 0:
334	362	return ''

336	364	size = self.remaining
337	365	else:
338	366	size = min(size, self.remaining)
339
	367
340	368	data = self.rfile.readline(size)
341	369	self.remaining -= len(data)
342	370	return data
343
	371
344	372	def readlines(self, sizehint=0):
345	373	# Shamelessly stolen from StringIO
346	374	total = 0

353	381	break
354	382	line = self.readline(sizehint)
355	383	return lines
356
	384
357	385	def close(self):
358	386	self.rfile.close()
359
	387
360	388	def __iter__(self):
361	389	return self
362
	390
363	391	def __next__(self):
364	392	data = next(self.rfile)
365	393	self.remaining -= len(data)

367	395
368	396
369	397	class ChunkedRFile(object):
	398
370	399	"""Wraps a file-like object, returning an empty string when exhausted.
371
	400
372	401	This class is intended to provide a conforming wsgi.input value for
373	402	request entities that have been encoded with the 'chunked' transfer
374	403	encoding.
375	404	"""
376
	405
377	406	def __init__(self, rfile, maxlen, bufsize=8192):
378	407	self.rfile = rfile
379	408	self.maxlen = maxlen

381	410	self.buffer = EMPTY
382	411	self.bufsize = bufsize
383	412	self.closed = False
384
	413
385	414	def _fetch(self):
386	415	if self.closed:
387	416	return
388
	417
389	418	line = self.rfile.readline()
390	419	self.bytes_read += len(line)
391
	420
392	421	if self.maxlen and self.bytes_read > self.maxlen:
393	422	raise MaxSizeExceeded("Request Entity Too Large", self.maxlen)
394
	423
395	424	line = line.strip().split(SEMICOLON, 1)
396
	425
397	426	try:
398	427	chunk_size = line.pop(0)
399	428	chunk_size = int(chunk_size, 16)
400	429	except ValueError:
401	430	raise ValueError("Bad chunked transfer size: " + repr(chunk_size))
402
	431
403	432	if chunk_size <= 0:
404	433	self.closed = True
405	434	return
406
	435
407	436	## if line: chunk_extension = line[0]
408
	437
409	438	if self.maxlen and self.bytes_read + chunk_size > self.maxlen:
410	439	raise IOError("Request Entity Too Large")
411
	440
412	441	chunk = self.rfile.read(chunk_size)
413	442	self.bytes_read += len(chunk)
414	443	self.buffer += chunk
415
	444
416	445	crlf = self.rfile.read(2)
417	446	if crlf != CRLF:
418	447	raise ValueError(
419		"Bad chunked transfer coding (expected '\\r\\n', "
420		"got " + repr(crlf) + ")")
421
	448	"Bad chunked transfer coding (expected '\\r\\n', "
	449	"got " + repr(crlf) + ")")
	450
422	451	def read(self, size=None):
423	452	data = EMPTY
424	453	while True:
425	454	if size and len(data) >= size:
426	455	return data
427
	456
428	457	if not self.buffer:
429	458	self._fetch()
430	459	if not self.buffer:
431	460	# EOF
432	461	return data
433
	462
434	463	if size:
435	464	remaining = size - len(data)
436	465	data += self.buffer[:remaining]
437	466	self.buffer = self.buffer[remaining:]
438	467	else:
439	468	data += self.buffer
440
	469
441	470	def readline(self, size=None):
442	471	data = EMPTY
443	472	while True:
444	473	if size and len(data) >= size:
445	474	return data
446
	475
447	476	if not self.buffer:
448	477	self._fetch()
449	478	if not self.buffer:
450	479	# EOF
451	480	return data
452
	481
453	482	newline_pos = self.buffer.find(LF)
454	483	if size:
455	484	if newline_pos == -1:

466	495	else:
467	496	data += self.buffer[:newline_pos]
468	497	self.buffer = self.buffer[newline_pos:]
469
	498
470	499	def readlines(self, sizehint=0):
471	500	# Shamelessly stolen from StringIO
472	501	total = 0

479	508	break
480	509	line = self.readline(sizehint)
481	510	return lines
482
	511
483	512	def read_trailer_lines(self):
484	513	if not self.closed:
485	514	raise ValueError(
486	515	"Cannot read trailers until the request body has been read.")
487
	516
488	517	while True:
489	518	line = self.rfile.readline()
490	519	if not line:
491	520	# No more data--illegal end of headers
492	521	raise ValueError("Illegal end of headers.")
493
	522
494	523	self.bytes_read += len(line)
495	524	if self.maxlen and self.bytes_read > self.maxlen:
496	525	raise IOError("Request Entity Too Large")
497
	526
498	527	if line == CRLF:
499	528	# Normal end of headers
500	529	break
501	530	if not line.endswith(CRLF):
502	531	raise ValueError("HTTP requires CRLF terminators")
503
	532
504	533	yield line
505
	534
506	535	def close(self):
507	536	self.rfile.close()
508
	537
509	538	def __iter__(self):
510	539	# Shamelessly stolen from StringIO
511	540	total = 0

519	548
520	549
521	550	class HTTPRequest(object):
	551
522	552	"""An HTTP Request (and response).
523
	553
524	554	A single HTTP connection may consist of multiple request/response pairs.
525	555	"""
526
	556
527	557	server = None
528	558	"""The HTTPServer object which is receiving this request."""
529
	559
530	560	conn = None
531	561	"""The HTTPConnection object on which this request connected."""
532
	562
533	563	inheaders = {}
534	564	"""A dict of request headers."""
535
	565
536	566	outheaders = []
537	567	"""A list of header tuples to write in the response."""
538
	568
539	569	ready = False
540	570	"""When True, the request has been parsed and is ready to begin generating
541	571	the response. When False, signals the calling Connection that the response
542	572	should not be generated and the connection should close."""
543
	573
544	574	close_connection = False
545	575	"""Signals the calling Connection that the request should close. This does
546	576	not imply an error! The client and/or server may each request that the
547	577	connection be closed."""
548
	578
549	579	chunked_write = False
550	580	"""If True, output will be encoded with the "chunked" transfer-coding.
551
	581
552	582	This value is set automatically inside send_headers."""
553
	583
554	584	def __init__(self, server, conn):
555		self.server= server
	585	self.server = server
556	586	self.conn = conn
557
	587
558	588	self.ready = False
559	589	self.started_request = False
560	590	self.scheme = ntob("http")

563	593	# Use the lowest-common protocol in case read_request_line errors.
564	594	self.response_protocol = 'HTTP/1.0'
565	595	self.inheaders = {}
566
	596
567	597	self.status = ""
568	598	self.outheaders = []
569	599	self.sent_headers = False
570	600	self.close_connection = self.__class__.close_connection
571	601	self.chunked_read = False
572	602	self.chunked_write = self.__class__.chunked_write
573
	603
574	604	def parse_request(self):
575	605	"""Parse the next HTTP request start-line and message-headers."""
576	606	self.rfile = SizeCheckWrapper(self.conn.rfile,

578	608	try:
579	609	success = self.read_request_line()
580	610	except MaxSizeExceeded:
581		self.simple_response("414 Request-URI Too Long",
	611	self.simple_response(
	612	"414 Request-URI Too Long",
582	613	"The Request-URI sent with the request exceeds the maximum "
583	614	"allowed bytes.")
584	615	return
585	616	else:
586	617	if not success:
587	618	return
588
	619
589	620	try:
590	621	success = self.read_request_headers()
591	622	except MaxSizeExceeded:
592		self.simple_response("413 Request Entity Too Large",
	623	self.simple_response(
	624	"413 Request Entity Too Large",
593	625	"The headers sent with the request exceed the maximum "
594	626	"allowed bytes.")
595	627	return
596	628	else:
597	629	if not success:
598	630	return
599
	631
600	632	self.ready = True
601
	633
602	634	def read_request_line(self):
603	635	# HTTP/1.1 connections are persistent by default. If a client
604	636	# requests a page, then idles (leaves the connection open),

608	640	# (although your TCP stack might suffer for it: cf Apache's history
609	641	# with FIN_WAIT_2).
610	642	request_line = self.rfile.readline()
611
	643
612	644	# Set started_request to True so communicate() knows to send 408
613	645	# from here on out.
614	646	self.started_request = True
615	647	if not request_line:
616	648	return False
617
	649
618	650	if request_line == CRLF:
619	651	# RFC 2616 sec 4.1: "...if the server is reading the protocol
620	652	# stream at the beginning of a message and receives a CRLF

623	655	request_line = self.rfile.readline()
624	656	if not request_line:
625	657	return False
626
	658
627	659	if not request_line.endswith(CRLF):
628		self.simple_response("400 Bad Request", "HTTP requires CRLF terminators")
	660	self.simple_response(
	661	"400 Bad Request", "HTTP requires CRLF terminators")
629	662	return False
630
	663
631	664	try:
632	665	method, uri, req_protocol = request_line.strip().split(SPACE, 2)
633	666	rp = int(req_protocol[5]), int(req_protocol[7])
634	667	except (ValueError, IndexError):
635	668	self.simple_response("400 Bad Request", "Malformed Request-Line")
636	669	return False
637
	670
638	671	self.uri = uri
639	672	self.method = method
640
	673
641	674	# uri may be an abs_path (including "http://host.domain.tld");
642	675	scheme, authority, path = self.parse_request_uri(uri)
643	676	if NUMBER_SIGN in path:
644	677	self.simple_response("400 Bad Request",
645	678	"Illegal #fragment in Request-URI.")
646	679	return False
647
	680
648	681	if scheme:
649	682	self.scheme = scheme
650
	683
651	684	qs = EMPTY
652	685	if QUESTION_MARK in path:
653	686	path, qs = path.split(QUESTION_MARK, 1)
654
	687
655	688	# Unquote the path+params (e.g. "/this%20path" -> "/this path").
656	689	# http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2
657	690	#

667	700	return False
668	701	path = "%2F".join(atoms)
669	702	self.path = path
670
	703
671	704	# Note that, like wsgiref and most other HTTP servers,
672	705	# we "% HEX HEX"-unquote the path but not the query string.
673	706	self.qs = qs
674
	707
675	708	# Compare request and server HTTP protocol versions, in case our
676	709	# server does not support the requested protocol. Limit our output
677	710	# to min(req, server). We want the following output:

685	718	# the client only understands 1.0. RFC 2616 10.5.6 says we should
686	719	# only return 505 if the _major_ version is different.
687	720	sp = int(self.server.protocol[5]), int(self.server.protocol[7])
688
	721
689	722	if sp[0] != rp[0]:
690	723	self.simple_response("505 HTTP Version Not Supported")
691	724	return False

697	730
698	731	def read_request_headers(self):
699	732	"""Read self.rfile into self.inheaders. Return success."""
700
	733
701	734	# then all the http headers
702	735	try:
703	736	read_headers(self.rfile, self.inheaders)

705	738	ex = sys.exc_info()[1]
706	739	self.simple_response("400 Bad Request", ex.args[0])
707	740	return False
708
	741
709	742	mrbs = self.server.max_request_body_size
710	743	if mrbs and int(self.inheaders.get("Content-Length", 0)) > mrbs:
711		self.simple_response("413 Request Entity Too Large",
	744	self.simple_response(
	745	"413 Request Entity Too Large",
712	746	"The entity sent with the request exceeds the maximum "
713	747	"allowed bytes.")
714	748	return False
715
	749
716	750	# Persistent connection support
717	751	if self.response_protocol == "HTTP/1.1":
718	752	# Both server and client are HTTP/1.1

722	756	# Either the server or client (or both) are HTTP/1.0
723	757	if self.inheaders.get("Connection", "") != "Keep-Alive":
724	758	self.close_connection = True
725
	759
726	760	# Transfer-Encoding support
727	761	te = None
728	762	if self.response_protocol == "HTTP/1.1":
729	763	te = self.inheaders.get("Transfer-Encoding")
730	764	if te:
731	765	te = [x.strip().lower() for x in te.split(",") if x.strip()]
732
	766
733	767	self.chunked_read = False
734
	768
735	769	if te:
736	770	for enc in te:
737	771	if enc == "chunked":

742	776	self.simple_response("501 Unimplemented")
743	777	self.close_connection = True
744	778	return False
745
	779
746	780	# From PEP 333:
747	781	# "Servers and gateways that implement HTTP 1.1 must provide
748	782	# transparent support for HTTP 1.1's "expect/continue" mechanism.

762	796	# but it seems like it would be a big slowdown for such a rare case.
763	797	if self.inheaders.get("Expect", "") == "100-continue":
764	798	# Don't use simple_response here, because it emits headers
765		# we don't want. See http://www.cherrypy.org/ticket/951
	799	# we don't want. See
	800	# https://bitbucket.org/cherrypy/cherrypy/issue/951
766	801	msg = self.server.protocol + " 100 Continue\r\n\r\n"
767	802	try:
768	803	self.conn.wfile.sendall(msg)

771	806	if x.args[0] not in socket_errors_to_ignore:
772	807	raise
773	808	return True
774
	809
775	810	def parse_request_uri(self, uri):
776	811	"""Parse a Request-URI into (scheme, authority, path).
777
	812
778	813	Note that Request-URI's must be one of::
779
	814
780	815	Request-URI = "*" \| absoluteURI \| abs_path \| authority
781
	816
782	817	Therefore, a Request-URI which starts with a double forward-slash
783	818	cannot be a "net_path"::
784
	819
785	820	net_path = "//" authority [ abs_path ]
786
	821
787	822	Instead, it must be interpreted as an "abs_path" with an empty first
788	823	path segment::
789
	824
790	825	abs_path = "/" path_segments
791	826	path_segments = segment *( "/" segment )
792	827	segment = pchar ( ";" param )

794	829	"""
795	830	if uri == ASTERISK:
796	831	return None, None, uri
797
	832
798	833	i = uri.find('://')
799	834	if i > 0 and QUESTION_MARK not in uri[:i]:
800	835	# An absoluteURI.
801	836	# If there's a scheme (and it must be http or https), then:
802		# http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
	837	# http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query
	838	# ]]
803	839	scheme, remainder = uri[:i].lower(), uri[i + 3:]
804	840	authority, path = remainder.split(FORWARD_SLASH, 1)
805	841	path = FORWARD_SLASH + path
806	842	return scheme, authority, path
807
	843
808	844	if uri.startswith(FORWARD_SLASH):
809	845	# An abs_path.
810	846	return None, None, uri
811	847	else:
812	848	# An authority.
813	849	return None, uri, None
814
	850
815	851	def respond(self):
816	852	"""Call the gateway and write its iterable output."""
817	853	mrbs = self.server.max_request_body_size

821	857	cl = int(self.inheaders.get("Content-Length", 0))
822	858	if mrbs and mrbs < cl:
823	859	if not self.sent_headers:
824		self.simple_response("413 Request Entity Too Large",
	860	self.simple_response(
	861	"413 Request Entity Too Large",
825	862	"The entity sent with the request exceeds the maximum "
826	863	"allowed bytes.")
827	864	return
828	865	self.rfile = KnownLengthRFile(self.conn.rfile, cl)
829
	866
830	867	self.server.gateway(self).respond()
831
	868
832	869	if (self.ready and not self.sent_headers):
833	870	self.sent_headers = True
834	871	self.send_headers()
835	872	if self.chunked_write:
836	873	self.conn.wfile.sendall("0\r\n\r\n")
837
	874
838	875	def simple_response(self, status, msg=""):
839	876	"""Write a simple response back to the client."""
840	877	status = str(status)

842	879	status + CRLF,
843	880	"Content-Length: %s\r\n" % len(msg),
844	881	"Content-Type: text/plain\r\n"]
845
	882
846	883	if status[:3] in ("413", "414"):
847	884	# Request Entity Too Large / Request-URI Too Long
848	885	self.close_connection = True

855	892	# HTTP/1.0 had no 413/414 status nor Connection header.
856	893	# Emit 400 instead and trust the message body is enough.
857	894	status = "400 Bad Request"
858
	895
859	896	buf.append(CRLF)
860	897	if msg:
861	898	if isinstance(msg, unicodestr):
862	899	msg = msg.encode("ISO-8859-1")
863	900	buf.append(msg)
864
	901
865	902	try:
866	903	self.conn.wfile.sendall("".join(buf))
867	904	except socket.error:
868	905	x = sys.exc_info()[1]
869	906	if x.args[0] not in socket_errors_to_ignore:
870	907	raise
871
	908
872	909	def write(self, chunk):
873	910	"""Write unbuffered data to the client."""
874	911	if self.chunked_write and chunk:

876	913	self.conn.wfile.sendall(EMPTY.join(buf))
877	914	else:
878	915	self.conn.wfile.sendall(chunk)
879
	916
880	917	def send_headers(self):
881	918	"""Assert, process, and send the HTTP response message-headers.
882
	919
883	920	You must set self.status, and self.outheaders before calling this.
884	921	"""
885	922	hkeys = [key.lower() for key, value in self.outheaders]
886	923	status = int(self.status[:3])
887
	924
888	925	if status == 413:
889	926	# Request Entity Too Large. Close conn to avoid garbage.
890	927	self.close_connection = True

896	933	pass
897	934	else:
898	935	if (self.response_protocol == 'HTTP/1.1'
899		and self.method != 'HEAD'):
	936	and self.method != 'HEAD'):
900	937	# Use the chunked transfer-coding
901	938	self.chunked_write = True
902	939	self.outheaders.append(("Transfer-Encoding", "chunked"))
903	940	else:
904	941	# Closing the conn is the only way to determine len.
905	942	self.close_connection = True
906
	943
907	944	if "connection" not in hkeys:
908	945	if self.response_protocol == 'HTTP/1.1':
909	946	# Both server and client are HTTP/1.1 or better

913	950	# Server and/or client are HTTP/1.0
914	951	if not self.close_connection:
915	952	self.outheaders.append(("Connection", "Keep-Alive"))
916
	953
917	954	if (not self.close_connection) and (not self.chunked_read):
918	955	# Read any remaining request body data on the socket.
919	956	# "If an origin server receives a request that does not include an

930	967	remaining = getattr(self.rfile, 'remaining', 0)
931	968	if remaining > 0:
932	969	self.rfile.read(remaining)
933
	970
934	971	if "date" not in hkeys:
935	972	self.outheaders.append(("Date", rfc822.formatdate()))
936
	973
937	974	if "server" not in hkeys:
938	975	self.outheaders.append(("Server", self.server.server_name))
939
	976
940	977	buf = [self.server.protocol + SPACE + self.status + CRLF]
941	978	for k, v in self.outheaders:
942	979	buf.append(k + COLON + SPACE + v + CRLF)

945	982
946	983
947	984	class NoSSLError(Exception):
	985
948	986	"""Exception raised when a client speaks HTTP to an HTTPS socket."""
949	987	pass
950	988
951	989
952	990	class FatalSSLAlert(Exception):
	991
953	992	"""Exception raised when the SSL implementation signals a fatal alert."""
954	993	pass
955	994
956	995
957	996	class CP_fileobject(socket._fileobject):
	997
958	998	"""Faux file object attached to a socket object."""
959	999
960	1000	def __init__(self, args, *kwargs):
961	1001	self.bytes_read = 0
962	1002	self.bytes_written = 0
963	1003	socket._fileobject.__init__(self, args, *kwargs)
964
	1004
965	1005	def sendall(self, data):
966	1006	"""Sendall for non-blocking sockets."""
967	1007	while data:

991	1031	return data
992	1032	except socket.error, e:
993	1033	if (e.args[0] not in socket_errors_nonblocking
994		and e.args[0] not in socket_error_eintr):
	1034	and e.args[0] not in socket_error_eintr):
995	1035	raise
996	1036
997	1037	if not _fileobject_uses_str_type:
998	1038	def read(self, size=-1):
999		# Use max, disallow tiny reads in a loop as they are very inefficient.
1000		# We never leave read() with any leftover data from a new recv() call
1001		# in our internal buffer.
	1039	# Use max, disallow tiny reads in a loop as they are very
	1040	# inefficient.
	1041	# We never leave read() with any leftover data from a new recv()
	1042	# call in our internal buffer.
1002	1043	rbufsize = max(self._rbufsize, self.default_bufsize)
1003		# Our use of StringIO rather than lists of string objects returned by
1004		# recv() minimizes memory usage and fragmentation that occurs when
1005		# rbufsize is large compared to the typical return value of recv().
	1044	# Our use of StringIO rather than lists of string objects returned
	1045	# by recv() minimizes memory usage and fragmentation that occurs
	1046	# when rbufsize is large compared to the typical return value of
	1047	# recv().
1006	1048	buf = self._rbuf
1007	1049	buf.seek(0, 2) # seek end
1008	1050	if size < 0:
1009	1051	# Read until EOF
1010		self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf.
	1052	# reset _rbuf. we consume it via buf.
	1053	self._rbuf = StringIO.StringIO()
1011	1054	while True:
1012	1055	data = self.recv(rbufsize)
1013	1056	if not data:

1018	1061	# Read until size bytes or EOF seen, whichever comes first
1019	1062	buf_len = buf.tell()
1020	1063	if buf_len >= size:
1021		# Already have size bytes in our buffer? Extract and return.
	1064	# Already have size bytes in our buffer? Extract and
	1065	# return.
1022	1066	buf.seek(0)
1023	1067	rv = buf.read(size)
1024	1068	self._rbuf = StringIO.StringIO()
1025	1069	self._rbuf.write(buf.read())
1026	1070	return rv
1027	1071
1028		self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf.
	1072	# reset _rbuf. we consume it via buf.
	1073	self._rbuf = StringIO.StringIO()
1029	1074	while True:
1030	1075	left = size - buf_len
1031	1076	# recv() will malloc the amount of memory given as its

1073	1118	# Speed up unbuffered case
1074	1119	buf.seek(0)
1075	1120	buffers = [buf.read()]
1076		self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf.
	1121	# reset _rbuf. we consume it via buf.
	1122	self._rbuf = StringIO.StringIO()
1077	1123	data = None
1078	1124	recv = self.recv
1079	1125	while data != "\n":

1084	1130	return "".join(buffers)
1085	1131
1086	1132	buf.seek(0, 2) # seek end
1087		self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf.
	1133	# reset _rbuf. we consume it via buf.
	1134	self._rbuf = StringIO.StringIO()
1088	1135	while True:
1089	1136	data = self.recv(self._rbufsize)
1090	1137	if not data:

1099	1146	buf.write(data)
1100	1147	return buf.getvalue()
1101	1148	else:
1102		# Read until size bytes or \n or EOF seen, whichever comes first
	1149	# Read until size bytes or \n or EOF seen, whichever comes
	1150	# first
1103	1151	buf.seek(0, 2) # seek end
1104	1152	buf_len = buf.tell()
1105	1153	if buf_len >= size:

1108	1156	self._rbuf = StringIO.StringIO()
1109	1157	self._rbuf.write(buf.read())
1110	1158	return rv
1111		self._rbuf = StringIO.StringIO() # reset _rbuf. we consume it via buf.
	1159	# reset _rbuf. we consume it via buf.
	1160	self._rbuf = StringIO.StringIO()
1112	1161	while True:
1113	1162	data = self.recv(self._rbufsize)
1114	1163	if not data:

1124	1173	buf.write(data[:nl])
1125	1174	break
1126	1175	else:
1127		# Shortcut. Avoid data copy through buf when returning
1128		# a substring of our first recv().
	1176	# Shortcut. Avoid data copy through buf when
	1177	# returning a substring of our first recv().
1129	1178	return data[:nl]
1130	1179	n = len(data)
1131	1180	if n == size and not buf_len:

1219	1268	break
1220	1269	return "".join(buffers)
1221	1270	else:
1222		# Read until size bytes or \n or EOF seen, whichever comes first
	1271	# Read until size bytes or \n or EOF seen, whichever comes
	1272	# first
1223	1273	nl = data.find('\n', 0, size)
1224	1274	if nl >= 0:
1225	1275	nl += 1

1255	1305
1256	1306
1257	1307	class HTTPConnection(object):
	1308
1258	1309	"""An HTTP connection (active socket).
1259
	1310
1260	1311	server: the Server object which received this connection.
1261	1312	socket: the raw socket object (usually TCP) for this connection.
1262	1313	makefile: a fileobject class for reading from the socket.
1263	1314	"""
1264
	1315
1265	1316	remote_addr = None
1266	1317	remote_port = None
1267	1318	ssl_env = None
1268	1319	rbufsize = DEFAULT_BUFFER_SIZE
1269	1320	wbufsize = DEFAULT_BUFFER_SIZE
1270	1321	RequestHandlerClass = HTTPRequest
1271
	1322
1272	1323	def __init__(self, server, sock, makefile=CP_fileobject):
1273	1324	self.server = server
1274	1325	self.socket = sock
1275		self.rfile = makefile(sock, "rb", self.rbufsize)
1276		self.wfile = makefile(sock, "wb", self.wbufsize)
	1326	self.rfile = makefile(sock._sock, "rb", self.rbufsize)
	1327	self.wfile = makefile(sock._sock, "wb", self.wbufsize)
1277	1328	self.requests_seen = 0
1278
	1329
1279	1330	def communicate(self):
1280	1331	"""Read each request and respond appropriately."""
1281	1332	request_seen = False

1286	1337	# get written to the previous request.
1287	1338	req = None
1288	1339	req = self.RequestHandlerClass(self.server, self)
1289
	1340
1290	1341	# This order of operations should guarantee correct pipelining.
1291	1342	req.parse_request()
1292	1343	if self.server.stats['Enabled']:

1296	1347	# probably already made a simple_response). Return and
1297	1348	# let the conn close.
1298	1349	return
1299
	1350
1300	1351	request_seen = True
1301	1352	req.respond()
1302	1353	if req.close_connection:

1305	1356	e = sys.exc_info()[1]
1306	1357	errnum = e.args[0]
1307	1358	# sadly SSL sockets return a different (longer) time out string
1308		if errnum == 'timed out' or errnum == 'The read operation timed out':
	1359	if (
	1360	errnum == 'timed out' or
	1361	errnum == 'The read operation timed out'
	1362	):
1309	1363	# Don't error if we're between requests; only error
1310	1364	# if 1) no request has been started at all, or 2) we're
1311	1365	# in the middle of a request.
1312		# See http://www.cherrypy.org/ticket/853
	1366	# See https://bitbucket.org/cherrypy/cherrypy/issue/853
1313	1367	if (not request_seen) or (req and req.started_request):
1314	1368	# Don't bother writing the 408 if the response
1315	1369	# has already started being written.

1337	1391	except NoSSLError:
1338	1392	if req and not req.sent_headers:
1339	1393	# Unwrap our wfile
1340		self.wfile = CP_fileobject(self.socket._sock, "wb", self.wbufsize)
1341		req.simple_response("400 Bad Request",
	1394	self.wfile = CP_fileobject(
	1395	self.socket._sock, "wb", self.wbufsize)
	1396	req.simple_response(
	1397	"400 Bad Request",
1342	1398	"The client sent a plain HTTP request, but "
1343	1399	"this server only speaks HTTPS on this port.")
1344	1400	self.linger = True

1351	1407	except FatalSSLAlert:
1352	1408	# Close the connection.
1353	1409	return
1354
	1410
1355	1411	linger = False
1356
	1412
1357	1413	def close(self):
1358	1414	"""Close the socket underlying this connection."""
1359	1415	self.rfile.close()
1360
	1416
1361	1417	if not self.linger:
1362		# Python's socket module does NOT call close on the kernel socket
1363		# when you call socket.close(). We do so manually here because we
1364		# want this server to send a FIN TCP segment immediately. Note this
1365		# must be called before calling socket.close(), because the latter
1366		# drops its reference to the kernel socket.
	1418	# Python's socket module does NOT call close on the kernel
	1419	# socket when you call socket.close(). We do so manually here
	1420	# because we want this server to send a FIN TCP segment
	1421	# immediately. Note this must be called before calling
	1422	# socket.close(), because the latter drops its reference to
	1423	# the kernel socket.
1367	1424	if hasattr(self.socket, '_sock'):
1368	1425	self.socket._sock.close()
1369	1426	self.socket.close()

1378	1435
1379	1436
1380	1437	class TrueyZero(object):
1381		"""An object which equals and does math like the integer '0' but evals True."""
	1438
	1439	"""An object which equals and does math like the integer 0 but evals True.
	1440	"""
	1441
1382	1442	def __add__(self, other):
1383	1443	return other
	1444
1384	1445	def __radd__(self, other):
1385	1446	return other
1386	1447	trueyzero = TrueyZero()

1388	1449
1389	1450	_SHUTDOWNREQUEST = None
1390	1451
	1452
1391	1453	class WorkerThread(threading.Thread):
	1454
1392	1455	"""Thread which continuously polls a Queue for Connection objects.
1393
	1456
1394	1457	Due to the timing issues of polling a Queue, a WorkerThread does not
1395	1458	check its own 'ready' flag after it has started. To stop the thread,
1396	1459	it is necessary to stick a _SHUTDOWNREQUEST object onto the Queue
1397	1460	(one for each running WorkerThread).
1398	1461	"""
1399
	1462
1400	1463	conn = None
1401	1464	"""The current connection pulled off the Queue, or None."""
1402
	1465
1403	1466	server = None
1404	1467	"""The HTTP Server which spawned this thread, and which owns the
1405	1468	Queue and is placing active connections into it."""
1406
	1469
1407	1470	ready = False
1408	1471	"""A simple flag for the calling server to know when this thread
1409	1472	has begun polling the Queue."""
1410
1411
	1473
1412	1474	def __init__(self, server):
1413	1475	self.ready = False
1414	1476	self.server = server
1415
	1477
1416	1478	self.requests_seen = 0
1417	1479	self.bytes_read = 0
1418	1480	self.bytes_written = 0
1419	1481	self.start_time = None
1420	1482	self.work_time = 0
1421	1483	self.stats = {
1422		'Requests': lambda s: self.requests_seen + ((self.start_time is None) and trueyzero or self.conn.requests_seen),
1423		'Bytes Read': lambda s: self.bytes_read + ((self.start_time is None) and trueyzero or self.conn.rfile.bytes_read),
1424		'Bytes Written': lambda s: self.bytes_written + ((self.start_time is None) and trueyzero or self.conn.wfile.bytes_written),
1425		'Work Time': lambda s: self.work_time + ((self.start_time is None) and trueyzero or time.time() - self.start_time),
1426		'Read Throughput': lambda s: s['Bytes Read'](s) / (s['Work Time'](s) or 1e-6),
1427		'Write Throughput': lambda s: s['Bytes Written'](s) / (s['Work Time'](s) or 1e-6),
	1484	'Requests': lambda s: self.requests_seen + (
	1485	(self.start_time is None) and
	1486	trueyzero or
	1487	self.conn.requests_seen
	1488	),
	1489	'Bytes Read': lambda s: self.bytes_read + (
	1490	(self.start_time is None) and
	1491	trueyzero or
	1492	self.conn.rfile.bytes_read
	1493	),
	1494	'Bytes Written': lambda s: self.bytes_written + (
	1495	(self.start_time is None) and
	1496	trueyzero or
	1497	self.conn.wfile.bytes_written
	1498	),
	1499	'Work Time': lambda s: self.work_time + (
	1500	(self.start_time is None) and
	1501	trueyzero or
	1502	time.time() - self.start_time
	1503	),
	1504	'Read Throughput': lambda s: s['Bytes Read'](s) / (
	1505	s['Work Time'](s) or 1e-6),
	1506	'Write Throughput': lambda s: s['Bytes Written'](s) / (
	1507	s['Work Time'](s) or 1e-6),
1428	1508	}
1429	1509	threading.Thread.__init__(self)
1430
	1510
1431	1511	def run(self):
1432	1512	self.server.stats['Worker Threads'][self.getName()] = self.stats
1433	1513	try:

1436	1516	conn = self.server.requests.get()
1437	1517	if conn is _SHUTDOWNREQUEST:
1438	1518	return
1439
	1519
1440	1520	self.conn = conn
1441	1521	if self.server.stats['Enabled']:
1442	1522	self.start_time = time.time()

1457	1537
1458	1538
1459	1539	class ThreadPool(object):
	1540
1460	1541	"""A Request Queue for an HTTPServer which pools threads.
1461
	1542
1462	1543	ThreadPool objects must provide min, get(), put(obj), start()
1463	1544	and stop(timeout) attributes.
1464	1545	"""
1465
	1546
1466	1547	def __init__(self, server, min=10, max=-1):
1467	1548	self.server = server
1468	1549	self.min = min

1470	1551	self._threads = []
1471	1552	self._queue = queue.Queue()
1472	1553	self.get = self._queue.get
1473
	1554
1474	1555	def start(self):
1475	1556	"""Start the pool of threads."""
1476	1557	for i in range(self.min):

1481	1562	for worker in self._threads:
1482	1563	while not worker.ready:
1483	1564	time.sleep(.1)
1484
	1565
1485	1566	def _get_idle(self):
1486	1567	"""Number of worker threads which are idle. Read-only."""
1487	1568	return len([t for t in self._threads if t.conn is None])
1488	1569	idle = property(_get_idle, doc=_get_idle.__doc__)
1489
	1570
1490	1571	def put(self, obj):
1491	1572	self._queue.put(obj)
1492	1573	if obj is _SHUTDOWNREQUEST:
1493	1574	return
1494
	1575
1495	1576	def grow(self, amount):
1496	1577	"""Spawn new worker threads (not above self.max)."""
1497		for i in range(amount):
1498		if self.max > 0 and len(self._threads) >= self.max:
1499		break
1500		worker = WorkerThread(self.server)
1501		worker.setName("CP Server " + worker.getName())
1502		self._threads.append(worker)
1503		worker.start()
1504
	1578	if self.max > 0:
	1579	budget = max(self.max - len(self._threads), 0)
	1580	else:
	1581	# self.max <= 0 indicates no maximum
	1582	budget = float('inf')
	1583
	1584	n_new = min(amount, budget)
	1585
	1586	workers = [self._spawn_worker() for i in range(n_new)]
	1587	while not self._all(operator.attrgetter('ready'), workers):
	1588	time.sleep(.1)
	1589	self._threads.extend(workers)
	1590
	1591	def _spawn_worker(self):
	1592	worker = WorkerThread(self.server)
	1593	worker.setName("CP Server " + worker.getName())
	1594	worker.start()
	1595	return worker
	1596
	1597	def _all(func, items):
	1598	results = [func(item) for item in items]
	1599	return reduce(operator.and_, results, True)
	1600	_all = staticmethod(_all)
	1601
1505	1602	def shrink(self, amount):
1506	1603	"""Kill off worker threads (not below self.min)."""
1507	1604	# Grow/shrink the pool if necessary.

1510	1607	if not t.isAlive():
1511	1608	self._threads.remove(t)
1512	1609	amount -= 1
1513
1514		if amount > 0:
1515		for i in range(min(amount, len(self._threads) - self.min)):
1516		# Put a number of shutdown requests on the queue equal
1517		# to 'amount'. Once each of those is processed by a worker,
1518		# that worker will terminate and be culled from our list
1519		# in self.put.
1520		self._queue.put(_SHUTDOWNREQUEST)
1521
	1610
	1611	# calculate the number of threads above the minimum
	1612	n_extra = max(len(self._threads) - self.min, 0)
	1613
	1614	# don't remove more than amount
	1615	n_to_remove = min(amount, n_extra)
	1616
	1617	# put shutdown requests on the queue equal to the number of threads
	1618	# to remove. As each request is processed by a worker, that worker
	1619	# will terminate and be culled from the list.
	1620	for n in range(n_to_remove):
	1621	self._queue.put(_SHUTDOWNREQUEST)
	1622
1522	1623	def stop(self, timeout=5):
1523	1624	# Must shut down threads here so the code that calls
1524	1625	# this method can know when all threads are stopped.
1525	1626	for worker in self._threads:
1526	1627	self._queue.put(_SHUTDOWNREQUEST)
1527
	1628
1528	1629	# Don't join currentThread (when stop is called inside a request).
1529	1630	current = threading.currentThread()
1530	1631	if timeout and timeout >= 0:

1552	1653	worker.join()
1553	1654	except (AssertionError,
1554	1655	# Ignore repeated Ctrl-C.
1555		# See http://www.cherrypy.org/ticket/691.
	1656	# See
	1657	# https://bitbucket.org/cherrypy/cherrypy/issue/691.
1556	1658	KeyboardInterrupt):
1557	1659	pass
1558
	1660
1559	1661	def _get_qsize(self):
1560	1662	return self._queue.qsize()
1561	1663	qsize = property(_get_qsize)
1562
1563	1664
1564	1665
1565	1666	try:

1567	1668	except ImportError:
1568	1669	try:
1569	1670	from ctypes import windll, WinError
	1671	import ctypes.wintypes
	1672	_SetHandleInformation = windll.kernel32.SetHandleInformation
	1673	_SetHandleInformation.argtypes = [
	1674	ctypes.wintypes.HANDLE,
	1675	ctypes.wintypes.DWORD,
	1676	ctypes.wintypes.DWORD,
	1677	]
	1678	_SetHandleInformation.restype = ctypes.wintypes.BOOL
1570	1679	except ImportError:
1571	1680	def prevent_socket_inheritance(sock):
1572	1681	"""Dummy function, since neither fcntl nor ctypes are available."""

1574	1683	else:
1575	1684	def prevent_socket_inheritance(sock):
1576	1685	"""Mark the given socket fd as non-inheritable (Windows)."""
1577		if not windll.kernel32.SetHandleInformation(sock.fileno(), 1, 0):
	1686	if not _SetHandleInformation(sock.fileno(), 1, 0):
1578	1687	raise WinError()
1579	1688	else:
1580	1689	def prevent_socket_inheritance(sock):

1585	1694
1586	1695
1587	1696	class SSLAdapter(object):
	1697
1588	1698	"""Base class for SSL driver library adapters.
1589
	1699
1590	1700	Required methods:
1591
	1701
1592	1702	* ``wrap(sock) -> (wrapped socket, ssl environ dict)``
1593		* ``makefile(sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE) -> socket file object``
	1703	* ``makefile(sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE) ->
	1704	socket file object``
1594	1705	"""
1595
	1706
1596	1707	def __init__(self, certificate, private_key, certificate_chain=None):
1597	1708	self.certificate = certificate
1598	1709	self.private_key = private_key
1599	1710	self.certificate_chain = certificate_chain
1600
	1711
1601	1712	def wrap(self, sock):
1602	1713	raise NotImplemented
1603
	1714
1604	1715	def makefile(self, sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE):
1605	1716	raise NotImplemented
1606	1717
1607	1718
1608	1719	class HTTPServer(object):
	1720
1609	1721	"""An HTTP server."""
1610
	1722
1611	1723	_bind_addr = "127.0.0.1"
1612	1724	_interrupt = None
1613
	1725
1614	1726	gateway = None
1615	1727	"""A Gateway instance."""
1616
	1728
1617	1729	minthreads = None
1618	1730	"""The minimum number of worker threads to create (default 10)."""
1619
	1731
1620	1732	maxthreads = None
1621		"""The maximum number of worker threads to create (default -1 = no limit)."""
1622
	1733	"""The maximum number of worker threads to create (default -1 = no limit).
	1734	"""
	1735
1623	1736	server_name = None
1624	1737	"""The name of the server; defaults to socket.gethostname()."""
1625
	1738
1626	1739	protocol = "HTTP/1.1"
1627	1740	"""The version string to write in the Status-Line of all HTTP responses.
1628
	1741
1629	1742	For example, "HTTP/1.1" is the default. This also limits the supported
1630	1743	features used in the response."""
1631
	1744
1632	1745	request_queue_size = 5
1633		"""The 'backlog' arg to socket.listen(); max queued connections (default 5)."""
1634
	1746	"""The 'backlog' arg to socket.listen(); max queued connections
	1747	(default 5).
	1748	"""
	1749
1635	1750	shutdown_timeout = 5
1636		"""The total time, in seconds, to wait for worker threads to cleanly exit."""
1637
	1751	"""The total time, in seconds, to wait for worker threads to cleanly exit.
	1752	"""
	1753
1638	1754	timeout = 10
1639	1755	"""The timeout in seconds for accepted connections (default 10)."""
1640
1641		version = "CherryPy/3.2.2"
	1756
	1757	version = "CherryPy/3.3.0"
1642	1758	"""A version string for the HTTPServer."""
1643
	1759
1644	1760	software = None
1645	1761	"""The value to set for the SERVER_SOFTWARE entry in the WSGI environ.
1646
	1762
1647	1763	If None, this defaults to ``'%s Server' % self.version``."""
1648
	1764
1649	1765	ready = False
1650		"""An internal flag which marks whether the socket is accepting connections."""
1651
	1766	"""An internal flag which marks whether the socket is accepting connections
	1767	"""
	1768
1652	1769	max_request_header_size = 0
1653	1770	"""The maximum size, in bytes, for request headers, or 0 for no limit."""
1654
	1771
1655	1772	max_request_body_size = 0
1656	1773	"""The maximum size, in bytes, for request bodies, or 0 for no limit."""
1657
	1774
1658	1775	nodelay = True
1659	1776	"""If True (the default since 3.1), sets the TCP_NODELAY socket option."""
1660
	1777
1661	1778	ConnectionClass = HTTPConnection
1662	1779	"""The class to use for handling HTTP connections."""
1663
	1780
1664	1781	ssl_adapter = None
1665	1782	"""An instance of SSLAdapter (or a subclass).
1666
	1783
1667	1784	You must have the corresponding SSL driver library installed."""
1668
	1785
1669	1786	def __init__(self, bind_addr, gateway, minthreads=10, maxthreads=-1,
1670	1787	server_name=None):
1671	1788	self.bind_addr = bind_addr
1672	1789	self.gateway = gateway
1673
	1790
1674	1791	self.requests = ThreadPool(self, min=minthreads or 1, max=maxthreads)
1675
	1792
1676	1793	if not server_name:
1677	1794	server_name = socket.gethostname()
1678	1795	self.server_name = server_name
1679	1796	self.clear_stats()
1680
	1797
1681	1798	def clear_stats(self):
1682	1799	self._start_time = None
1683	1800	self._run_time = 0

1691	1808	'Threads': lambda s: len(getattr(self.requests, "_threads", [])),
1692	1809	'Threads Idle': lambda s: getattr(self.requests, "idle", None),
1693	1810	'Socket Errors': 0,
1694		'Requests': lambda s: (not s['Enabled']) and -1 or sum([w['Requests'](w) for w
1695		in s['Worker Threads'].values()], 0),
1696		'Bytes Read': lambda s: (not s['Enabled']) and -1 or sum([w['Bytes Read'](w) for w
1697		in s['Worker Threads'].values()], 0),
1698		'Bytes Written': lambda s: (not s['Enabled']) and -1 or sum([w['Bytes Written'](w) for w
1699		in s['Worker Threads'].values()], 0),
1700		'Work Time': lambda s: (not s['Enabled']) and -1 or sum([w['Work Time'](w) for w
1701		in s['Worker Threads'].values()], 0),
	1811	'Requests': lambda s: (not s['Enabled']) and -1 or sum(
	1812	[w['Requests'](w) for w in s['Worker Threads'].values()], 0),
	1813	'Bytes Read': lambda s: (not s['Enabled']) and -1 or sum(
	1814	[w['Bytes Read'](w) for w in s['Worker Threads'].values()], 0),
	1815	'Bytes Written': lambda s: (not s['Enabled']) and -1 or sum(
	1816	[w['Bytes Written'](w) for w in s['Worker Threads'].values()],
	1817	0),
	1818	'Work Time': lambda s: (not s['Enabled']) and -1 or sum(
	1819	[w['Work Time'](w) for w in s['Worker Threads'].values()], 0),
1702	1820	'Read Throughput': lambda s: (not s['Enabled']) and -1 or sum(
1703	1821	[w['Bytes Read'](w) / (w['Work Time'](w) or 1e-6)
1704	1822	for w in s['Worker Threads'].values()], 0),

1706	1824	[w['Bytes Written'](w) / (w['Work Time'](w) or 1e-6)
1707	1825	for w in s['Worker Threads'].values()], 0),
1708	1826	'Worker Threads': {},
1709		}
	1827	}
1710	1828	logging.statistics["CherryPy HTTPServer %d" % id(self)] = self.stats
1711
	1829
1712	1830	def runtime(self):
1713	1831	if self._start_time is None:
1714	1832	return self._run_time
1715	1833	else:
1716	1834	return self._run_time + (time.time() - self._start_time)
1717
	1835
1718	1836	def __str__(self):
1719	1837	return "%s.%s(%r)" % (self.__module__, self.__class__.__name__,
1720	1838	self.bind_addr)
1721
	1839
1722	1840	def _get_bind_addr(self):
1723	1841	return self._bind_addr
	1842
1724	1843	def _set_bind_addr(self, value):
1725	1844	if isinstance(value, tuple) and value[0] in ('', None):
1726	1845	# Despite the socket module docs, using '' does not

1737	1856	"Use '0.0.0.0' (IPv4) or '::' (IPv6) instead "
1738	1857	"to listen on all active interfaces.")
1739	1858	self._bind_addr = value
1740		bind_addr = property(_get_bind_addr, _set_bind_addr,
	1859	bind_addr = property(
	1860	_get_bind_addr,
	1861	_set_bind_addr,
1741	1862	doc="""The interface on which to listen for connections.
1742
	1863
1743	1864	For TCP sockets, a (host, port) tuple. Host values may be any IPv4
1744	1865	or IPv6 address, or any valid hostname. The string 'localhost' is a
1745	1866	synonym for '127.0.0.1' (or '::1', if your hosts file prefers IPv6).
1746	1867	The string '0.0.0.0' is a special IPv4 entry meaning "any active
1747	1868	interface" (INADDR_ANY), and '::' is the similar IN6ADDR_ANY for
1748	1869	IPv6. The empty string or None are not allowed.
1749
	1870
1750	1871	For UNIX sockets, supply the filename as a string.""")
1751
	1872
1752	1873	def start(self):
1753	1874	"""Run the server forever."""
1754	1875	# We don't have to trap KeyboardInterrupt or SystemExit here,

1756	1877	# If you're using this server with another framework, you should
1757	1878	# trap those exceptions in whatever code block calls start().
1758	1879	self._interrupt = None
1759
	1880
1760	1881	if self.software is None:
1761	1882	self.software = "%s Server" % self.version
1762
	1883
1763	1884	# SSL backward compatibility
1764	1885	if (self.ssl_adapter is None and
1765		getattr(self, 'ssl_certificate', None) and
1766		getattr(self, 'ssl_private_key', None)):
	1886	getattr(self, 'ssl_certificate', None) and
	1887	getattr(self, 'ssl_private_key', None)):
1767	1888	warnings.warn(
1768		"SSL attributes are deprecated in CherryPy 3.2, and will "
1769		"be removed in CherryPy 3.3. Use an ssl_adapter attribute "
1770		"instead.",
1771		DeprecationWarning
1772		)
	1889	"SSL attributes are deprecated in CherryPy 3.2, and will "
	1890	"be removed in CherryPy 3.3. Use an ssl_adapter attribute "
	1891	"instead.",
	1892	DeprecationWarning
	1893	)
1773	1894	try:
1774	1895	from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
1775	1896	except ImportError:

1778	1899	self.ssl_adapter = pyOpenSSLAdapter(
1779	1900	self.ssl_certificate, self.ssl_private_key,
1780	1901	getattr(self, 'ssl_certificate_chain', None))
1781
	1902
1782	1903	# Select the appropriate socket
1783	1904	if isinstance(self.bind_addr, basestring):
1784	1905	# AF_UNIX socket
1785
	1906
1786	1907	# So we can reuse the socket...
1787		try: os.unlink(self.bind_addr)
1788		except: pass
1789
	1908	try:
	1909	os.unlink(self.bind_addr)
	1910	except:
	1911	pass
	1912
1790	1913	# So everyone can access the socket...
1791		try: os.chmod(self.bind_addr, 511) # 0777
1792		except: pass
1793
1794		info = [(socket.AF_UNIX, socket.SOCK_STREAM, 0, "", self.bind_addr)]
	1914	try:
	1915	os.chmod(self.bind_addr, 511) # 0777
	1916	except:
	1917	pass
	1918
	1919	info = [
	1920	(socket.AF_UNIX, socket.SOCK_STREAM, 0, "", self.bind_addr)]
1795	1921	else:
1796	1922	# AF_INET or AF_INET6 socket
1797		# Get the correct address family for our host (allows IPv6 addresses)
	1923	# Get the correct address family for our host (allows IPv6
	1924	# addresses)
1798	1925	host, port = self.bind_addr
1799	1926	try:
1800		info = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
1801		socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
	1927	info = socket.getaddrinfo(
	1928	host, port, socket.AF_UNSPEC,
	1929	socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
1802	1930	except socket.gaierror:
1803	1931	if ':' in self.bind_addr[0]:
1804	1932	info = [(socket.AF_INET6, socket.SOCK_STREAM,

1806	1934	else:
1807	1935	info = [(socket.AF_INET, socket.SOCK_STREAM,
1808	1936	0, "", self.bind_addr)]
1809
	1937
1810	1938	self.socket = None
1811	1939	msg = "No socket could be created"
1812	1940	for res in info:
1813	1941	af, socktype, proto, canonname, sa = res
1814	1942	try:
1815	1943	self.bind(af, socktype, proto)
1816		except socket.error:
	1944	except socket.error, serr:
	1945	msg = "%s -- (%s: %s)" % (msg, sa, serr)
1817	1946	if self.socket:
1818	1947	self.socket.close()
1819	1948	self.socket = None

1821	1950	break
1822	1951	if not self.socket:
1823	1952	raise socket.error(msg)
1824
	1953
1825	1954	# Timeout so KeyboardInterrupt can be caught on Win32
1826	1955	self.socket.settimeout(1)
1827	1956	self.socket.listen(self.request_queue_size)
1828
	1957
1829	1958	# Create worker threads
1830	1959	self.requests.start()
1831
	1960
1832	1961	self.ready = True
1833	1962	self._start_time = time.time()
1834	1963	while self.ready:

1839	1968	except:
1840	1969	self.error_log("Error in HTTPServer.tick", level=logging.ERROR,
1841	1970	traceback=True)
1842
	1971
1843	1972	if self.interrupt:
1844	1973	while self.interrupt is True:
1845	1974	# Wait for self.stop() to complete. See _set_interrupt.

1863	1992	self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
1864	1993	if self.nodelay and not isinstance(self.bind_addr, str):
1865	1994	self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
1866
	1995
1867	1996	if self.ssl_adapter is not None:
1868	1997	self.socket = self.ssl_adapter.bind(self.socket)
1869
	1998
1870	1999	# If listening on the IPV6 any address ('::' = IN6ADDR_ANY),
1871		# activate dual-stack. See http://www.cherrypy.org/ticket/871.
	2000	# activate dual-stack. See
	2001	# https://bitbucket.org/cherrypy/cherrypy/issue/871.
1872	2002	if (hasattr(socket, 'AF_INET6') and family == socket.AF_INET6
1873		and self.bind_addr[0] in ('::', '::0', '::0.0.0.0')):
	2003	and self.bind_addr[0] in ('::', '::0', '::0.0.0.0')):
1874	2004	try:
1875		self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
	2005	self.socket.setsockopt(
	2006	socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
1876	2007	except (AttributeError, socket.error):
1877	2008	# Apparently, the socket option is not available in
1878	2009	# this machine's TCP stack
1879	2010	pass
1880
	2011
1881	2012	self.socket.bind(self.bind_addr)
1882
	2013
1883	2014	def tick(self):
1884	2015	"""Accept a new connection and put it on the Queue."""
1885	2016	try:

1888	2019	self.stats['Accepts'] += 1
1889	2020	if not self.ready:
1890	2021	return
1891
	2022
1892	2023	prevent_socket_inheritance(s)
1893	2024	if hasattr(s, 'settimeout'):
1894	2025	s.settimeout(self.timeout)
1895
	2026
1896	2027	makefile = CP_fileobject
1897	2028	ssl_env = {}
1898	2029	# if ssl cert and key are set, we try to be a secure HTTP server

1906	2037	"Content-Length: %s\r\n" % len(msg),
1907	2038	"Content-Type: text/plain\r\n\r\n",
1908	2039	msg]
1909
1910		wfile = makefile(s, "wb", DEFAULT_BUFFER_SIZE)
	2040
	2041	wfile = makefile(s._sock, "wb", DEFAULT_BUFFER_SIZE)
1911	2042	try:
1912	2043	wfile.sendall("".join(buf))
1913	2044	except socket.error:

1921	2052	# Re-apply our timeout since we may have a new socket object
1922	2053	if hasattr(s, 'settimeout'):
1923	2054	s.settimeout(self.timeout)
1924
	2055
1925	2056	conn = self.ConnectionClass(self, s, makefile)
1926
	2057
1927	2058	if not isinstance(self.bind_addr, basestring):
1928	2059	# optional values
1929	2060	# Until we do DNS lookups, omit REMOTE_HOST
1930		if addr is None: # sometimes this can happen
	2061	if addr is None: # sometimes this can happen
1931	2062	# figure out if AF_INET or AF_INET6.
1932	2063	if len(s.getsockname()) == 2:
1933	2064	# AF_INET

1937	2068	addr = ('::', 0)
1938	2069	conn.remote_addr = addr[0]
1939	2070	conn.remote_port = addr[1]
1940
	2071
1941	2072	conn.ssl_env = ssl_env
1942
	2073
1943	2074	self.requests.put(conn)
1944	2075	except socket.timeout:
1945	2076	# The only reason for the timeout in start() is so we can

1955	2086	# is received during the accept() call; all docs say retry
1956	2087	# the call, and I think I'm reading it right that Python
1957	2088	# will then go ahead and poll for and handle the signal
1958		# elsewhere. See http://www.cherrypy.org/ticket/707.
	2089	# elsewhere. See
	2090	# https://bitbucket.org/cherrypy/cherrypy/issue/707.
1959	2091	return
1960	2092	if x.args[0] in socket_errors_nonblocking:
1961		# Just try again. See http://www.cherrypy.org/ticket/479.
	2093	# Just try again. See
	2094	# https://bitbucket.org/cherrypy/cherrypy/issue/479.
1962	2095	return
1963	2096	if x.args[0] in socket_errors_to_ignore:
1964	2097	# Our socket was closed.
1965		# See http://www.cherrypy.org/ticket/686.
	2098	# See https://bitbucket.org/cherrypy/cherrypy/issue/686.
1966	2099	return
1967	2100	raise
1968
	2101
1969	2102	def _get_interrupt(self):
1970	2103	return self._interrupt
	2104
1971	2105	def _set_interrupt(self, interrupt):
1972	2106	self._interrupt = True
1973	2107	self.stop()

1975	2109	interrupt = property(_get_interrupt, _set_interrupt,
1976	2110	doc="Set this to an Exception instance to "
1977	2111	"interrupt the server.")
1978
	2112
1979	2113	def stop(self):
1980	2114	"""Gracefully shutdown a server that is serving forever."""
1981	2115	self.ready = False
1982	2116	if self._start_time is not None:
1983	2117	self._run_time += (time.time() - self._start_time)
1984	2118	self._start_time = None
1985
	2119
1986	2120	sock = getattr(self, "socket", None)
1987	2121	if sock:
1988	2122	if not isinstance(self.bind_addr, basestring):

1993	2127	x = sys.exc_info()[1]
1994	2128	if x.args[0] not in socket_errors_to_ignore:
1995	2129	# Changed to use error code and not message
1996		# See http://www.cherrypy.org/ticket/860.
	2130	# See
	2131	# https://bitbucket.org/cherrypy/cherrypy/issue/860.
1997	2132	raise
1998	2133	else:
1999	2134	# Note that we're explicitly NOT using AI_PASSIVE,

2006	2141	s = None
2007	2142	try:
2008	2143	s = socket.socket(af, socktype, proto)
2009		# See http://groups.google.com/group/cherrypy-users/
2010		# browse_frm/thread/bbfe5eb39c904fe0
	2144	# See
	2145	# http://groups.google.com/group/cherrypy-users/
	2146	# browse_frm/thread/bbfe5eb39c904fe0
2011	2147	s.settimeout(1.0)
2012	2148	s.connect((host, port))
2013	2149	s.close()

2017	2153	if hasattr(sock, "close"):
2018	2154	sock.close()
2019	2155	self.socket = None
2020
	2156
2021	2157	self.requests.stop(self.shutdown_timeout)
2022	2158
2023	2159
2024	2160	class Gateway(object):
2025		"""A base class to interface HTTPServer with other systems, such as WSGI."""
2026
	2161
	2162	"""A base class to interface HTTPServer with other systems, such as WSGI.
	2163	"""
	2164
2027	2165	def __init__(self, req):
2028	2166	self.req = req
2029
	2167
2030	2168	def respond(self):
2031	2169	"""Process the current request. Must be overridden in a subclass."""
2032	2170	raise NotImplemented

2037	2175	ssl_adapters = {
2038	2176	'builtin': 'cherrypy.wsgiserver.ssl_builtin.BuiltinSSLAdapter',
2039	2177	'pyopenssl': 'cherrypy.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter',
2040		}
	2178	}
	2179
2041	2180
2042	2181	def get_ssl_adapter_class(name='pyopenssl'):
2043	2182	"""Return an SSL adapter class for the given name."""

2046	2185	last_dot = adapter.rfind(".")
2047	2186	attr_name = adapter[last_dot + 1:]
2048	2187	mod_path = adapter[:last_dot]
2049
	2188
2050	2189	try:
2051	2190	mod = sys.modules[mod_path]
2052	2191	if mod is None:

2054	2193	except KeyError:
2055	2194	# The last [''] is important.
2056	2195	mod = __import__(mod_path, globals(), locals(), [''])
2057
	2196
2058	2197	# Let an AttributeError propagate outward.
2059	2198	try:
2060	2199	adapter = getattr(mod, attr_name)
2061	2200	except AttributeError:
2062	2201	raise AttributeError("'%s' object has no attribute '%s'"
2063	2202	% (mod_path, attr_name))
2064
	2203
2065	2204	return adapter
2066	2205
2067		# -------------------------------- WSGI Stuff -------------------------------- #
	2206	# ------------------------------- WSGI Stuff -------------------------------- #
2068	2207
2069	2208
2070	2209	class CherryPyWSGIServer(HTTPServer):
	2210
2071	2211	"""A subclass of HTTPServer which calls a WSGI application."""
2072
	2212
2073	2213	wsgi_version = (1, 0)
2074	2214	"""The version of WSGI to produce."""
2075
	2215
2076	2216	def __init__(self, bind_addr, wsgi_app, numthreads=10, server_name=None,
2077	2217	max=-1, request_queue_size=5, timeout=10, shutdown_timeout=5):
2078	2218	self.requests = ThreadPool(self, min=numthreads or 1, max=max)
2079	2219	self.wsgi_app = wsgi_app
2080	2220	self.gateway = wsgi_gateways[self.wsgi_version]
2081
	2221
2082	2222	self.bind_addr = bind_addr
2083	2223	if not server_name:
2084	2224	server_name = socket.gethostname()
2085	2225	self.server_name = server_name
2086	2226	self.request_queue_size = request_queue_size
2087
	2227
2088	2228	self.timeout = timeout
2089	2229	self.shutdown_timeout = shutdown_timeout
2090	2230	self.clear_stats()
2091
	2231
2092	2232	def _get_numthreads(self):
2093	2233	return self.requests.min
	2234
2094	2235	def _set_numthreads(self, value):
2095	2236	self.requests.min = value
2096	2237	numthreads = property(_get_numthreads, _set_numthreads)
2097	2238
2098	2239
2099	2240	class WSGIGateway(Gateway):
	2241
2100	2242	"""A base class to interface HTTPServer with WSGI."""
2101
	2243
2102	2244	def __init__(self, req):
2103	2245	self.req = req
2104	2246	self.started_response = False
2105	2247	self.env = self.get_environ()
2106	2248	self.remaining_bytes_out = None
2107
	2249
2108	2250	def get_environ(self):
2109	2251	"""Return a new environ dict targeting the given wsgi.version"""
2110	2252	raise NotImplemented
2111
	2253
2112	2254	def respond(self):
2113	2255	"""Process the current request."""
2114	2256	response = self.req.server.wsgi_app(self.env, self.start_response)

2127	2269	finally:
2128	2270	if hasattr(response, "close"):
2129	2271	response.close()
2130
2131		def start_response(self, status, headers, exc_info = None):
	2272
	2273	def start_response(self, status, headers, exc_info=None):
2132	2274	"""WSGI callable to begin the HTTP response."""
2133	2275	# "The application may call start_response more than once,
2134	2276	# if and only if the exc_info argument is provided."

2136	2278	raise AssertionError("WSGI start_response called a second "
2137	2279	"time with no exc_info.")
2138	2280	self.started_response = True
2139
	2281
2140	2282	# "if exc_info is provided, and the HTTP headers have already been
2141	2283	# sent, start_response must raise an error, and should raise the
2142	2284	# exc_info tuple."

2145	2287	raise exc_info[0], exc_info[1], exc_info[2]
2146	2288	finally:
2147	2289	exc_info = None
2148
	2290
2149	2291	self.req.status = status
2150	2292	for k, v in headers:
2151	2293	if not isinstance(k, str):
2152		raise TypeError("WSGI response header key %r is not of type str." % k)
	2294	raise TypeError(
	2295	"WSGI response header key %r is not of type str." % k)
2153	2296	if not isinstance(v, str):
2154		raise TypeError("WSGI response header value %r is not of type str." % v)
	2297	raise TypeError(
	2298	"WSGI response header value %r is not of type str." % v)
2155	2299	if k.lower() == 'content-length':
2156	2300	self.remaining_bytes_out = int(v)
2157	2301	self.req.outheaders.extend(headers)
2158
	2302
2159	2303	return self.write
2160
	2304
2161	2305	def write(self, chunk):
2162	2306	"""WSGI callable to write unbuffered data to the client.
2163
	2307
2164	2308	This method is also used internally by start_response (to write
2165	2309	data from the iterable returned by the WSGI application).
2166	2310	"""
2167	2311	if not self.started_response:
2168	2312	raise AssertionError("WSGI write called before start_response.")
2169
	2313
2170	2314	chunklen = len(chunk)
2171	2315	rbo = self.remaining_bytes_out
2172	2316	if rbo is not None and chunklen > rbo:
2173	2317	if not self.req.sent_headers:
2174	2318	# Whew. We can send a 500 to the client.
2175		self.req.simple_response("500 Internal Server Error",
	2319	self.req.simple_response(
	2320	"500 Internal Server Error",
2176	2321	"The requested resource returned more bytes than the "
2177	2322	"declared Content-Length.")
2178	2323	else:
2179	2324	# Dang. We have probably already sent data. Truncate the chunk
2180	2325	# to fit (so the client doesn't hang) and raise an error later.
2181	2326	chunk = chunk[:rbo]
2182
	2327
2183	2328	if not self.req.sent_headers:
2184	2329	self.req.sent_headers = True
2185	2330	self.req.send_headers()
2186
	2331
2187	2332	self.req.write(chunk)
2188
	2333
2189	2334	if rbo is not None:
2190	2335	rbo -= chunklen
2191	2336	if rbo < 0:

2194	2339
2195	2340
2196	2341	class WSGIGateway_10(WSGIGateway):
	2342
2197	2343	"""A Gateway class to interface HTTPServer with WSGI 1.0.x."""
2198
	2344
2199	2345	def get_environ(self):
2200	2346	"""Return a new environ dict targeting the given wsgi.version"""
2201	2347	req = self.req

2222	2368	'wsgi.run_once': False,
2223	2369	'wsgi.url_scheme': req.scheme,
2224	2370	'wsgi.version': (1, 0),
2225		}
2226
	2371	}
	2372
2227	2373	if isinstance(req.server.bind_addr, basestring):
2228	2374	# AF_UNIX. This isn't really allowed by WSGI, which doesn't
2229	2375	# address unix domain sockets. But it's better than nothing.
2230	2376	env["SERVER_PORT"] = ""
2231	2377	else:
2232	2378	env["SERVER_PORT"] = str(req.server.bind_addr[1])
2233
	2379
2234	2380	# Request headers
2235	2381	for k, v in req.inheaders.iteritems():
2236	2382	env["HTTP_" + k.upper().replace("-", "_")] = v
2237
	2383
2238	2384	# CONTENT_TYPE/CONTENT_LENGTH
2239	2385	ct = env.pop("HTTP_CONTENT_TYPE", None)
2240	2386	if ct is not None:

2242	2388	cl = env.pop("HTTP_CONTENT_LENGTH", None)
2243	2389	if cl is not None:
2244	2390	env["CONTENT_LENGTH"] = cl
2245
	2391
2246	2392	if req.conn.ssl_env:
2247	2393	env.update(req.conn.ssl_env)
2248
	2394
2249	2395	return env
2250	2396
2251	2397
2252	2398	class WSGIGateway_u0(WSGIGateway_10):
	2399
2253	2400	"""A Gateway class to interface HTTPServer with WSGI u.0.
2254
2255		WSGI u.0 is an experimental protocol, which uses unicode for keys and values
2256		in both Python 2 and Python 3.
	2401
	2402	WSGI u.0 is an experimental protocol, which uses unicode for keys and
	2403	values in both Python 2 and Python 3.
2257	2404	"""
2258
	2405
2259	2406	def get_environ(self):
2260	2407	"""Return a new environ dict targeting the given wsgi.version"""
2261	2408	req = self.req
2262	2409	env_10 = WSGIGateway_10.get_environ(self)
2263		env = dict([(k.decode('ISO-8859-1'), v) for k, v in env_10.iteritems()])
	2410	env = dict([(k.decode('ISO-8859-1'), v)
	2411	for k, v in env_10.iteritems()])
2264	2412	env[u'wsgi.version'] = ('u', 0)
2265
	2413
2266	2414	# Request-URI
2267	2415	env.setdefault(u'wsgi.url_encoding', u'utf-8')
2268	2416	try:

2273	2421	env[u'wsgi.url_encoding'] = u'ISO-8859-1'
2274	2422	for key in [u"PATH_INFO", u"SCRIPT_NAME", u"QUERY_STRING"]:
2275	2423	env[key] = env_10[str(key)].decode(env[u'wsgi.url_encoding'])
2276
	2424
2277	2425	for k, v in sorted(env.items()):
2278	2426	if isinstance(v, str) and k not in ('REQUEST_URI', 'wsgi.input'):
2279	2427	env[k] = v.decode('ISO-8859-1')
2280
	2428
2281	2429	return env
2282	2430
2283	2431	wsgi_gateways = {

2285	2433	('u', 0): WSGIGateway_u0,
2286	2434	}
2287	2435
	2436
2288	2437	class WSGIPathInfoDispatcher(object):
	2438
2289	2439	"""A WSGI dispatcher for dispatch based on the PATH_INFO.
2290
	2440
2291	2441	apps: a dict or list of (path_prefix, app) pairs.
2292	2442	"""
2293
	2443
2294	2444	def __init__(self, apps):
2295	2445	try:
2296	2446	apps = list(apps.items())
2297	2447	except AttributeError:
2298	2448	pass
2299
	2449
2300	2450	# Sort the apps by len(path), descending
2301		apps.sort(cmp=lambda x,y: cmp(len(x[0]), len(y[0])))
	2451	apps.sort(cmp=lambda x, y: cmp(len(x[0]), len(y[0])))
2302	2452	apps.reverse()
2303
	2453
2304	2454	# The path_prefix strings must start, but not end, with a slash.
2305	2455	# Use "" instead of "/".
2306	2456	self.apps = [(p.rstrip("/"), a) for p, a in apps]
2307
	2457
2308	2458	def __call__(self, environ, start_response):
2309	2459	path = environ["PATH_INFO"] or "/"
2310	2460	for p, app in self.apps:

2314	2464	environ["SCRIPT_NAME"] = environ["SCRIPT_NAME"] + p
2315	2465	environ["PATH_INFO"] = path[len(p):]
2316	2466	return app(environ, start_response)
2317
	2467
2318	2468	start_response('404 Not Found', [('Content-Type', 'text/plain'),
2319	2469	('Content-Length', '0')])
2320	2470	return ['']
2321

+495

-369

cherrypy/wsgiserver/wsgiserver3.py less more

3	3	(without using CherryPy's application machinery)::
4	4
5	5	from cherrypy import wsgiserver
6
	6
7	7	def my_crazy_app(environ, start_response):
8	8	status = '200 OK'
9	9	response_headers = [('Content-type','text/plain')]
10	10	start_response(status, response_headers)
11	11	return ['Hello world!']
12
	12
13	13	server = wsgiserver.CherryPyWSGIServer(
14	14	('0.0.0.0', 8070), my_crazy_app,
15	15	server_name='www.cherrypy.example')
16	16	server.start()
17
18		The CherryPy WSGI server can serve as many WSGI applications
	17
	18	The CherryPy WSGI server can serve as many WSGI applications
19	19	as you want in one instance by using a WSGIPathInfoDispatcher::
20
	20
21	21	d = WSGIPathInfoDispatcher({'/': my_crazy_app, '/blog': my_blog_app})
22	22	server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', 80), d)
23
	23
24	24	Want SSL support? Just set server.ssl_adapter to an SSLAdapter instance.
25	25
26	26	This won't call the CherryPy engine (application side) at all, only the

85	85	import email.utils
86	86	import socket
87	87	import sys
88		if 'win' in sys.platform and not hasattr(socket, 'IPPROTO_IPV6'):
89		socket.IPPROTO_IPV6 = 41
90		if sys.version_info < (3,1):
	88	if 'win' in sys.platform and hasattr(socket, "AF_INET6"):
	89	if not hasattr(socket, 'IPPROTO_IPV6'):
	90	socket.IPPROTO_IPV6 = 41
	91	if not hasattr(socket, 'IPV6_V6ONLY'):
	92	socket.IPV6_V6ONLY = 27
	93	if sys.version_info < (3, 1):
91	94	import io
92	95	else:
93	96	import _pyio as io

96	99	import threading
97	100	import time
98	101	from traceback import format_exc
99		from urllib.parse import unquote
100		from urllib.parse import urlparse
101		from urllib.parse import scheme_chars
102		import warnings
103	102
104	103	if sys.version_info >= (3, 0):
105	104	bytestr = bytes
106	105	unicodestr = str
107	106	basestring = (bytes, str)
	107
108	108	def ntob(n, encoding='ISO-8859-1'):
109		"""Return the given native string as a byte string in the given encoding."""
	109	"""Return the given native string as a byte string in the given
	110	encoding.
	111	"""
110	112	# In Python 3, the native string type is unicode
111	113	return n.encode(encoding)
112	114	else:
113	115	bytestr = str
114	116	unicodestr = unicode
115	117	basestring = basestring
	118
116	119	def ntob(n, encoding='ISO-8859-1'):
117		"""Return the given native string as a byte string in the given encoding."""
	120	"""Return the given native string as a byte string in the given
	121	encoding.
	122	"""
118	123	# In Python 2, the native string type is bytes. Assume it's already
119	124	# in the given encoding, which for ISO-8859-1 is almost always what
120	125	# was intended.

135	140
136	141	import errno
137	142
	143
138	144	def plat_specific_errors(*errnames):
139	145	"""Return error numbers for all errors in errnames on this platform.
140
	146
141	147	The 'errno' module contains different global constants depending on
142	148	the specific platform (OS). This function will return the list of
143	149	numeric values for a given list of potential names.

159	165	"ECONNABORTED", "WSAECONNABORTED",
160	166	"ENETRESET", "WSAENETRESET",
161	167	"EHOSTDOWN", "EHOSTUNREACH",
162		)
	168	)
163	169	socket_errors_to_ignore.append("timed out")
164	170	socket_errors_to_ignore.append("The read operation timed out")
165	171
166	172	socket_errors_nonblocking = plat_specific_errors(
167	173	'EAGAIN', 'EWOULDBLOCK', 'WSAEWOULDBLOCK')
168	174
169		comma_separated_headers = [ntob(h) for h in
	175	comma_separated_headers = [
	176	ntob(h) for h in
170	177	['Accept', 'Accept-Charset', 'Accept-Encoding',
171	178	'Accept-Language', 'Accept-Ranges', 'Allow', 'Cache-Control',
172	179	'Connection', 'Content-Encoding', 'Content-Language', 'Expect',
173	180	'If-Match', 'If-None-Match', 'Pragma', 'Proxy-Authenticate', 'TE',
174	181	'Trailer', 'Transfer-Encoding', 'Upgrade', 'Vary', 'Via', 'Warning',
175		'WWW-Authenticate']]
	182	'WWW-Authenticate']
	183	]
176	184
177	185
178	186	import logging
179		if not hasattr(logging, 'statistics'): logging.statistics = {}
	187	if not hasattr(logging, 'statistics'):
	188	logging.statistics = {}
180	189
181	190
182	191	def read_headers(rfile, hdict=None):
183	192	"""Read headers from the given stream into the given header dict.
184
	193
185	194	If hdict is None, a new header dict is created. Returns the populated
186	195	header dict.
187
	196
188	197	Headers which are repeated are folded together using a comma if their
189	198	specification so dictates.
190
	199
191	200	This function raises ValueError when the read bytes violate the HTTP spec.
192	201	You should probably return "400 Bad Request" if this happens.
193	202	"""
194	203	if hdict is None:
195	204	hdict = {}
196
	205
197	206	while True:
198	207	line = rfile.readline()
199	208	if not line:
200	209	# No more data--illegal end of headers
201	210	raise ValueError("Illegal end of headers.")
202
	211
203	212	if line == CRLF:
204	213	# Normal end of headers
205	214	break
206	215	if not line.endswith(CRLF):
207	216	raise ValueError("HTTP requires CRLF terminators")
208
	217
209	218	if line[0] in (SPACE, TAB):
210	219	# It's a continuation line.
211	220	v = line.strip()

218	227	k = k.strip().title()
219	228	v = v.strip()
220	229	hname = k
221
	230
222	231	if k in comma_separated_headers:
223	232	existing = hdict.get(hname)
224	233	if existing:
225	234	v = b", ".join((existing, v))
226	235	hdict[hname] = v
227
	236
228	237	return hdict
229	238
230	239
231	240	class MaxSizeExceeded(Exception):
232	241	pass
233	242
	243
234	244	class SizeCheckWrapper(object):
	245
235	246	"""Wraps a file-like object, raising MaxSizeExceeded if too large."""
236
	247
237	248	def __init__(self, rfile, maxlen):
238	249	self.rfile = rfile
239	250	self.maxlen = maxlen
240	251	self.bytes_read = 0
241
	252
242	253	def _check_length(self):
243	254	if self.maxlen and self.bytes_read > self.maxlen:
244	255	raise MaxSizeExceeded()
245
	256
246	257	def read(self, size=None):
247	258	data = self.rfile.read(size)
248	259	self.bytes_read += len(data)
249	260	self._check_length()
250	261	return data
251
	262
252	263	def readline(self, size=None):
253	264	if size is not None:
254	265	data = self.rfile.readline(size)
255	266	self.bytes_read += len(data)
256	267	self._check_length()
257	268	return data
258
	269
259	270	# User didn't specify a size ...
260	271	# We read the line in chunks to make sure it's not a 100MB line !
261	272	res = []

264	275	self.bytes_read += len(data)
265	276	self._check_length()
266	277	res.append(data)
267		# See http://www.cherrypy.org/ticket/421
268		if len(data) < 256 or data[-1:] == "\n":
	278	# See https://bitbucket.org/cherrypy/cherrypy/issue/421
	279	if len(data) < 256 or data[-1:] == LF:
269	280	return EMPTY.join(res)
270
	281
271	282	def readlines(self, sizehint=0):
272	283	# Shamelessly stolen from StringIO
273	284	total = 0

280	291	break
281	292	line = self.readline()
282	293	return lines
283
	294
284	295	def close(self):
285	296	self.rfile.close()
286
	297
287	298	def __iter__(self):
288	299	return self
289
	300
290	301	def __next__(self):
291	302	data = next(self.rfile)
292	303	self.bytes_read += len(data)
293	304	self._check_length()
294	305	return data
295
	306
296	307	def next(self):
297	308	data = self.rfile.next()
298	309	self.bytes_read += len(data)

301	312
302	313
303	314	class KnownLengthRFile(object):
	315
304	316	"""Wraps a file-like object, returning an empty string when exhausted."""
305
	317
306	318	def __init__(self, rfile, content_length):
307	319	self.rfile = rfile
308	320	self.remaining = content_length
309
	321
310	322	def read(self, size=None):
311	323	if self.remaining == 0:
312	324	return b''

314	326	size = self.remaining
315	327	else:
316	328	size = min(size, self.remaining)
317
	329
318	330	data = self.rfile.read(size)
319	331	self.remaining -= len(data)
320	332	return data
321
	333
322	334	def readline(self, size=None):
323	335	if self.remaining == 0:
324	336	return b''

326	338	size = self.remaining
327	339	else:
328	340	size = min(size, self.remaining)
329
	341
330	342	data = self.rfile.readline(size)
331	343	self.remaining -= len(data)
332	344	return data
333
	345
334	346	def readlines(self, sizehint=0):
335	347	# Shamelessly stolen from StringIO
336	348	total = 0

343	355	break
344	356	line = self.readline(sizehint)
345	357	return lines
346
	358
347	359	def close(self):
348	360	self.rfile.close()
349
	361
350	362	def __iter__(self):
351	363	return self
352
	364
353	365	def __next__(self):
354	366	data = next(self.rfile)
355	367	self.remaining -= len(data)

357	369
358	370
359	371	class ChunkedRFile(object):
	372
360	373	"""Wraps a file-like object, returning an empty string when exhausted.
361
	374
362	375	This class is intended to provide a conforming wsgi.input value for
363	376	request entities that have been encoded with the 'chunked' transfer
364	377	encoding.
365	378	"""
366
	379
367	380	def __init__(self, rfile, maxlen, bufsize=8192):
368	381	self.rfile = rfile
369	382	self.maxlen = maxlen

371	384	self.buffer = EMPTY
372	385	self.bufsize = bufsize
373	386	self.closed = False
374
	387
375	388	def _fetch(self):
376	389	if self.closed:
377	390	return
378
	391
379	392	line = self.rfile.readline()
380	393	self.bytes_read += len(line)
381
	394
382	395	if self.maxlen and self.bytes_read > self.maxlen:
383	396	raise MaxSizeExceeded("Request Entity Too Large", self.maxlen)
384
	397
385	398	line = line.strip().split(SEMICOLON, 1)
386
	399
387	400	try:
388	401	chunk_size = line.pop(0)
389	402	chunk_size = int(chunk_size, 16)
390	403	except ValueError:
391	404	raise ValueError("Bad chunked transfer size: " + repr(chunk_size))
392
	405
393	406	if chunk_size <= 0:
394	407	self.closed = True
395	408	return
396
	409
397	410	## if line: chunk_extension = line[0]
398
	411
399	412	if self.maxlen and self.bytes_read + chunk_size > self.maxlen:
400	413	raise IOError("Request Entity Too Large")
401
	414
402	415	chunk = self.rfile.read(chunk_size)
403	416	self.bytes_read += len(chunk)
404	417	self.buffer += chunk
405
	418
406	419	crlf = self.rfile.read(2)
407	420	if crlf != CRLF:
408	421	raise ValueError(
409		"Bad chunked transfer coding (expected '\\r\\n', "
410		"got " + repr(crlf) + ")")
411
	422	"Bad chunked transfer coding (expected '\\r\\n', "
	423	"got " + repr(crlf) + ")")
	424
412	425	def read(self, size=None):
413	426	data = EMPTY
414	427	while True:
415	428	if size and len(data) >= size:
416	429	return data
417
	430
418	431	if not self.buffer:
419	432	self._fetch()
420	433	if not self.buffer:
421	434	# EOF
422	435	return data
423
	436
424	437	if size:
425	438	remaining = size - len(data)
426	439	data += self.buffer[:remaining]
427	440	self.buffer = self.buffer[remaining:]
428	441	else:
429	442	data += self.buffer
430
	443
431	444	def readline(self, size=None):
432	445	data = EMPTY
433	446	while True:
434	447	if size and len(data) >= size:
435	448	return data
436
	449
437	450	if not self.buffer:
438	451	self._fetch()
439	452	if not self.buffer:
440	453	# EOF
441	454	return data
442
	455
443	456	newline_pos = self.buffer.find(LF)
444	457	if size:
445	458	if newline_pos == -1:

456	469	else:
457	470	data += self.buffer[:newline_pos]
458	471	self.buffer = self.buffer[newline_pos:]
459
	472
460	473	def readlines(self, sizehint=0):
461	474	# Shamelessly stolen from StringIO
462	475	total = 0

469	482	break
470	483	line = self.readline(sizehint)
471	484	return lines
472
	485
473	486	def read_trailer_lines(self):
474	487	if not self.closed:
475	488	raise ValueError(
476	489	"Cannot read trailers until the request body has been read.")
477
	490
478	491	while True:
479	492	line = self.rfile.readline()
480	493	if not line:
481	494	# No more data--illegal end of headers
482	495	raise ValueError("Illegal end of headers.")
483
	496
484	497	self.bytes_read += len(line)
485	498	if self.maxlen and self.bytes_read > self.maxlen:
486	499	raise IOError("Request Entity Too Large")
487
	500
488	501	if line == CRLF:
489	502	# Normal end of headers
490	503	break
491	504	if not line.endswith(CRLF):
492	505	raise ValueError("HTTP requires CRLF terminators")
493
	506
494	507	yield line
495
	508
496	509	def close(self):
497	510	self.rfile.close()
498
	511
499	512	def __iter__(self):
500	513	# Shamelessly stolen from StringIO
501	514	total = 0

509	522
510	523
511	524	class HTTPRequest(object):
	525
512	526	"""An HTTP Request (and response).
513
	527
514	528	A single HTTP connection may consist of multiple request/response pairs.
515	529	"""
516
	530
517	531	server = None
518	532	"""The HTTPServer object which is receiving this request."""
519
	533
520	534	conn = None
521	535	"""The HTTPConnection object on which this request connected."""
522
	536
523	537	inheaders = {}
524	538	"""A dict of request headers."""
525
	539
526	540	outheaders = []
527	541	"""A list of header tuples to write in the response."""
528
	542
529	543	ready = False
530	544	"""When True, the request has been parsed and is ready to begin generating
531	545	the response. When False, signals the calling Connection that the response
532	546	should not be generated and the connection should close."""
533
	547
534	548	close_connection = False
535	549	"""Signals the calling Connection that the request should close. This does
536	550	not imply an error! The client and/or server may each request that the
537	551	connection be closed."""
538
	552
539	553	chunked_write = False
540	554	"""If True, output will be encoded with the "chunked" transfer-coding.
541
	555
542	556	This value is set automatically inside send_headers."""
543
	557
544	558	def __init__(self, server, conn):
545		self.server= server
	559	self.server = server
546	560	self.conn = conn
547
	561
548	562	self.ready = False
549	563	self.started_request = False
550	564	self.scheme = ntob("http")

553	567	# Use the lowest-common protocol in case read_request_line errors.
554	568	self.response_protocol = 'HTTP/1.0'
555	569	self.inheaders = {}
556
	570
557	571	self.status = ""
558	572	self.outheaders = []
559	573	self.sent_headers = False
560	574	self.close_connection = self.__class__.close_connection
561	575	self.chunked_read = False
562	576	self.chunked_write = self.__class__.chunked_write
563
	577
564	578	def parse_request(self):
565	579	"""Parse the next HTTP request start-line and message-headers."""
566	580	self.rfile = SizeCheckWrapper(self.conn.rfile,

568	582	try:
569	583	success = self.read_request_line()
570	584	except MaxSizeExceeded:
571		self.simple_response("414 Request-URI Too Long",
	585	self.simple_response(
	586	"414 Request-URI Too Long",
572	587	"The Request-URI sent with the request exceeds the maximum "
573	588	"allowed bytes.")
574	589	return
575	590	else:
576	591	if not success:
577	592	return
578
	593
579	594	try:
580	595	success = self.read_request_headers()
581	596	except MaxSizeExceeded:
582		self.simple_response("413 Request Entity Too Large",
	597	self.simple_response(
	598	"413 Request Entity Too Large",
583	599	"The headers sent with the request exceed the maximum "
584	600	"allowed bytes.")
585	601	return
586	602	else:
587	603	if not success:
588	604	return
589
	605
590	606	self.ready = True
591
	607
592	608	def read_request_line(self):
593	609	# HTTP/1.1 connections are persistent by default. If a client
594	610	# requests a page, then idles (leaves the connection open),

598	614	# (although your TCP stack might suffer for it: cf Apache's history
599	615	# with FIN_WAIT_2).
600	616	request_line = self.rfile.readline()
601
	617
602	618	# Set started_request to True so communicate() knows to send 408
603	619	# from here on out.
604	620	self.started_request = True
605	621	if not request_line:
606	622	return False
607
	623
608	624	if request_line == CRLF:
609	625	# RFC 2616 sec 4.1: "...if the server is reading the protocol
610	626	# stream at the beginning of a message and receives a CRLF

613	629	request_line = self.rfile.readline()
614	630	if not request_line:
615	631	return False
616
	632
617	633	if not request_line.endswith(CRLF):
618		self.simple_response("400 Bad Request", "HTTP requires CRLF terminators")
	634	self.simple_response(
	635	"400 Bad Request", "HTTP requires CRLF terminators")
619	636	return False
620
	637
621	638	try:
622	639	method, uri, req_protocol = request_line.strip().split(SPACE, 2)
623		# The [x:y] slicing is necessary for byte strings to avoid getting ord's
	640	# The [x:y] slicing is necessary for byte strings to avoid getting
	641	# ord's
624	642	rp = int(req_protocol[5:6]), int(req_protocol[7:8])
625	643	except ValueError:
626	644	self.simple_response("400 Bad Request", "Malformed Request-Line")
627	645	return False
628
	646
629	647	self.uri = uri
630	648	self.method = method
631
	649
632	650	# uri may be an abs_path (including "http://host.domain.tld");
633	651	scheme, authority, path = self.parse_request_uri(uri)
634	652	if NUMBER_SIGN in path:
635	653	self.simple_response("400 Bad Request",
636	654	"Illegal #fragment in Request-URI.")
637	655	return False
638
	656
639	657	if scheme:
640	658	self.scheme = scheme
641
	659
642	660	qs = EMPTY
643	661	if QUESTION_MARK in path:
644	662	path, qs = path.split(QUESTION_MARK, 1)
645
	663
646	664	# Unquote the path+params (e.g. "/this%20path" -> "/this path").
647	665	# http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2
648	666	#

658	676	return False
659	677	path = b"%2F".join(atoms)
660	678	self.path = path
661
	679
662	680	# Note that, like wsgiref and most other HTTP servers,
663	681	# we "% HEX HEX"-unquote the path but not the query string.
664	682	self.qs = qs
665
	683
666	684	# Compare request and server HTTP protocol versions, in case our
667	685	# server does not support the requested protocol. Limit our output
668	686	# to min(req, server). We want the following output:

675	693	# Notice that, in (b), the response will be "HTTP/1.1" even though
676	694	# the client only understands 1.0. RFC 2616 10.5.6 says we should
677	695	# only return 505 if the _major_ version is different.
678		# The [x:y] slicing is necessary for byte strings to avoid getting ord's
	696	# The [x:y] slicing is necessary for byte strings to avoid getting
	697	# ord's
679	698	sp = int(self.server.protocol[5:6]), int(self.server.protocol[7:8])
680
	699
681	700	if sp[0] != rp[0]:
682	701	self.simple_response("505 HTTP Version Not Supported")
683	702	return False

688	707
689	708	def read_request_headers(self):
690	709	"""Read self.rfile into self.inheaders. Return success."""
691
	710
692	711	# then all the http headers
693	712	try:
694	713	read_headers(self.rfile, self.inheaders)

696	715	ex = sys.exc_info()[1]
697	716	self.simple_response("400 Bad Request", ex.args[0])
698	717	return False
699
	718
700	719	mrbs = self.server.max_request_body_size
701	720	if mrbs and int(self.inheaders.get(b"Content-Length", 0)) > mrbs:
702		self.simple_response("413 Request Entity Too Large",
	721	self.simple_response(
	722	"413 Request Entity Too Large",
703	723	"The entity sent with the request exceeds the maximum "
704	724	"allowed bytes.")
705	725	return False
706
	726
707	727	# Persistent connection support
708	728	if self.response_protocol == "HTTP/1.1":
709	729	# Both server and client are HTTP/1.1

713	733	# Either the server or client (or both) are HTTP/1.0
714	734	if self.inheaders.get(b"Connection", b"") != b"Keep-Alive":
715	735	self.close_connection = True
716
	736
717	737	# Transfer-Encoding support
718	738	te = None
719	739	if self.response_protocol == "HTTP/1.1":
720	740	te = self.inheaders.get(b"Transfer-Encoding")
721	741	if te:
722	742	te = [x.strip().lower() for x in te.split(b",") if x.strip()]
723
	743
724	744	self.chunked_read = False
725
	745
726	746	if te:
727	747	for enc in te:
728	748	if enc == b"chunked":

733	753	self.simple_response("501 Unimplemented")
734	754	self.close_connection = True
735	755	return False
736
	756
737	757	# From PEP 333:
738	758	# "Servers and gateways that implement HTTP 1.1 must provide
739	759	# transparent support for HTTP 1.1's "expect/continue" mechanism.

753	773	# but it seems like it would be a big slowdown for such a rare case.
754	774	if self.inheaders.get(b"Expect", b"") == b"100-continue":
755	775	# Don't use simple_response here, because it emits headers
756		# we don't want. See http://www.cherrypy.org/ticket/951
757		msg = self.server.protocol.encode('ascii') + b" 100 Continue\r\n\r\n"
	776	# we don't want. See
	777	# https://bitbucket.org/cherrypy/cherrypy/issue/951
	778	msg = self.server.protocol.encode(
	779	'ascii') + b" 100 Continue\r\n\r\n"
758	780	try:
759	781	self.conn.wfile.write(msg)
760	782	except socket.error:

762	784	if x.args[0] not in socket_errors_to_ignore:
763	785	raise
764	786	return True
765
	787
766	788	def parse_request_uri(self, uri):
767	789	"""Parse a Request-URI into (scheme, authority, path).
768
	790
769	791	Note that Request-URI's must be one of::
770
	792
771	793	Request-URI = "*" \| absoluteURI \| abs_path \| authority
772
	794
773	795	Therefore, a Request-URI which starts with a double forward-slash
774	796	cannot be a "net_path"::
775
	797
776	798	net_path = "//" authority [ abs_path ]
777
	799
778	800	Instead, it must be interpreted as an "abs_path" with an empty first
779	801	path segment::
780
	802
781	803	abs_path = "/" path_segments
782	804	path_segments = segment *( "/" segment )
783	805	segment = pchar ( ";" param )

790	812	if sep and QUESTION_MARK not in scheme:
791	813	# An absoluteURI.
792	814	# If there's a scheme (and it must be http or https), then:
793		# http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
	815	# http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query
	816	# ]]
794	817	authority, path_a, path_b = remainder.partition(FORWARD_SLASH)
795		return scheme.lower(), authority, path_a+path_b
	818	return scheme.lower(), authority, path_a + path_b
796	819
797	820	if uri.startswith(FORWARD_SLASH):
798	821	# An abs_path.

800	823	else:
801	824	# An authority.
802	825	return None, uri, None
803
	826
804	827	def unquote_bytes(self, path):
805		"""takes quoted string and unquotes % encoded values"""
	828	"""takes quoted string and unquotes % encoded values"""
806	829	res = path.split(b'%')
807
	830
808	831	for i in range(1, len(res)):
809	832	item = res[i]
810	833	try:

812	835	except ValueError:
813	836	raise
814	837	return b''.join(res)
815
	838
816	839	def respond(self):
817	840	"""Call the gateway and write its iterable output."""
818	841	mrbs = self.server.max_request_body_size

822	845	cl = int(self.inheaders.get(b"Content-Length", 0))
823	846	if mrbs and mrbs < cl:
824	847	if not self.sent_headers:
825		self.simple_response("413 Request Entity Too Large",
826		"The entity sent with the request exceeds the maximum "
827		"allowed bytes.")
	848	self.simple_response(
	849	"413 Request Entity Too Large",
	850	"The entity sent with the request exceeds the "
	851	"maximum allowed bytes.")
828	852	return
829	853	self.rfile = KnownLengthRFile(self.conn.rfile, cl)
830
	854
831	855	self.server.gateway(self).respond()
832
	856
833	857	if (self.ready and not self.sent_headers):
834	858	self.sent_headers = True
835	859	self.send_headers()
836	860	if self.chunked_write:
837	861	self.conn.wfile.write(b"0\r\n\r\n")
838
	862
839	863	def simple_response(self, status, msg=""):
840	864	"""Write a simple response back to the client."""
841	865	status = str(status)

843	867	bytes(status, "ISO-8859-1") + CRLF,
844	868	bytes("Content-Length: %s\r\n" % len(msg), "ISO-8859-1"),
845	869	b"Content-Type: text/plain\r\n"]
846
	870
847	871	if status[:3] in ("413", "414"):
848	872	# Request Entity Too Large / Request-URI Too Long
849	873	self.close_connection = True

856	880	# HTTP/1.0 had no 413/414 status nor Connection header.
857	881	# Emit 400 instead and trust the message body is enough.
858	882	status = "400 Bad Request"
859
	883
860	884	buf.append(CRLF)
861	885	if msg:
862	886	if isinstance(msg, unicodestr):
863	887	msg = msg.encode("ISO-8859-1")
864	888	buf.append(msg)
865
	889
866	890	try:
867	891	self.conn.wfile.write(b"".join(buf))
868	892	except socket.error:
869	893	x = sys.exc_info()[1]
870	894	if x.args[0] not in socket_errors_to_ignore:
871	895	raise
872
	896
873	897	def write(self, chunk):
874	898	"""Write unbuffered data to the client."""
875	899	if self.chunked_write and chunk:

877	901	self.conn.wfile.write(EMPTY.join(buf))
878	902	else:
879	903	self.conn.wfile.write(chunk)
880
	904
881	905	def send_headers(self):
882	906	"""Assert, process, and send the HTTP response message-headers.
883
	907
884	908	You must set self.status, and self.outheaders before calling this.
885	909	"""
886	910	hkeys = [key.lower() for key, value in self.outheaders]
887	911	status = int(self.status[:3])
888
	912
889	913	if status == 413:
890	914	# Request Entity Too Large. Close conn to avoid garbage.
891	915	self.close_connection = True

897	921	pass
898	922	else:
899	923	if (self.response_protocol == 'HTTP/1.1'
900		and self.method != b'HEAD'):
	924	and self.method != b'HEAD'):
901	925	# Use the chunked transfer-coding
902	926	self.chunked_write = True
903	927	self.outheaders.append((b"Transfer-Encoding", b"chunked"))
904	928	else:
905	929	# Closing the conn is the only way to determine len.
906	930	self.close_connection = True
907
	931
908	932	if b"connection" not in hkeys:
909	933	if self.response_protocol == 'HTTP/1.1':
910	934	# Both server and client are HTTP/1.1 or better

914	938	# Server and/or client are HTTP/1.0
915	939	if not self.close_connection:
916	940	self.outheaders.append((b"Connection", b"Keep-Alive"))
917
	941
918	942	if (not self.close_connection) and (not self.chunked_read):
919	943	# Read any remaining request body data on the socket.
920	944	# "If an origin server receives a request that does not include an

931	955	remaining = getattr(self.rfile, 'remaining', 0)
932	956	if remaining > 0:
933	957	self.rfile.read(remaining)
934
	958
935	959	if b"date" not in hkeys:
936		self.outheaders.append(
937		(b"Date", email.utils.formatdate(usegmt=True).encode('ISO-8859-1')))
938
	960	self.outheaders.append((
	961	b"Date",
	962	email.utils.formatdate(usegmt=True).encode('ISO-8859-1')
	963	))
	964
939	965	if b"server" not in hkeys:
940	966	self.outheaders.append(
941	967	(b"Server", self.server.server_name.encode('ISO-8859-1')))
942
943		buf = [self.server.protocol.encode('ascii') + SPACE + self.status + CRLF]
	968
	969	buf = [self.server.protocol.encode(
	970	'ascii') + SPACE + self.status + CRLF]
944	971	for k, v in self.outheaders:
945	972	buf.append(k + COLON + SPACE + v + CRLF)
946	973	buf.append(CRLF)

948	975
949	976
950	977	class NoSSLError(Exception):
	978
951	979	"""Exception raised when a client speaks HTTP to an HTTPS socket."""
952	980	pass
953	981
954	982
955	983	class FatalSSLAlert(Exception):
	984
956	985	"""Exception raised when the SSL implementation signals a fatal alert."""
957	986	pass
958	987
959	988
960	989	class CP_BufferedWriter(io.BufferedWriter):
	990
961	991	"""Faux file object attached to a socket object."""
962	992
963	993	def write(self, b):
964	994	self._checkClosed()
965	995	if isinstance(b, str):
966	996	raise TypeError("can't write str to binary stream")
967
	997
968	998	with self._write_lock:
969	999	self._write_buf.extend(b)
970	1000	self._flush_unlocked()
971	1001	return len(b)
972
	1002
973	1003	def _flush_unlocked(self):
974	1004	self._checkClosed("flush of closed file")
975	1005	while self._write_buf:

988	1018	else:
989	1019	return CP_BufferedWriter(socket.SocketIO(sock, mode), bufsize)
990	1020
	1021
991	1022	class HTTPConnection(object):
	1023
992	1024	"""An HTTP connection (active socket).
993
	1025
994	1026	server: the Server object which received this connection.
995	1027	socket: the raw socket object (usually TCP) for this connection.
996	1028	makefile: a fileobject class for reading from the socket.
997	1029	"""
998
	1030
999	1031	remote_addr = None
1000	1032	remote_port = None
1001	1033	ssl_env = None
1002	1034	rbufsize = DEFAULT_BUFFER_SIZE
1003	1035	wbufsize = DEFAULT_BUFFER_SIZE
1004	1036	RequestHandlerClass = HTTPRequest
1005
	1037
1006	1038	def __init__(self, server, sock, makefile=CP_makefile):
1007	1039	self.server = server
1008	1040	self.socket = sock
1009	1041	self.rfile = makefile(sock, "rb", self.rbufsize)
1010	1042	self.wfile = makefile(sock, "wb", self.wbufsize)
1011	1043	self.requests_seen = 0
1012
	1044
1013	1045	def communicate(self):
1014	1046	"""Read each request and respond appropriately."""
1015	1047	request_seen = False

1020	1052	# get written to the previous request.
1021	1053	req = None
1022	1054	req = self.RequestHandlerClass(self.server, self)
1023
	1055
1024	1056	# This order of operations should guarantee correct pipelining.
1025	1057	req.parse_request()
1026	1058	if self.server.stats['Enabled']:

1030	1062	# probably already made a simple_response). Return and
1031	1063	# let the conn close.
1032	1064	return
1033
	1065
1034	1066	request_seen = True
1035	1067	req.respond()
1036	1068	if req.close_connection:

1039	1071	e = sys.exc_info()[1]
1040	1072	errnum = e.args[0]
1041	1073	# sadly SSL sockets return a different (longer) time out string
1042		if errnum == 'timed out' or errnum == 'The read operation timed out':
	1074	if (
	1075	errnum == 'timed out' or
	1076	errnum == 'The read operation timed out'
	1077	):
1043	1078	# Don't error if we're between requests; only error
1044	1079	# if 1) no request has been started at all, or 2) we're
1045	1080	# in the middle of a request.
1046		# See http://www.cherrypy.org/ticket/853
	1081	# See https://bitbucket.org/cherrypy/cherrypy/issue/853
1047	1082	if (not request_seen) or (req and req.started_request):
1048	1083	# Don't bother writing the 408 if the response
1049	1084	# has already started being written.

1071	1106	except NoSSLError:
1072	1107	if req and not req.sent_headers:
1073	1108	# Unwrap our wfile
1074		self.wfile = CP_makefile(self.socket._sock, "wb", self.wbufsize)
1075		req.simple_response("400 Bad Request",
1076		"The client sent a plain HTTP request, but "
1077		"this server only speaks HTTPS on this port.")
	1109	self.wfile = CP_makefile(
	1110	self.socket._sock, "wb", self.wbufsize)
	1111	req.simple_response(
	1112	"400 Bad Request",
	1113	"The client sent a plain HTTP request, but this server "
	1114	"only speaks HTTPS on this port.")
1078	1115	self.linger = True
1079	1116	except Exception:
1080	1117	e = sys.exc_info()[1]

1085	1122	except FatalSSLAlert:
1086	1123	# Close the connection.
1087	1124	return
1088
	1125
1089	1126	linger = False
1090
	1127
1091	1128	def close(self):
1092	1129	"""Close the socket underlying this connection."""
1093	1130	self.rfile.close()
1094
	1131
1095	1132	if not self.linger:
1096		# Python's socket module does NOT call close on the kernel socket
1097		# when you call socket.close(). We do so manually here because we
1098		# want this server to send a FIN TCP segment immediately. Note this
1099		# must be called before calling socket.close(), because the latter
1100		# drops its reference to the kernel socket.
1101		# Python 3 probably fixed this with socket._real_close; hard to tell.
1102		## self.socket._sock.close()
	1133	# Python's socket module does NOT call close on the kernel
	1134	# socket when you call socket.close(). We do so manually here
	1135	# because we want this server to send a FIN TCP segment
	1136	# immediately. Note this must be called before calling
	1137	# socket.close(), because the latter drops its reference to
	1138	# the kernel socket.
	1139	# Python 3 probably fixed this with socket._real_close;
	1140	# hard to tell.
	1141	# self.socket._sock.close()
1103	1142	self.socket.close()
1104	1143	else:
1105	1144	# On the other hand, sometimes we want to hang around for a bit

1112	1151
1113	1152
1114	1153	class TrueyZero(object):
1115		"""An object which equals and does math like the integer '0' but evals True."""
	1154
	1155	"""An object which equals and does math like the integer 0 but evals True.
	1156	"""
	1157
1116	1158	def __add__(self, other):
1117	1159	return other
	1160
1118	1161	def __radd__(self, other):
1119	1162	return other
1120	1163	trueyzero = TrueyZero()

1122	1165
1123	1166	_SHUTDOWNREQUEST = None
1124	1167
	1168
1125	1169	class WorkerThread(threading.Thread):
	1170
1126	1171	"""Thread which continuously polls a Queue for Connection objects.
1127
	1172
1128	1173	Due to the timing issues of polling a Queue, a WorkerThread does not
1129	1174	check its own 'ready' flag after it has started. To stop the thread,
1130	1175	it is necessary to stick a _SHUTDOWNREQUEST object onto the Queue
1131	1176	(one for each running WorkerThread).
1132	1177	"""
1133
	1178
1134	1179	conn = None
1135	1180	"""The current connection pulled off the Queue, or None."""
1136
	1181
1137	1182	server = None
1138	1183	"""The HTTP Server which spawned this thread, and which owns the
1139	1184	Queue and is placing active connections into it."""
1140
	1185
1141	1186	ready = False
1142	1187	"""A simple flag for the calling server to know when this thread
1143	1188	has begun polling the Queue."""
1144
1145
	1189
1146	1190	def __init__(self, server):
1147	1191	self.ready = False
1148	1192	self.server = server
1149
	1193
1150	1194	self.requests_seen = 0
1151	1195	self.bytes_read = 0
1152	1196	self.bytes_written = 0
1153	1197	self.start_time = None
1154	1198	self.work_time = 0
1155	1199	self.stats = {
1156		'Requests': lambda s: self.requests_seen + ((self.start_time is None) and trueyzero or self.conn.requests_seen),
1157		'Bytes Read': lambda s: self.bytes_read + ((self.start_time is None) and trueyzero or self.conn.rfile.bytes_read),
1158		'Bytes Written': lambda s: self.bytes_written + ((self.start_time is None) and trueyzero or self.conn.wfile.bytes_written),
1159		'Work Time': lambda s: self.work_time + ((self.start_time is None) and trueyzero or time.time() - self.start_time),
1160		'Read Throughput': lambda s: s['Bytes Read'](s) / (s['Work Time'](s) or 1e-6),
1161		'Write Throughput': lambda s: s['Bytes Written'](s) / (s['Work Time'](s) or 1e-6),
	1200	'Requests': lambda s: self.requests_seen + (
	1201	(self.start_time is None) and
	1202	trueyzero or
	1203	self.conn.requests_seen
	1204	),
	1205	'Bytes Read': lambda s: self.bytes_read + (
	1206	(self.start_time is None) and
	1207	trueyzero or
	1208	self.conn.rfile.bytes_read
	1209	),
	1210	'Bytes Written': lambda s: self.bytes_written + (
	1211	(self.start_time is None) and
	1212	trueyzero or
	1213	self.conn.wfile.bytes_written
	1214	),
	1215	'Work Time': lambda s: self.work_time + (
	1216	(self.start_time is None) and
	1217	trueyzero or
	1218	time.time() - self.start_time
	1219	),
	1220	'Read Throughput': lambda s: s['Bytes Read'](s) / (
	1221	s['Work Time'](s) or 1e-6),
	1222	'Write Throughput': lambda s: s['Bytes Written'](s) / (
	1223	s['Work Time'](s) or 1e-6),
1162	1224	}
1163	1225	threading.Thread.__init__(self)
1164
	1226
1165	1227	def run(self):
1166	1228	self.server.stats['Worker Threads'][self.getName()] = self.stats
1167	1229	try:

1170	1232	conn = self.server.requests.get()
1171	1233	if conn is _SHUTDOWNREQUEST:
1172	1234	return
1173
	1235
1174	1236	self.conn = conn
1175	1237	if self.server.stats['Enabled']:
1176	1238	self.start_time = time.time()

1191	1253
1192	1254
1193	1255	class ThreadPool(object):
	1256
1194	1257	"""A Request Queue for an HTTPServer which pools threads.
1195
	1258
1196	1259	ThreadPool objects must provide min, get(), put(obj), start()
1197	1260	and stop(timeout) attributes.
1198	1261	"""
1199
	1262
1200	1263	def __init__(self, server, min=10, max=-1):
1201	1264	self.server = server
1202	1265	self.min = min

1204	1267	self._threads = []
1205	1268	self._queue = queue.Queue()
1206	1269	self.get = self._queue.get
1207
	1270
1208	1271	def start(self):
1209	1272	"""Start the pool of threads."""
1210	1273	for i in range(self.min):

1215	1278	for worker in self._threads:
1216	1279	while not worker.ready:
1217	1280	time.sleep(.1)
1218
	1281
1219	1282	def _get_idle(self):
1220	1283	"""Number of worker threads which are idle. Read-only."""
1221	1284	return len([t for t in self._threads if t.conn is None])
1222	1285	idle = property(_get_idle, doc=_get_idle.__doc__)
1223
	1286
1224	1287	def put(self, obj):
1225	1288	self._queue.put(obj)
1226	1289	if obj is _SHUTDOWNREQUEST:
1227	1290	return
1228
	1291
1229	1292	def grow(self, amount):
1230	1293	"""Spawn new worker threads (not above self.max)."""
1231		for i in range(amount):
1232		if self.max > 0 and len(self._threads) >= self.max:
1233		break
1234		worker = WorkerThread(self.server)
1235		worker.setName("CP Server " + worker.getName())
1236		self._threads.append(worker)
1237		worker.start()
1238
	1294	if self.max > 0:
	1295	budget = max(self.max - len(self._threads), 0)
	1296	else:
	1297	# self.max <= 0 indicates no maximum
	1298	budget = float('inf')
	1299
	1300	n_new = min(amount, budget)
	1301
	1302	workers = [self._spawn_worker() for i in range(n_new)]
	1303	while not all(worker.ready for worker in workers):
	1304	time.sleep(.1)
	1305	self._threads.extend(workers)
	1306
	1307	def _spawn_worker(self):
	1308	worker = WorkerThread(self.server)
	1309	worker.setName("CP Server " + worker.getName())
	1310	worker.start()
	1311	return worker
	1312
1239	1313	def shrink(self, amount):
1240	1314	"""Kill off worker threads (not below self.min)."""
1241	1315	# Grow/shrink the pool if necessary.

1244	1318	if not t.isAlive():
1245	1319	self._threads.remove(t)
1246	1320	amount -= 1
1247
1248		if amount > 0:
1249		for i in range(min(amount, len(self._threads) - self.min)):
1250		# Put a number of shutdown requests on the queue equal
1251		# to 'amount'. Once each of those is processed by a worker,
1252		# that worker will terminate and be culled from our list
1253		# in self.put.
1254		self._queue.put(_SHUTDOWNREQUEST)
1255
	1321
	1322	# calculate the number of threads above the minimum
	1323	n_extra = max(len(self._threads) - self.min, 0)
	1324
	1325	# don't remove more than amount
	1326	n_to_remove = min(amount, n_extra)
	1327
	1328	# put shutdown requests on the queue equal to the number of threads
	1329	# to remove. As each request is processed by a worker, that worker
	1330	# will terminate and be culled from the list.
	1331	for n in range(n_to_remove):
	1332	self._queue.put(_SHUTDOWNREQUEST)
	1333
1256	1334	def stop(self, timeout=5):
1257	1335	# Must shut down threads here so the code that calls
1258	1336	# this method can know when all threads are stopped.
1259	1337	for worker in self._threads:
1260	1338	self._queue.put(_SHUTDOWNREQUEST)
1261
	1339
1262	1340	# Don't join currentThread (when stop is called inside a request).
1263	1341	current = threading.currentThread()
1264	1342	if timeout and timeout >= 0:

1286	1364	worker.join()
1287	1365	except (AssertionError,
1288	1366	# Ignore repeated Ctrl-C.
1289		# See http://www.cherrypy.org/ticket/691.
	1367	# See
	1368	# https://bitbucket.org/cherrypy/cherrypy/issue/691.
1290	1369	KeyboardInterrupt):
1291	1370	pass
1292
	1371
1293	1372	def _get_qsize(self):
1294	1373	return self._queue.qsize()
1295	1374	qsize = property(_get_qsize)
1296
1297	1375
1298	1376
1299	1377	try:

1301	1379	except ImportError:
1302	1380	try:
1303	1381	from ctypes import windll, WinError
	1382	import ctypes.wintypes
	1383	_SetHandleInformation = windll.kernel32.SetHandleInformation
	1384	_SetHandleInformation.argtypes = [
	1385	ctypes.wintypes.HANDLE,
	1386	ctypes.wintypes.DWORD,
	1387	ctypes.wintypes.DWORD,
	1388	]
	1389	_SetHandleInformation.restype = ctypes.wintypes.BOOL
1304	1390	except ImportError:
1305	1391	def prevent_socket_inheritance(sock):
1306	1392	"""Dummy function, since neither fcntl nor ctypes are available."""

1308	1394	else:
1309	1395	def prevent_socket_inheritance(sock):
1310	1396	"""Mark the given socket fd as non-inheritable (Windows)."""
1311		if not windll.kernel32.SetHandleInformation(sock.fileno(), 1, 0):
	1397	if not _SetHandleInformation(sock.fileno(), 1, 0):
1312	1398	raise WinError()
1313	1399	else:
1314	1400	def prevent_socket_inheritance(sock):

1319	1405
1320	1406
1321	1407	class SSLAdapter(object):
	1408
1322	1409	"""Base class for SSL driver library adapters.
1323
	1410
1324	1411	Required methods:
1325
	1412
1326	1413	* ``wrap(sock) -> (wrapped socket, ssl environ dict)``
1327		* ``makefile(sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE) -> socket file object``
	1414	* ``makefile(sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE) ->
	1415	socket file object``
1328	1416	"""
1329
	1417
1330	1418	def __init__(self, certificate, private_key, certificate_chain=None):
1331	1419	self.certificate = certificate
1332	1420	self.private_key = private_key
1333	1421	self.certificate_chain = certificate_chain
1334
	1422
1335	1423	def wrap(self, sock):
1336	1424	raise NotImplemented
1337
	1425
1338	1426	def makefile(self, sock, mode='r', bufsize=DEFAULT_BUFFER_SIZE):
1339	1427	raise NotImplemented
1340	1428
1341	1429
1342	1430	class HTTPServer(object):
	1431
1343	1432	"""An HTTP server."""
1344
	1433
1345	1434	_bind_addr = "127.0.0.1"
1346	1435	_interrupt = None
1347
	1436
1348	1437	gateway = None
1349	1438	"""A Gateway instance."""
1350
	1439
1351	1440	minthreads = None
1352	1441	"""The minimum number of worker threads to create (default 10)."""
1353
	1442
1354	1443	maxthreads = None
1355		"""The maximum number of worker threads to create (default -1 = no limit)."""
1356
	1444	"""The maximum number of worker threads to create (default -1 = no limit).
	1445	"""
	1446
1357	1447	server_name = None
1358	1448	"""The name of the server; defaults to socket.gethostname()."""
1359
	1449
1360	1450	protocol = "HTTP/1.1"
1361	1451	"""The version string to write in the Status-Line of all HTTP responses.
1362
	1452
1363	1453	For example, "HTTP/1.1" is the default. This also limits the supported
1364	1454	features used in the response."""
1365
	1455
1366	1456	request_queue_size = 5
1367		"""The 'backlog' arg to socket.listen(); max queued connections (default 5)."""
1368
	1457	"""The 'backlog' arg to socket.listen(); max queued connections
	1458	(default 5).
	1459	"""
	1460
1369	1461	shutdown_timeout = 5
1370		"""The total time, in seconds, to wait for worker threads to cleanly exit."""
1371
	1462	"""The total time, in seconds, to wait for worker threads to cleanly exit.
	1463	"""
	1464
1372	1465	timeout = 10
1373	1466	"""The timeout in seconds for accepted connections (default 10)."""
1374
1375		version = "CherryPy/3.2.2"
	1467
	1468	version = "CherryPy/3.3.0"
1376	1469	"""A version string for the HTTPServer."""
1377
	1470
1378	1471	software = None
1379	1472	"""The value to set for the SERVER_SOFTWARE entry in the WSGI environ.
1380
	1473
1381	1474	If None, this defaults to ``'%s Server' % self.version``."""
1382
	1475
1383	1476	ready = False
1384		"""An internal flag which marks whether the socket is accepting connections."""
1385
	1477	"""An internal flag which marks whether the socket is accepting
	1478	connections.
	1479	"""
	1480
1386	1481	max_request_header_size = 0
1387	1482	"""The maximum size, in bytes, for request headers, or 0 for no limit."""
1388
	1483
1389	1484	max_request_body_size = 0
1390	1485	"""The maximum size, in bytes, for request bodies, or 0 for no limit."""
1391
	1486
1392	1487	nodelay = True
1393	1488	"""If True (the default since 3.1), sets the TCP_NODELAY socket option."""
1394
	1489
1395	1490	ConnectionClass = HTTPConnection
1396	1491	"""The class to use for handling HTTP connections."""
1397
	1492
1398	1493	ssl_adapter = None
1399	1494	"""An instance of SSLAdapter (or a subclass).
1400
	1495
1401	1496	You must have the corresponding SSL driver library installed."""
1402
	1497
1403	1498	def __init__(self, bind_addr, gateway, minthreads=10, maxthreads=-1,
1404	1499	server_name=None):
1405	1500	self.bind_addr = bind_addr
1406	1501	self.gateway = gateway
1407
	1502
1408	1503	self.requests = ThreadPool(self, min=minthreads or 1, max=maxthreads)
1409
	1504
1410	1505	if not server_name:
1411	1506	server_name = socket.gethostname()
1412	1507	self.server_name = server_name
1413	1508	self.clear_stats()
1414
	1509
1415	1510	def clear_stats(self):
1416	1511	self._start_time = None
1417	1512	self._run_time = 0

1425	1520	'Threads': lambda s: len(getattr(self.requests, "_threads", [])),
1426	1521	'Threads Idle': lambda s: getattr(self.requests, "idle", None),
1427	1522	'Socket Errors': 0,
1428		'Requests': lambda s: (not s['Enabled']) and -1 or sum([w['Requests'](w) for w
1429		in s['Worker Threads'].values()], 0),
1430		'Bytes Read': lambda s: (not s['Enabled']) and -1 or sum([w['Bytes Read'](w) for w
1431		in s['Worker Threads'].values()], 0),
1432		'Bytes Written': lambda s: (not s['Enabled']) and -1 or sum([w['Bytes Written'](w) for w
1433		in s['Worker Threads'].values()], 0),
1434		'Work Time': lambda s: (not s['Enabled']) and -1 or sum([w['Work Time'](w) for w
1435		in s['Worker Threads'].values()], 0),
	1523	'Requests': lambda s: (not s['Enabled']) and -1 or sum(
	1524	[w['Requests'](w) for w in s['Worker Threads'].values()], 0),
	1525	'Bytes Read': lambda s: (not s['Enabled']) and -1 or sum(
	1526	[w['Bytes Read'](w) for w in s['Worker Threads'].values()], 0),
	1527	'Bytes Written': lambda s: (not s['Enabled']) and -1 or sum(
	1528	[w['Bytes Written'](w) for w in s['Worker Threads'].values()],
	1529	0),
	1530	'Work Time': lambda s: (not s['Enabled']) and -1 or sum(
	1531	[w['Work Time'](w) for w in s['Worker Threads'].values()], 0),
1436	1532	'Read Throughput': lambda s: (not s['Enabled']) and -1 or sum(
1437	1533	[w['Bytes Read'](w) / (w['Work Time'](w) or 1e-6)
1438	1534	for w in s['Worker Threads'].values()], 0),

1440	1536	[w['Bytes Written'](w) / (w['Work Time'](w) or 1e-6)
1441	1537	for w in s['Worker Threads'].values()], 0),
1442	1538	'Worker Threads': {},
1443		}
	1539	}
1444	1540	logging.statistics["CherryPy HTTPServer %d" % id(self)] = self.stats
1445
	1541
1446	1542	def runtime(self):
1447	1543	if self._start_time is None:
1448	1544	return self._run_time
1449	1545	else:
1450	1546	return self._run_time + (time.time() - self._start_time)
1451
	1547
1452	1548	def __str__(self):
1453	1549	return "%s.%s(%r)" % (self.__module__, self.__class__.__name__,
1454	1550	self.bind_addr)
1455
	1551
1456	1552	def _get_bind_addr(self):
1457	1553	return self._bind_addr
	1554
1458	1555	def _set_bind_addr(self, value):
1459	1556	if isinstance(value, tuple) and value[0] in ('', None):
1460	1557	# Despite the socket module docs, using '' does not

1471	1568	"Use '0.0.0.0' (IPv4) or '::' (IPv6) instead "
1472	1569	"to listen on all active interfaces.")
1473	1570	self._bind_addr = value
1474		bind_addr = property(_get_bind_addr, _set_bind_addr,
	1571	bind_addr = property(
	1572	_get_bind_addr,
	1573	_set_bind_addr,
1475	1574	doc="""The interface on which to listen for connections.
1476
	1575
1477	1576	For TCP sockets, a (host, port) tuple. Host values may be any IPv4
1478	1577	or IPv6 address, or any valid hostname. The string 'localhost' is a
1479	1578	synonym for '127.0.0.1' (or '::1', if your hosts file prefers IPv6).
1480	1579	The string '0.0.0.0' is a special IPv4 entry meaning "any active
1481	1580	interface" (INADDR_ANY), and '::' is the similar IN6ADDR_ANY for
1482	1581	IPv6. The empty string or None are not allowed.
1483
	1582
1484	1583	For UNIX sockets, supply the filename as a string.""")
1485
	1584
1486	1585	def start(self):
1487	1586	"""Run the server forever."""
1488	1587	# We don't have to trap KeyboardInterrupt or SystemExit here,

1490	1589	# If you're using this server with another framework, you should
1491	1590	# trap those exceptions in whatever code block calls start().
1492	1591	self._interrupt = None
1493
	1592
1494	1593	if self.software is None:
1495	1594	self.software = "%s Server" % self.version
1496
	1595
1497	1596	# Select the appropriate socket
1498	1597	if isinstance(self.bind_addr, basestring):
1499	1598	# AF_UNIX socket
1500
	1599
1501	1600	# So we can reuse the socket...
1502		try: os.unlink(self.bind_addr)
1503		except: pass
1504
	1601	try:
	1602	os.unlink(self.bind_addr)
	1603	except:
	1604	pass
	1605
1505	1606	# So everyone can access the socket...
1506		try: os.chmod(self.bind_addr, 511) # 0777
1507		except: pass
1508
1509		info = [(socket.AF_UNIX, socket.SOCK_STREAM, 0, "", self.bind_addr)]
	1607	try:
	1608	os.chmod(self.bind_addr, 511) # 0777
	1609	except:
	1610	pass
	1611
	1612	info = [
	1613	(socket.AF_UNIX, socket.SOCK_STREAM, 0, "", self.bind_addr)]
1510	1614	else:
1511	1615	# AF_INET or AF_INET6 socket
1512		# Get the correct address family for our host (allows IPv6 addresses)
	1616	# Get the correct address family for our host (allows IPv6
	1617	# addresses)
1513	1618	host, port = self.bind_addr
1514	1619	try:
1515	1620	info = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
1516		socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
	1621	socket.SOCK_STREAM, 0,
	1622	socket.AI_PASSIVE)
1517	1623	except socket.gaierror:
1518	1624	if ':' in self.bind_addr[0]:
1519	1625	info = [(socket.AF_INET6, socket.SOCK_STREAM,

1521	1627	else:
1522	1628	info = [(socket.AF_INET, socket.SOCK_STREAM,
1523	1629	0, "", self.bind_addr)]
1524
	1630
1525	1631	self.socket = None
1526	1632	msg = "No socket could be created"
1527	1633	for res in info:
1528	1634	af, socktype, proto, canonname, sa = res
1529	1635	try:
1530	1636	self.bind(af, socktype, proto)
1531		except socket.error:
	1637	except socket.error as serr:
	1638	msg = "%s -- (%s: %s)" % (msg, sa, serr)
1532	1639	if self.socket:
1533	1640	self.socket.close()
1534	1641	self.socket = None

1536	1643	break
1537	1644	if not self.socket:
1538	1645	raise socket.error(msg)
1539
	1646
1540	1647	# Timeout so KeyboardInterrupt can be caught on Win32
1541	1648	self.socket.settimeout(1)
1542	1649	self.socket.listen(self.request_queue_size)
1543
	1650
1544	1651	# Create worker threads
1545	1652	self.requests.start()
1546
	1653
1547	1654	self.ready = True
1548	1655	self._start_time = time.time()
1549	1656	while self.ready:

1577	1684	self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
1578	1685	if self.nodelay and not isinstance(self.bind_addr, str):
1579	1686	self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
1580
	1687
1581	1688	if self.ssl_adapter is not None:
1582	1689	self.socket = self.ssl_adapter.bind(self.socket)
1583
	1690
1584	1691	# If listening on the IPV6 any address ('::' = IN6ADDR_ANY),
1585		# activate dual-stack. See http://www.cherrypy.org/ticket/871.
	1692	# activate dual-stack. See
	1693	# https://bitbucket.org/cherrypy/cherrypy/issue/871.
1586	1694	if (hasattr(socket, 'AF_INET6') and family == socket.AF_INET6
1587		and self.bind_addr[0] in ('::', '::0', '::0.0.0.0')):
	1695	and self.bind_addr[0] in ('::', '::0', '::0.0.0.0')):
1588	1696	try:
1589		self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
	1697	self.socket.setsockopt(
	1698	socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
1590	1699	except (AttributeError, socket.error):
1591	1700	# Apparently, the socket option is not available in
1592	1701	# this machine's TCP stack
1593	1702	pass
1594
	1703
1595	1704	self.socket.bind(self.bind_addr)
1596
	1705
1597	1706	def tick(self):
1598	1707	"""Accept a new connection and put it on the Queue."""
1599	1708	try:

1602	1711	self.stats['Accepts'] += 1
1603	1712	if not self.ready:
1604	1713	return
1605
	1714
1606	1715	prevent_socket_inheritance(s)
1607	1716	if hasattr(s, 'settimeout'):
1608	1717	s.settimeout(self.timeout)
1609
	1718
1610	1719	makefile = CP_makefile
1611	1720	ssl_env = {}
1612	1721	# if ssl cert and key are set, we try to be a secure HTTP server

1620	1729	"Content-Length: %s\r\n" % len(msg),
1621	1730	"Content-Type: text/plain\r\n\r\n",
1622	1731	msg]
1623
	1732
1624	1733	wfile = makefile(s, "wb", DEFAULT_BUFFER_SIZE)
1625	1734	try:
1626	1735	wfile.write("".join(buf).encode('ISO-8859-1'))

1635	1744	# Re-apply our timeout since we may have a new socket object
1636	1745	if hasattr(s, 'settimeout'):
1637	1746	s.settimeout(self.timeout)
1638
	1747
1639	1748	conn = self.ConnectionClass(self, s, makefile)
1640
	1749
1641	1750	if not isinstance(self.bind_addr, basestring):
1642	1751	# optional values
1643	1752	# Until we do DNS lookups, omit REMOTE_HOST
1644		if addr is None: # sometimes this can happen
	1753	if addr is None: # sometimes this can happen
1645	1754	# figure out if AF_INET or AF_INET6.
1646	1755	if len(s.getsockname()) == 2:
1647	1756	# AF_INET

1651	1760	addr = ('::', 0)
1652	1761	conn.remote_addr = addr[0]
1653	1762	conn.remote_port = addr[1]
1654
	1763
1655	1764	conn.ssl_env = ssl_env
1656
	1765
1657	1766	self.requests.put(conn)
1658	1767	except socket.timeout:
1659	1768	# The only reason for the timeout in start() is so we can

1669	1778	# is received during the accept() call; all docs say retry
1670	1779	# the call, and I think I'm reading it right that Python
1671	1780	# will then go ahead and poll for and handle the signal
1672		# elsewhere. See http://www.cherrypy.org/ticket/707.
	1781	# elsewhere. See
	1782	# https://bitbucket.org/cherrypy/cherrypy/issue/707.
1673	1783	return
1674	1784	if x.args[0] in socket_errors_nonblocking:
1675		# Just try again. See http://www.cherrypy.org/ticket/479.
	1785	# Just try again. See
	1786	# https://bitbucket.org/cherrypy/cherrypy/issue/479.
1676	1787	return
1677	1788	if x.args[0] in socket_errors_to_ignore:
1678	1789	# Our socket was closed.
1679		# See http://www.cherrypy.org/ticket/686.
	1790	# See https://bitbucket.org/cherrypy/cherrypy/issue/686.
1680	1791	return
1681	1792	raise
1682
	1793
1683	1794	def _get_interrupt(self):
1684	1795	return self._interrupt
	1796
1685	1797	def _set_interrupt(self, interrupt):
1686	1798	self._interrupt = True
1687	1799	self.stop()

1689	1801	interrupt = property(_get_interrupt, _set_interrupt,
1690	1802	doc="Set this to an Exception instance to "
1691	1803	"interrupt the server.")
1692
	1804
1693	1805	def stop(self):
1694	1806	"""Gracefully shutdown a server that is serving forever."""
1695	1807	self.ready = False
1696	1808	if self._start_time is not None:
1697	1809	self._run_time += (time.time() - self._start_time)
1698	1810	self._start_time = None
1699
	1811
1700	1812	sock = getattr(self, "socket", None)
1701	1813	if sock:
1702	1814	if not isinstance(self.bind_addr, basestring):

1707	1819	x = sys.exc_info()[1]
1708	1820	if x.args[0] not in socket_errors_to_ignore:
1709	1821	# Changed to use error code and not message
1710		# See http://www.cherrypy.org/ticket/860.
	1822	# See
	1823	# https://bitbucket.org/cherrypy/cherrypy/issue/860.
1711	1824	raise
1712	1825	else:
1713	1826	# Note that we're explicitly NOT using AI_PASSIVE,

1720	1833	s = None
1721	1834	try:
1722	1835	s = socket.socket(af, socktype, proto)
1723		# See http://groups.google.com/group/cherrypy-users/
1724		# browse_frm/thread/bbfe5eb39c904fe0
	1836	# See
	1837	# http://groups.google.com/group/cherrypy-users/
	1838	# browse_frm/thread/bbfe5eb39c904fe0
1725	1839	s.settimeout(1.0)
1726	1840	s.connect((host, port))
1727	1841	s.close()

1731	1845	if hasattr(sock, "close"):
1732	1846	sock.close()
1733	1847	self.socket = None
1734
	1848
1735	1849	self.requests.stop(self.shutdown_timeout)
1736	1850
1737	1851
1738	1852	class Gateway(object):
1739		"""A base class to interface HTTPServer with other systems, such as WSGI."""
1740
	1853
	1854	"""A base class to interface HTTPServer with other systems, such as WSGI.
	1855	"""
	1856
1741	1857	def __init__(self, req):
1742	1858	self.req = req
1743
	1859
1744	1860	def respond(self):
1745	1861	"""Process the current request. Must be overridden in a subclass."""
1746	1862	raise NotImplemented

1750	1866	# of such classes (in which case they will be lazily loaded).
1751	1867	ssl_adapters = {
1752	1868	'builtin': 'cherrypy.wsgiserver.ssl_builtin.BuiltinSSLAdapter',
1753		}
	1869	}
	1870
1754	1871
1755	1872	def get_ssl_adapter_class(name='builtin'):
1756	1873	"""Return an SSL adapter class for the given name."""

1759	1876	last_dot = adapter.rfind(".")
1760	1877	attr_name = adapter[last_dot + 1:]
1761	1878	mod_path = adapter[:last_dot]
1762
	1879
1763	1880	try:
1764	1881	mod = sys.modules[mod_path]
1765	1882	if mod is None:

1767	1884	except KeyError:
1768	1885	# The last [''] is important.
1769	1886	mod = __import__(mod_path, globals(), locals(), [''])
1770
	1887
1771	1888	# Let an AttributeError propagate outward.
1772	1889	try:
1773	1890	adapter = getattr(mod, attr_name)
1774	1891	except AttributeError:
1775	1892	raise AttributeError("'%s' object has no attribute '%s'"
1776	1893	% (mod_path, attr_name))
1777
	1894
1778	1895	return adapter
1779	1896
1780		# -------------------------------- WSGI Stuff -------------------------------- #
	1897	# ------------------------------- WSGI Stuff -------------------------------- #
1781	1898
1782	1899
1783	1900	class CherryPyWSGIServer(HTTPServer):
	1901
1784	1902	"""A subclass of HTTPServer which calls a WSGI application."""
1785
	1903
1786	1904	wsgi_version = (1, 0)
1787	1905	"""The version of WSGI to produce."""
1788
	1906
1789	1907	def __init__(self, bind_addr, wsgi_app, numthreads=10, server_name=None,
1790	1908	max=-1, request_queue_size=5, timeout=10, shutdown_timeout=5):
1791	1909	self.requests = ThreadPool(self, min=numthreads or 1, max=max)
1792	1910	self.wsgi_app = wsgi_app
1793	1911	self.gateway = wsgi_gateways[self.wsgi_version]
1794
	1912
1795	1913	self.bind_addr = bind_addr
1796	1914	if not server_name:
1797	1915	server_name = socket.gethostname()
1798	1916	self.server_name = server_name
1799	1917	self.request_queue_size = request_queue_size
1800
	1918
1801	1919	self.timeout = timeout
1802	1920	self.shutdown_timeout = shutdown_timeout
1803	1921	self.clear_stats()
1804
	1922
1805	1923	def _get_numthreads(self):
1806	1924	return self.requests.min
	1925
1807	1926	def _set_numthreads(self, value):
1808	1927	self.requests.min = value
1809	1928	numthreads = property(_get_numthreads, _set_numthreads)
1810	1929
1811	1930
1812	1931	class WSGIGateway(Gateway):
	1932
1813	1933	"""A base class to interface HTTPServer with WSGI."""
1814
	1934
1815	1935	def __init__(self, req):
1816	1936	self.req = req
1817	1937	self.started_response = False
1818	1938	self.env = self.get_environ()
1819	1939	self.remaining_bytes_out = None
1820
	1940
1821	1941	def get_environ(self):
1822	1942	"""Return a new environ dict targeting the given wsgi.version"""
1823	1943	raise NotImplemented
1824
	1944
1825	1945	def respond(self):
1826	1946	"""Process the current request."""
1827	1947	response = self.req.server.wsgi_app(self.env, self.start_response)

1840	1960	finally:
1841	1961	if hasattr(response, "close"):
1842	1962	response.close()
1843
1844		def start_response(self, status, headers, exc_info = None):
	1963
	1964	def start_response(self, status, headers, exc_info=None):
1845	1965	"""WSGI callable to begin the HTTP response."""
1846	1966	# "The application may call start_response more than once,
1847	1967	# if and only if the exc_info argument is provided."

1849	1969	raise AssertionError("WSGI start_response called a second "
1850	1970	"time with no exc_info.")
1851	1971	self.started_response = True
1852
	1972
1853	1973	# "if exc_info is provided, and the HTTP headers have already been
1854	1974	# sent, start_response must raise an error, and should raise the
1855	1975	# exc_info tuple."

1869	1989
1870	1990	for k, v in headers:
1871	1991	if not isinstance(k, str):
1872		raise TypeError("WSGI response header key %r is not of type str." % k)
	1992	raise TypeError(
	1993	"WSGI response header key %r is not of type str." % k)
1873	1994	if not isinstance(v, str):
1874		raise TypeError("WSGI response header value %r is not of type str." % v)
	1995	raise TypeError(
	1996	"WSGI response header value %r is not of type str." % v)
1875	1997	if k.lower() == 'content-length':
1876	1998	self.remaining_bytes_out = int(v)
1877		self.req.outheaders.append((k.encode('ISO-8859-1'), v.encode('ISO-8859-1')))
1878
	1999	self.req.outheaders.append(
	2000	(k.encode('ISO-8859-1'), v.encode('ISO-8859-1')))
	2001
1879	2002	return self.write
1880
	2003
1881	2004	def write(self, chunk):
1882	2005	"""WSGI callable to write unbuffered data to the client.
1883
	2006
1884	2007	This method is also used internally by start_response (to write
1885	2008	data from the iterable returned by the WSGI application).
1886	2009	"""
1887	2010	if not self.started_response:
1888	2011	raise AssertionError("WSGI write called before start_response.")
1889
	2012
1890	2013	chunklen = len(chunk)
1891	2014	rbo = self.remaining_bytes_out
1892	2015	if rbo is not None and chunklen > rbo:
1893	2016	if not self.req.sent_headers:
1894	2017	# Whew. We can send a 500 to the client.
1895	2018	self.req.simple_response("500 Internal Server Error",
1896		"The requested resource returned more bytes than the "
1897		"declared Content-Length.")
	2019	"The requested resource returned "
	2020	"more bytes than the declared "
	2021	"Content-Length.")
1898	2022	else:
1899	2023	# Dang. We have probably already sent data. Truncate the chunk
1900	2024	# to fit (so the client doesn't hang) and raise an error later.
1901	2025	chunk = chunk[:rbo]
1902
	2026
1903	2027	if not self.req.sent_headers:
1904	2028	self.req.sent_headers = True
1905	2029	self.req.send_headers()
1906
	2030
1907	2031	self.req.write(chunk)
1908
	2032
1909	2033	if rbo is not None:
1910	2034	rbo -= chunklen
1911	2035	if rbo < 0:

1914	2038
1915	2039
1916	2040	class WSGIGateway_10(WSGIGateway):
	2041
1917	2042	"""A Gateway class to interface HTTPServer with WSGI 1.0.x."""
1918
	2043
1919	2044	def get_environ(self):
1920	2045	"""Return a new environ dict targeting the given wsgi.version"""
1921	2046	req = self.req

1929	2054	'REMOTE_ADDR': req.conn.remote_addr or '',
1930	2055	'REMOTE_PORT': str(req.conn.remote_port or ''),
1931	2056	'REQUEST_METHOD': req.method.decode('ISO-8859-1'),
1932		'REQUEST_URI': req.uri,
	2057	'REQUEST_URI': req.uri.decode('ISO-8859-1'),
1933	2058	'SCRIPT_NAME': '',
1934	2059	'SERVER_NAME': req.server.server_name,
1935	2060	# Bah. "SERVER_PROTOCOL" is actually the REQUEST protocol.

1942	2067	'wsgi.run_once': False,
1943	2068	'wsgi.url_scheme': req.scheme.decode('ISO-8859-1'),
1944	2069	'wsgi.version': (1, 0),
1945		}
1946
	2070	}
1947	2071	if isinstance(req.server.bind_addr, basestring):
1948	2072	# AF_UNIX. This isn't really allowed by WSGI, which doesn't
1949	2073	# address unix domain sockets. But it's better than nothing.
1950	2074	env["SERVER_PORT"] = ""
1951	2075	else:
1952	2076	env["SERVER_PORT"] = str(req.server.bind_addr[1])
1953
	2077
1954	2078	# Request headers
1955	2079	for k, v in req.inheaders.items():
1956	2080	k = k.decode('ISO-8859-1').upper().replace("-", "_")
1957	2081	env["HTTP_" + k] = v.decode('ISO-8859-1')
1958
	2082
1959	2083	# CONTENT_TYPE/CONTENT_LENGTH
1960	2084	ct = env.pop("HTTP_CONTENT_TYPE", None)
1961	2085	if ct is not None:

1963	2087	cl = env.pop("HTTP_CONTENT_LENGTH", None)
1964	2088	if cl is not None:
1965	2089	env["CONTENT_LENGTH"] = cl
1966
	2090
1967	2091	if req.conn.ssl_env:
1968	2092	env.update(req.conn.ssl_env)
1969
	2093
1970	2094	return env
1971	2095
1972	2096
1973	2097	class WSGIGateway_u0(WSGIGateway_10):
	2098
1974	2099	"""A Gateway class to interface HTTPServer with WSGI u.0.
1975
1976		WSGI u.0 is an experimental protocol, which uses unicode for keys and values
1977		in both Python 2 and Python 3.
	2100
	2101	WSGI u.0 is an experimental protocol, which uses unicode for keys
	2102	and values in both Python 2 and Python 3.
1978	2103	"""
1979
	2104
1980	2105	def get_environ(self):
1981	2106	"""Return a new environ dict targeting the given wsgi.version"""
1982	2107	req = self.req
1983	2108	env_10 = WSGIGateway_10.get_environ(self)
1984	2109	env = env_10.copy()
1985	2110	env['wsgi.version'] = ('u', 0)
1986
	2111
1987	2112	# Request-URI
1988	2113	env.setdefault('wsgi.url_encoding', 'utf-8')
1989	2114	try:

1995	2120	env['wsgi.url_encoding'] = 'ISO-8859-1'
1996	2121	env["PATH_INFO"] = env_10["PATH_INFO"]
1997	2122	env["QUERY_STRING"] = env_10["QUERY_STRING"]
1998
	2123
1999	2124	return env
2000	2125
2001	2126	wsgi_gateways = {

2003	2128	('u', 0): WSGIGateway_u0,
2004	2129	}
2005	2130
	2131
2006	2132	class WSGIPathInfoDispatcher(object):
	2133
2007	2134	"""A WSGI dispatcher for dispatch based on the PATH_INFO.
2008
	2135
2009	2136	apps: a dict or list of (path_prefix, app) pairs.
2010	2137	"""
2011
	2138
2012	2139	def __init__(self, apps):
2013	2140	try:
2014	2141	apps = list(apps.items())
2015	2142	except AttributeError:
2016	2143	pass
2017
	2144
2018	2145	# Sort the apps by len(path), descending
2019	2146	apps.sort()
2020	2147	apps.reverse()
2021
	2148
2022	2149	# The path_prefix strings must start, but not end, with a slash.
2023	2150	# Use "" instead of "/".
2024	2151	self.apps = [(p.rstrip("/"), a) for p, a in apps]
2025
	2152
2026	2153	def __call__(self, environ, start_response):
2027	2154	path = environ["PATH_INFO"] or "/"
2028	2155	for p, app in self.apps:

2032	2159	environ["SCRIPT_NAME"] = environ["SCRIPT_NAME"] + p
2033	2160	environ["PATH_INFO"] = path[len(p):]
2034	2161	return app(environ, start_response)
2035
	2162
2036	2163	start_response('404 Not Found', [('Content-Type', 'text/plain'),
2037	2164	('Content-Length', '0')])
2038	2165	return ['']
2039

+17

-5

setup.cfg less more

0		[egg_info]
1		tag_build =
2		tag_date = 0
3		tag_svn_revision = 0
4
	0	[sdist]
	1	formats = gztar,zip
	2
	3	[nosetests]
	4	where = cherrypy
	5	logging-filter = cherrypy
	6	verbosity = 2
	7	nocapture = True
	8
	9	[wheel]
	10	universal = 1
	11
	12	[egg_info]
	13	tag_build =
	14	tag_svn_revision = 0
	15	tag_date = 0
	16

+35

-21

setup.py less more

13	13	from distutils.command.install import INSTALL_SCHEMES
14	14	from distutils.command.build_py import build_py
15	15	import sys
16		import os
17	16	import re
18	17
	18
19	19	class cherrypy_build_py(build_py):
20		"Custom version of build_py that selects Python-specific wsgiserver"
	20	"""Custom version of build_py that excludes Python-specific modules"""
	21
21	22	def build_module(self, module, module_file, package):
22	23	python3 = sys.version_info >= (3,)
23	24	if python3:
24		exclude_pattern = re.compile('wsgiserver2\|ssl_pyopenssl')
	25	exclude_pattern = re.compile('wsgiserver2\|ssl_pyopenssl\|'
	26	'_cpcompat_subprocess')
25	27	else:
26	28	exclude_pattern = re.compile('wsgiserver3')
27	29	if exclude_pattern.match(module):
28		return # skip it
	30	return # skip it
29	31	return build_py.build_module(self, module, module_file, package)
30	32
31	33

33	35	# arguments for the setup command
34	36	###############################################################################
35	37	name = "CherryPy"
36		version = "3.2.2"
	38	version = "3.3.0"
37	39	desc = "Object-Oriented HTTP framework"
38	40	long_desc = "CherryPy is a pythonic, object-oriented HTTP framework"
39		classifiers=[
	41	classifiers = [
40	42	"Development Status :: 5 - Production/Stable",
41	43	"Environment :: Web Environment",
42	44	"Intended Audience :: Developers",
43	45	"License :: Freely Distributable",
44	46	"Operating System :: OS Independent",
	47	"Framework :: CherryPy",
	48	"License :: OSI Approved :: BSD License",
45	49	"Programming Language :: Python",
46	50	"Programming Language :: Python :: 2",
	51	"Programming Language :: Python :: 2.3",
	52	"Programming Language :: Python :: 2.4",
	53	"Programming Language :: Python :: 2.5",
	54	"Programming Language :: Python :: 2.6",
	55	"Programming Language :: Python :: 2.7",
47	56	"Programming Language :: Python :: 3",
	57	"Programming Language :: Python :: 3.3",
	58	"Programming Language :: Python :: Implementation",
	59	"Programming Language :: Python :: Implementation :: CPython",
	60	"Programming Language :: Python :: Implementation :: Jython",
	61	"Programming Language :: Python :: Implementation :: PyPy",
48	62	"Topic :: Internet :: WWW/HTTP",
49	63	"Topic :: Internet :: WWW/HTTP :: Dynamic Content",
50	64	"Topic :: Internet :: WWW/HTTP :: HTTP Servers",

53	67	"Topic :: Internet :: WWW/HTTP :: WSGI :: Server",
54	68	"Topic :: Software Development :: Libraries :: Application Frameworks",
55	69	]
56		author="CherryPy Team"
57		author_email="team@cherrypy.org"
58		url="http://www.cherrypy.org"
59		cp_license="BSD"
60		packages=[
	70	author = "CherryPy Team"
	71	author_email = "team@cherrypy.org"
	72	url = "http://www.cherrypy.org"
	73	cp_license = "BSD"
	74	packages = [
61	75	"cherrypy", "cherrypy.lib",
62	76	"cherrypy.tutorial", "cherrypy.test",
63	77	"cherrypy.process",
64	78	"cherrypy.scaffold",
65	79	"cherrypy.wsgiserver",
66	80	]
67		download_url="http://download.cherrypy.org/cherrypy/3.2.2/"
68		data_files=[
	81	data_files = [
69	82	('cherrypy', ['cherrypy/cherryd',
70	83	'cherrypy/favicon.ico',
71	84	'cherrypy/LICENSE.txt',

74	87	('cherrypy/scaffold', ['cherrypy/scaffold/example.conf',
75	88	'cherrypy/scaffold/site.conf',
76	89	]),
77		('cherrypy/scaffold/static', ['cherrypy/scaffold/static/made_with_cherrypy_small.png',
78		]),
	90	('cherrypy/scaffold/static', [
	91	'cherrypy/scaffold/static/made_with_cherrypy_small.png']),
79	92	('cherrypy/test', ['cherrypy/test/style.css',
80	93	'cherrypy/test/test.pem',
81	94	]),
82	95	('cherrypy/test/static', ['cherrypy/test/static/index.html',
83		'cherrypy/test/static/dirback.jpg',]),
	96	'cherrypy/test/static/dirback.jpg', ]),
84	97	('cherrypy/tutorial',
85	98	[
86	99	'cherrypy/tutorial/tutorial.conf',

88	101	'cherrypy/tutorial/pdf_file.pdf',
89	102	'cherrypy/tutorial/custom_error.html',
90	103	]
91		),
	104	),
92	105	]
93	106	scripts = ["cherrypy/cherryd"]
94	107
95	108	cmd_class = dict(
96		build_py = cherrypy_build_py,
	109	build_py=cherrypy_build_py,
97	110	)
98	111
99	112	if sys.version_info >= (3, 0):

107	120
108	121	# wininst may install data_files in Python/x.y instead of the cherrypy package.
109	122	# Django's solution is at http://code.djangoproject.com/changeset/8313
110		# See also http://mail.python.org/pipermail/distutils-sig/2004-August/004134.html
	123	# See also
	124	# http://mail.python.org/pipermail/distutils-sig/2004-August/004134.html
111	125	if 'bdist_wininst' in sys.argv or '--format=wininst' in sys.argv:
112	126	data_files = [(r'\PURELIB\%s' % path, files) for path, files in data_files]
	127
113	128
114	129	def main():
115	130	if sys.version < required_python_version:

121	136	for scheme in list(INSTALL_SCHEMES.values()):
122	137	scheme['data'] = scheme['purelib']
123	138
124		dist = setup(
	139	setup(
125	140	name=name,
126	141	version=version,
127	142	description=desc,

132	147	url=url,
133	148	license=cp_license,
134	149	packages=packages,
135		download_url=download_url,
136	150	data_files=data_files,
137	151	scripts=scripts,
138	152	cmdclass=cmd_class,