pax_global_header00006660000000000000000000000064134422722620014516gustar00rootroot0000000000000052 comment=229e27b7ef08016725dba983e8b404d407ec37db AdvancedHTTPServer-2.2.0/000077500000000000000000000000001344227226200151135ustar00rootroot00000000000000AdvancedHTTPServer-2.2.0/.gitignore000066400000000000000000000002211344227226200170760ustar00rootroot00000000000000*.conf *.geany *.py[cod] .buildinfo .doctrees/* .idea/* AdvancedHTTPServer.egg-info/* build/* dist/* docs/build docs/html MANIFEST Pipfile.lock AdvancedHTTPServer-2.2.0/.pylintrc000066400000000000000000000051631344227226200167650ustar00rootroot00000000000000[MASTER] persistent=no jobs=1 unsafe-load-any-extension=no [MESSAGES CONTROL] confidence=UNDEFINED #enable=C0325,C0326,W0611,W0612,W0613 #disable=all disable= C0111,C0113,C0301,C0330,C0411,C0412,C0413, E1101,E1136,E1137,E1138,E1608,W1627,E1601,E1603,E1602,E1605,E1604,E1607,E1606, F0401, I0011,I0020,I0021, R0201,R0204,R1704, W0221,W0622,W0703,W0704,W1201,W1202,W1505,W1601,W1602,W1603,W1604,W1605,W1606,W1607,W1608,W1609,W1610,W1611,W1612,W1613,W1614,W1615,W1616,W1617,W1618,W1619,W1620,W1621,W1622,W1623,W1624,W1625,W1626,W1628,W1629,W1630,W1631,W1632,W1633 [REPORTS]. output-format=colorized files-output=no reports=yes msg-template="{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}" [LOGGING] logging-modules=logging [BASIC] bad-functions=input good-names=i,j,k,ex,Run,_ bad-names=foo,bar,baz,toto,tutu,tata function-rgx=[a-z_][a-z0-9_]{2,30}$ function-name-hint=[a-z_][a-z0-9_]{2,30}$ variable-rgx=[a-z_][a-z0-9_]{2,30}$ variable-name-hint=[a-z_][a-z0-9_]{2,30}$ const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$ const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$ attr-rgx=[a-z_][a-z0-9_]{2,30}$ attr-name-hint=[a-z_][a-z0-9_]{2,30}$ argument-rgx=[a-z_][a-z0-9_]{2,30}$ argument-name-hint=[a-z_][a-z0-9_]{2,30}$ class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$ inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$ class-rgx=[A-Z_][a-zA-Z0-9]+$ class-name-hint=[A-Z_][a-zA-Z0-9]+$ module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ method-rgx=(([a-z_][a-z0-9_]{2,40})|(assert[a-zA-Z0-9]{2,40})|(do_[a-zA-Z0-9_]{2,40}))$ method-name-hint=(([a-z_][a-z0-9_]{2,40})|(assert[a-zA-Z0-9]{2,40})|(do_[a-zA-Z0-9_]{2,40}))$ [FORMAT] ignore-long-lines=^\s*(# )??$ single-line-if-stmt=no no-space-check=trailing-comma,dict-separator indent-string=\t indent-after-paren=4 expected-line-ending-format=LF [VARIABLES] init-import=no callbacks=cb_,_cb,signal_ [SIMILARITIES] min-similarity-lines=4 ignore-comments=yes ignore-docstrings=yes ignore-imports=no [TYPECHECK] ignore-mixin-members=yes generated-members=REQUEST,acl_users,aq_parent [MISCELLANEOUS] notes=FIXME,XXX,TODO [DESIGN] max-args=8 ignored-argument-names=_.* max-locals=15 max-returns=12 max-branches=20 max-statements=70 max-parents=7 max-attributes=15 min-public-methods=0 max-public-methods=30 [CLASSES] defining-attr-methods=__init__,__new__,setUp valid-classmethod-first-arg=cls valid-metaclass-classmethod-first-arg=mcs exclude-protected=_asdict,_fields,_replace,_source,_make [EXCEPTIONS] overgeneral-exceptions=Exception AdvancedHTTPServer-2.2.0/.travis.yml000066400000000000000000000004611344227226200172250ustar00rootroot00000000000000language: python python: - "2.7" - "3.4" - "3.5" - "3.6" install: - pip install msgpack-python pylint==1.8.3 sphinx sphinx-rtd-theme websocket-client script: - pylint --rcfile .pylintrc advancedhttpserver.py - python -m unittest -v tests - sphinx-build -b html -E docs/source docs/html AdvancedHTTPServer-2.2.0/LICENSE000066400000000000000000000026321344227226200161230ustar00rootroot00000000000000Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the project nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. AdvancedHTTPServer-2.2.0/Pipfile000066400000000000000000000002741344227226200164310ustar00rootroot00000000000000[[source]] name = "pypi" url = "https://pypi.org/simple" verify_ssl = true [dev-packages] sphinx = "*" websocket-client = "*" sphinx-rtd-theme = "*" [packages] msgpack = "*" [requires] AdvancedHTTPServer-2.2.0/README.rst000066400000000000000000000056431344227226200166120ustar00rootroot00000000000000AdvancedHTTPServer ================== Standalone web server built on Python’s BaseHTTPServer |Build Status| |Documentation Status| |Github Issues| |PyPi Release| License ------- AdvancedHTTPServer is released under the BSD 3-clause license, for more details see the `LICENSE `__ file. Features -------- AdvancedHTTPServer builds on top of Python’s included BaseHTTPServer and provides out of the box support for additional commonly needed features such as: - Threaded request handling - Binding to multiple interfaces - SSL and SNI support - Registering handler functions to HTTP resources - A default robots.txt file - Basic authentication - The HTTP verbs GET, HEAD, POST, and OPTIONS - Remote Procedure Call (RPC) over HTTP - WebSockets Dependencies ------------ AdvancedHTTPServer does not have any additional dependencies outside of the Python standard library. The following version of Python are currently supported: - Python 2.7 - Python 3.3 - Python 3.4 - Python 3.5 - Python 3.6 - Python 3.7 Code Documentation ------------------ AdvancedHTTPServer uses Sphinx for internal code documentation. This documentation can be generated from source with the command ``sphinx-build docs/source docs/html``. The latest documentation is kindly hosted on `ReadTheDocs `__ at `advancedhttpserver.readthedocs.io `__. Changes In Version 2.0 ---------------------- - The ``AdvancedHTTPServer`` module has been renamed ``advancedhttpserver`` - Classes prefixed with ``AdvancedHTTPServer`` have been renamed to have the redundant prefix removed - The ``hmac_key`` option is no longer supported - A single ``AdvancedHTTPServer`` instance can now be bound to multiple ports - The ``RequestHandler.install_handlers`` method has been renamed to ``on_init`` - ``SERIALIZER_DRIVERS`` was renamed to ``g_serializer_drivers`` - Support for multiple hostnames with SSL using the SNI extension - Support for persistent HTTP 1.1 TCP connections Powered By AdvancedHTTPServer ----------------------------- - `King Phisher `__ Phishing Campaign Toolkit .. |Build Status| image:: http://img.shields.io/travis/zeroSteiner/AdvancedHTTPServer.svg?style=flat-square :target: https://travis-ci.org/zeroSteiner/AdvancedHTTPServer .. |Documentation Status| image:: https://readthedocs.org/projects/advancedhttpserver/badge/?version=latest&style=flat-square :target: http://advancedhttpserver.readthedocs.org/en/latest .. |Github Issues| image:: http://img.shields.io/github/issues/zerosteiner/AdvancedHTTPServer.svg?style=flat-square :target: https://github.com/zerosteiner/AdvancedHTTPServer/issues .. |PyPi Release| image:: https://img.shields.io/pypi/v/AdvancedHTTPServer.svg?style=flat-square :target: https://pypi.python.org/pypi/AdvancedHTTPServer AdvancedHTTPServer-2.2.0/advancedhttpserver.pem000066400000000000000000000056411344227226200215200ustar00rootroot00000000000000-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEA22rznQ1HjJHw7pA42w9mSG0M+sVhC4KyE/16kjQOge2tzTvc CzqJcw147ndvM80ipH9rJoDPt93EF/TN+nGKarRQGKfld1pomQ/nkq1Co7OXqtBx dZmgYl8skS6vzeQJxtKGkpAYDh+ukq+LaQ9dtZLp2n4lQffX7SZh80oFS9f5Tq/e 3zc/2DsXGwAtcNdV6rHNEnCwvbbVeE6s5PgMDx/19Ut97keSpslTpGFXx2iEzUMz otg0+ADjpSBw03qgH8NA7IQduTyD7TP1dpxOHVGViFEz9dqxcyUq/9rPqCB+qSqX 22RwM93ShnaUf26tnCgWjYivSSxG5sCTuFWROQIDAQABAoIBAQCF1F0UjLX4Skee 6r6S9niXclQ5XExNvgCp6rBpHnE+1F5u0LTs8F5Hm48IPDbKbLNVjBYp3OVVK2Fg j0NXHwui+6ni7/0o6C7mNOo075K20GKQoCSj6vkFJzHCt6wpM463A09rc5IIg1By TboFcYbhqeMTDl/hNa8xCXky8BH86HNbPGwTtGUPP24MLmuJQd8bYFVj1fE/OgPx W5VWECaU3X1aLveKxtvnfzKHxAWAIq31xGpiW77piOVMDTozrzPyUxY7syEUpy0b ysi5tu+ERjyFQOM8in13uhKDlPINr94KZPg3OKE/Y7/piXAgMsqz9xLMazMMFzhy ebiDdXmRAoGBAP7F2RzfRXwLq2BHzJaarkYBrc/I4fsnp4e3j6XOwjhXz2cd49jf Qob8dGtoQRzOcZDaJ5mcvSZDRPc5N7JAa61X9/dkSTYP+cwYWpQJYdMoNcxh9qs3 CZ1hWNNvCqLLbpK7n2+tQB4aJ2jJxtsZtirNl5GvRbTmldx9T1CjfLdNAoGBANx5 giRTFREleC7LE+2UKurFHDFdv4do8IyQanKfvxLtOCs+VUXDlKORNPSxBuFeXps1 XvYbTZyHJjreUAgfTDOgkuTC8U7PgxH8PIXH4+Ryt9W0n4FtzCC3d9rMgucsL5ux X/mgQU29LS+IYUyNQvXS3P6a1kFbH/OTQVNkYEOdAoGAJWW9XPOZK4A7A8MGUQUb l8MfVGTUZx2HBfD38QrMj6C0HRrSGz+KcG4WWL3Q8P2Mxgp/zZioWzl8oh2QA2ZZ Z/SFvZbG+FyX+lGI2joWVfyNCRdIMhG+I4/qjf66vPLHpFpOKQJxavnD1ynnOron d1j+arAjt04xqU/rmJam8/ECgYAbPGd3VUwk8hwGq8+qacNjfTYeYxZmA/CzbKO5 xUI1dFib/vdJxv91tVp1X+kZri7BvbYdcQIFdCyk2RHJ7xPazNtYpzxoH/pxHlfb rvXYItPS8p1Bv+6XnBKSVPFW3X6EHUVd8Q4gLF6IoLBkZI8BDyt9yGLvb/JihK5t PtklgQKBgCwUKCp4CVnk+sFNr6ponSZsjt8+93U366GUQoLfhAEDcJmda16PigTZ yi7TUPUXh6qxeqqsENbpblzJHyEK+XWopzOm+RKcg8+RQSMq05YiF5qDhSzcR40z 3r7FgB8hTN9Qkj0zLMeRNxR8IA2LK3C0y4O5OdHizwXUSnY/FkiS -----END RSA PRIVATE KEY----- -----BEGIN CERTIFICATE----- MIIDlTCCAn2gAwIBAgIJAL7clMm64tWlMA0GCSqGSIb3DQEBCwUAMGExCzAJBgNV BAYTAlVTMQ0wCwYDVQQIDARPaGlvMRIwEAYDVQQHDAlDbGV2ZWxhbmQxGzAZBgNV BAoMEkFkdmFuY2VkSFRUUFNlcnZlcjESMBAGA1UEAwwJbG9jYWxob3N0MB4XDTE2 MDYwMTE3MDgzNVoXDTE5MDYwMTE3MDgzNVowYTELMAkGA1UEBhMCVVMxDTALBgNV BAgMBE9oaW8xEjAQBgNVBAcMCUNsZXZlbGFuZDEbMBkGA1UECgwSQWR2YW5jZWRI VFRQU2VydmVyMRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUA A4IBDwAwggEKAoIBAQDbavOdDUeMkfDukDjbD2ZIbQz6xWELgrIT/XqSNA6B7a3N O9wLOolzDXjud28zzSKkf2smgM+33cQX9M36cYpqtFAYp+V3WmiZD+eSrUKjs5eq 0HF1maBiXyyRLq/N5AnG0oaSkBgOH66Sr4tpD121kunafiVB99ftJmHzSgVL1/lO r97fNz/YOxcbAC1w11Xqsc0ScLC9ttV4Tqzk+AwPH/X1S33uR5KmyVOkYVfHaITN QzOi2DT4AOOlIHDTeqAfw0DshB25PIPtM/V2nE4dUZWIUTP12rFzJSr/2s+oIH6p KpfbZHAz3dKGdpR/bq2cKBaNiK9JLEbmwJO4VZE5AgMBAAGjUDBOMB0GA1UdDgQW BBSPKH0pJadusK9A6+H9mhZbx9U2qjAfBgNVHSMEGDAWgBSPKH0pJadusK9A6+H9 mhZbx9U2qjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAUVgKsBdWu phJnILzW89Qusrkoi+4iPPGePx7/bSc+NftuKTVpePJboJggaLJ8zqgSfx/rHqyK ignyyf+MlP9UjR+1GbzEmqYnnMU+ZNuPt0ycdE/LnaKfV1sIEcMF0sSzPEAW/48D 51ln+L7suBvtNHDkQmpVgJLOf+bOS7a4AKNF2JGSr2F/BPId8kk17cp2cnAf64kT sMtBFUNFEIsM6IjzYsGCIkBmDYM+j40zPCVzx6uIzmly3ZFDcP2g4xbe+RfATZHv cj3sGIoPxGJJryuNqllNCq9SXW1L/GLHuOwm60D8dl6lcZTQyNtDL9D7ZyrycUhY c4H6Eu8yoCMh -----END CERTIFICATE----- AdvancedHTTPServer-2.2.0/advancedhttpserver.py000077500000000000000000002263211344227226200213720ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # advancedhttpserver.py # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of the project nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # pylint: disable=too-many-lines # Homepage: https://github.com/zeroSteiner/AdvancedHTTPServer # Author: Spencer McIntyre (zeroSteiner) # Config file example FILE_CONFIG = """ [server] ip = 0.0.0.0 port = 8080 web_root = /var/www/html list_directories = True # Set an ssl_cert to enable SSL # ssl_cert = /path/to/cert.pem # ssl_key = /path/to/cert.key # ssl_version = TLSv1 """ # The AdvancedHTTPServer systemd service unit file # Quick how to: # 1. Copy this file to /etc/systemd/system/pyhttpd.service # 2. Edit the run parameters appropriately in the ExecStart option # 3. Set configuration settings in /etc/pyhttpd.conf # 4. Run "systemctl daemon-reload" FILE_SYSTEMD_SERVICE_UNIT = """ [Unit] Description=Python Advanced HTTP Server After=network.target [Service] Type=simple ExecStart=/sbin/runuser -l nobody -c "/usr/bin/python -m advancedhttpserver -c /etc/pyhttpd.conf" ExecStop=/bin/kill -INT $MAINPID [Install] WantedBy=multi-user.target """ __version__ = '2.2.0' __all__ = ( 'AdvancedHTTPServer', 'RegisterPath', 'RequestHandler', 'RPCClient', 'RPCClientCached', 'RPCError', 'RPCConnectionError', 'ServerTestCase', 'WebSocketHandler', 'build_server_from_argparser', 'build_server_from_config' ) import base64 import binascii import collections import datetime import hashlib import io import json import logging import logging.handlers import mimetypes import os import posixpath import random import re import select import shutil import socket import sqlite3 import ssl import string import struct import sys import threading import time import traceback import unittest import urllib import weakref import zlib if sys.version_info[0] < 3: import BaseHTTPServer import cgi as html import Cookie import httplib import Queue as queue import SocketServer as socketserver import urlparse http = type('http', (), {'client': httplib, 'cookies': Cookie, 'server': BaseHTTPServer}) urllib.parse = urlparse urllib.parse.quote = urllib.quote urllib.parse.unquote = urllib.unquote urllib.parse.urlencode = urllib.urlencode from ConfigParser import ConfigParser else: import html import http.client import http.cookies import http.server import queue import socketserver import urllib.parse from configparser import ConfigParser g_handler_map = {} g_serializer_drivers = {} """Dictionary of available drivers for serialization.""" g_ssl_has_server_sni = (getattr(ssl, 'HAS_SNI', False) and sys.version_info >= ((2, 7, 9) if sys.version_info[0] < 3 else (3, 4))) """An indication of if the environment offers server side SNI support.""" def _serialize_ext_dump(obj): if obj.__class__ == datetime.date: return 'datetime.date', obj.isoformat() elif obj.__class__ == datetime.datetime: return 'datetime.datetime', obj.isoformat() elif obj.__class__ == datetime.time: return 'datetime.time', obj.isoformat() raise TypeError('Unknown type: ' + repr(obj)) def _serialize_ext_load(obj_type, obj_value, default): if obj_type == 'datetime.date': return datetime.datetime.strptime(obj_value, '%Y-%m-%d').date() elif obj_type == 'datetime.datetime': return datetime.datetime.strptime(obj_value, '%Y-%m-%dT%H:%M:%S' + ('.%f' if '.' in obj_value else '')) elif obj_type == 'datetime.time': return datetime.datetime.strptime(obj_value, '%H:%M:%S' + ('.%f' if '.' in obj_value else '')).time() return default def _json_default(obj): obj_type, obj_value = _serialize_ext_dump(obj) return {'__complex_type__': obj_type, 'value': obj_value} def _json_object_hook(obj): return _serialize_ext_load(obj.get('__complex_type__'), obj.get('value'), obj) g_serializer_drivers['application/json'] = { 'dumps': lambda d: json.dumps(d, default=_json_default), 'loads': lambda d, e: json.loads(d, object_hook=_json_object_hook) } try: import msgpack except ImportError: has_msgpack = False else: has_msgpack = True _MSGPACK_EXT_TYPES = {10: 'datetime.datetime', 11: 'datetime.date', 12: 'datetime.time'} def _msgpack_default(obj): obj_type, obj_value = _serialize_ext_dump(obj) obj_type = next(i[0] for i in _MSGPACK_EXT_TYPES.items() if i[1] == obj_type) if sys.version_info[0] == 3: obj_value = obj_value.encode('utf-8') return msgpack.ExtType(obj_type, obj_value) def _msgpack_ext_hook(code, obj_value): default = msgpack.ExtType(code, obj_value) if sys.version_info[0] == 3: obj_value = obj_value.decode('utf-8') obj_type = _MSGPACK_EXT_TYPES.get(code) return _serialize_ext_load(obj_type, obj_value, default) g_serializer_drivers['binary/message-pack'] = { 'dumps': lambda d: msgpack.dumps(d, default=_msgpack_default), 'loads': lambda d, e: msgpack.loads(d, encoding=e, ext_hook=_msgpack_ext_hook) } if hasattr(logging, 'NullHandler'): logging.getLogger('AdvancedHTTPServer').addHandler(logging.NullHandler()) def random_string(size): """ Generate a random string of *size* length consisting of both letters and numbers. This function is not meant for cryptographic purposes and should not be used to generate security tokens. :param int size: The length of the string to return. :return: A string consisting of random characters. :rtype: str """ return ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(size)) def resolve_ssl_protocol_version(version=None): """ Look up an SSL protocol version by name. If *version* is not specified, then the strongest protocol available will be returned. :param str version: The name of the version to look up. :return: A protocol constant from the :py:mod:`ssl` module. :rtype: int """ if version is None: protocol_preference = ('TLSv1_2', 'TLSv1_1', 'TLSv1', 'SSLv3', 'SSLv23', 'SSLv2') for protocol in protocol_preference: if hasattr(ssl, 'PROTOCOL_' + protocol): return getattr(ssl, 'PROTOCOL_' + protocol) raise RuntimeError('could not find a suitable ssl PROTOCOL_ version constant') elif isinstance(version, str): if not hasattr(ssl, 'PROTOCOL_' + version): raise ValueError('invalid ssl protocol version: ' + version) return getattr(ssl, 'PROTOCOL_' + version) raise TypeError("ssl_version() argument 1 must be str, not {0}".format(type(version).__name__)) def build_server_from_argparser(description=None, server_klass=None, handler_klass=None): """ Build a server from command line arguments. If a ServerClass or HandlerClass is specified, then the object must inherit from the corresponding AdvancedHTTPServer base class. :param str description: Description string to be passed to the argument parser. :param server_klass: Alternative server class to use. :type server_klass: :py:class:`.AdvancedHTTPServer` :param handler_klass: Alternative handler class to use. :type handler_klass: :py:class:`.RequestHandler` :return: A configured server instance. :rtype: :py:class:`.AdvancedHTTPServer` """ import argparse def _argp_dir_type(arg): if not os.path.isdir(arg): raise argparse.ArgumentTypeError("{0} is not a valid directory".format(repr(arg))) return arg def _argp_port_type(arg): if not arg.isdigit(): raise argparse.ArgumentTypeError("{0} is not a valid port".format(repr(arg))) arg = int(arg) if arg < 0 or arg > 65535: raise argparse.ArgumentTypeError("{0} is not a valid port".format(repr(arg))) return arg description = (description or 'HTTP Server') server_klass = (server_klass or AdvancedHTTPServer) handler_klass = (handler_klass or RequestHandler) parser = argparse.ArgumentParser(conflict_handler='resolve', description=description, fromfile_prefix_chars='@') parser.epilog = 'When a config file is specified with --config only the --log, --log-file and --password options will be used.' parser.add_argument('-c', '--conf', dest='config', type=argparse.FileType('r'), help='read settings from a config file') parser.add_argument('-i', '--ip', dest='ip', default='0.0.0.0', help='the ip address to serve on') parser.add_argument('-L', '--log', dest='loglvl', choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'), default='INFO', help='set the logging level') parser.add_argument('-p', '--port', dest='port', default=8080, type=_argp_port_type, help='port to serve on') parser.add_argument('-v', '--version', action='version', version=parser.prog + ' Version: ' + __version__) parser.add_argument('-w', '--web-root', dest='web_root', default='.', type=_argp_dir_type, help='path to the web root directory') parser.add_argument('--log-file', dest='log_file', help='log information to a file') parser.add_argument('--no-threads', dest='use_threads', action='store_false', default=True, help='disable threading') parser.add_argument('--password', dest='password', help='password to use for basic authentication') ssl_group = parser.add_argument_group('ssl options') ssl_group.add_argument('--ssl-cert', dest='ssl_cert', help='the ssl cert to use') ssl_group.add_argument('--ssl-key', dest='ssl_key', help='the ssl key to use') ssl_group.add_argument('--ssl-version', dest='ssl_version', choices=[p[9:] for p in dir(ssl) if p.startswith('PROTOCOL_')], help='the version of ssl to use') arguments = parser.parse_args() logging.getLogger('').setLevel(logging.DEBUG) console_log_handler = logging.StreamHandler() console_log_handler.setLevel(getattr(logging, arguments.loglvl)) console_log_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(message)s")) logging.getLogger('').addHandler(console_log_handler) if arguments.log_file: main_file_handler = logging.handlers.RotatingFileHandler(arguments.log_file, maxBytes=262144, backupCount=5) main_file_handler.setLevel(logging.DEBUG) main_file_handler.setFormatter(logging.Formatter("%(asctime)s %(name)-30s %(levelname)-10s %(message)s")) logging.getLogger('').setLevel(logging.DEBUG) logging.getLogger('').addHandler(main_file_handler) if arguments.config: config = ConfigParser() config.readfp(arguments.config) server = build_server_from_config( config, 'server', server_klass=server_klass, handler_klass=handler_klass ) else: server = server_klass( handler_klass, address=(arguments.ip, arguments.port), use_threads=arguments.use_threads, ssl_certfile=arguments.ssl_cert, ssl_keyfile=arguments.ssl_key, ssl_version=arguments.ssl_version ) server.serve_files_root = arguments.web_root if arguments.password: server.auth_add_creds('', arguments.password) return server def build_server_from_config(config, section_name, server_klass=None, handler_klass=None): """ Build a server from a provided :py:class:`configparser.ConfigParser` instance. If a ServerClass or HandlerClass is specified, then the object must inherit from the corresponding AdvancedHTTPServer base class. :param config: Configuration to retrieve settings from. :type config: :py:class:`configparser.ConfigParser` :param str section_name: The section name of the configuration to use. :param server_klass: Alternative server class to use. :type server_klass: :py:class:`.AdvancedHTTPServer` :param handler_klass: Alternative handler class to use. :type handler_klass: :py:class:`.RequestHandler` :return: A configured server instance. :rtype: :py:class:`.AdvancedHTTPServer` """ server_klass = (server_klass or AdvancedHTTPServer) handler_klass = (handler_klass or RequestHandler) port = config.getint(section_name, 'port') web_root = None if config.has_option(section_name, 'web_root'): web_root = config.get(section_name, 'web_root') if config.has_option(section_name, 'ip'): ip = config.get(section_name, 'ip') else: ip = '0.0.0.0' ssl_certfile = None if config.has_option(section_name, 'ssl_cert'): ssl_certfile = config.get(section_name, 'ssl_cert') ssl_keyfile = None if config.has_option(section_name, 'ssl_key'): ssl_keyfile = config.get(section_name, 'ssl_key') ssl_version = None if config.has_option(section_name, 'ssl_version'): ssl_version = config.get(section_name, 'ssl_version') server = server_klass( handler_klass, address=(ip, port), ssl_certfile=ssl_certfile, ssl_keyfile=ssl_keyfile, ssl_version=ssl_version ) if config.has_option(section_name, 'password_type'): password_type = config.get(section_name, 'password_type') else: password_type = 'md5' if config.has_option(section_name, 'password'): password = config.get(section_name, 'password') if config.has_option(section_name, 'username'): username = config.get(section_name, 'username') else: username = '' server.auth_add_creds(username, password, pwtype=password_type) cred_idx = 0 while config.has_option(section_name, 'password' + str(cred_idx)): password = config.get(section_name, 'password' + str(cred_idx)) if not config.has_option(section_name, 'username' + str(cred_idx)): break username = config.get(section_name, 'username' + str(cred_idx)) server.auth_add_creds(username, password, pwtype=password_type) cred_idx += 1 if web_root is None: server.serve_files = False else: server.serve_files = True server.serve_files_root = web_root if config.has_option(section_name, 'list_directories'): server.serve_files_list_directories = config.getboolean(section_name, 'list_directories') return server class _RequestEmbryo(object): __slots__ = ('server', 'socket', 'address', 'created') def __init__(self, server, client_socket, address, created=None): server.request_embryos.append(self) self.server = weakref.ref(server) self.socket = client_socket self.address = address self.created = created or time.time() def fileno(self): return self.socket.fileno() def serve_ready(self): server = self.server() # server is a weakref if not server: return False try: self.socket.do_handshake() except ssl.SSLWantReadError: return False except (socket.error, OSError, ValueError): self.socket.close() server.request_embryos.remove(self) return False self.socket.settimeout(None) server.request_embryos.remove(self) server.request_queue.put((self.socket, self.address)) server.handle_request() return True class RegisterPath(object): """ Register a path and handler with the global handler map. This can be used as a decorator. If no handler is specified then the path and function will be registered with all :py:class:`.RequestHandler` instances. .. code-block:: python @RegisterPath('^test$') def handle_test(handler, query): pass """ def __init__(self, path, handler=None, is_rpc=False): """ :param str path: The path regex to register the function to. :param str handler: A specific :py:class:`.RequestHandler` class to register the handler with. :param bool is_rpc: Whether the handler is an RPC handler or not. """ self.path = path self.is_rpc = is_rpc if handler is None or isinstance(handler, str): self.handler = handler elif hasattr(handler, '__name__'): self.handler = handler.__name__ elif hasattr(handler, '__class__'): self.handler = handler.__class__.__name__ else: raise ValueError('unknown handler: ' + repr(handler)) def __call__(self, function): handler_map = g_handler_map.get(self.handler, {}) handler_map[self.path] = (function, self.is_rpc) g_handler_map[self.handler] = handler_map return function class RPCError(Exception): """ This class represents an RPC error either local or remote. Any errors in routines executed on the server will raise this error. """ def __init__(self, message, status=None, remote_exception=None): super(RPCError, self).__init__() self.message = message self.status = status self.remote_exception = remote_exception def __repr__(self): return "{0}(message='{1}', status={2}, remote_exception={3})".format(self.__class__.__name__, self.message, self.status, self.is_remote_exception) def __str__(self): if self.is_remote_exception: return 'a remote exception occurred' return "the server responded with {0} '{1}'".format(self.status, self.message) @property def is_remote_exception(self): """ This is true if the represented error resulted from an exception on the remote server. :type: bool """ return bool(self.remote_exception is not None) class RPCConnectionError(RPCError): """ An exception raised when there is a connection-related error encountered by the RPC client. .. versionadded:: 2.1.0 """ pass class RPCClient(object): """ This object facilitates communication with remote RPC methods as provided by a :py:class:`.RequestHandler` instance. Once created this object can be called directly, doing so is the same as using the call method. This object uses locks internally to be thread safe. Only one thread can execute a function at a time. """ def __init__(self, address, use_ssl=False, username=None, password=None, uri_base='/', ssl_context=None): """ :param tuple address: The address of the server to connect to as (host, port). :param bool use_ssl: Whether to connect with SSL or not. :param str username: The username to authenticate with. :param str password: The password to authenticate with. :param str uri_base: An optional prefix for all methods. :param ssl_context: An optional SSL context to use for SSL related options. """ self.host = str(address[0]) self.port = int(address[1]) if not hasattr(self, 'logger'): self.logger = logging.getLogger('AdvancedHTTPServer.RPCClient') self.headers = None """An optional dictionary of headers to include with each RPC request.""" self.use_ssl = bool(use_ssl) self.ssl_context = ssl_context self.uri_base = str(uri_base) self.username = (None if username is None else str(username)) self.password = (None if password is None else str(password)) self.lock = threading.Lock() """A :py:class:`threading.Lock` instance used to synchronize operations.""" self.serializer = None """The :py:class:`.Serializer` instance to use for encoding RPC data to the server.""" self.set_serializer('application/json') self.reconnect() def __del__(self): self.client.close() def __reduce__(self): address = (self.host, self.port) return (self.__class__, (address, self.use_ssl, self.username, self.password, self.uri_base)) def set_serializer(self, serializer_name, compression=None): """ Configure the serializer to use for communication with the server. The serializer specified must be valid and in the :py:data:`.g_serializer_drivers` map. :param str serializer_name: The name of the serializer to use. :param str compression: The name of a compression library to use. """ self.serializer = Serializer(serializer_name, charset='UTF-8', compression=compression) self.logger.debug('using serializer: ' + serializer_name) def __call__(self, *args, **kwargs): return self.call(*args, **kwargs) def encode(self, data): """Encode data with the configured serializer.""" return self.serializer.dumps(data) def decode(self, data): """Decode data with the configured serializer.""" return self.serializer.loads(data) def reconnect(self): """Reconnect to the remote server.""" self.lock.acquire() if self.use_ssl: self.client = http.client.HTTPSConnection(self.host, self.port, context=self.ssl_context) else: self.client = http.client.HTTPConnection(self.host, self.port) self.lock.release() def call(self, method, *args, **kwargs): """ Issue a call to the remote end point to execute the specified procedure. :param str method: The name of the remote procedure to execute. :return: The return value from the remote function. """ if kwargs: options = self.encode(dict(args=args, kwargs=kwargs)) else: options = self.encode(args) headers = {} if self.headers: headers.update(self.headers) headers['Content-Type'] = self.serializer.content_type headers['Content-Length'] = str(len(options)) headers['Connection'] = 'close' if self.username is not None and self.password is not None: headers['Authorization'] = 'Basic ' + base64.b64encode((self.username + ':' + self.password).encode('UTF-8')).decode('UTF-8') method = os.path.join(self.uri_base, method) self.logger.debug('calling RPC method: ' + method[1:]) try: with self.lock: self.client.request('RPC', method, options, headers) resp = self.client.getresponse() except http.client.ImproperConnectionState: raise RPCConnectionError('improper connection state') if resp.status != 200: raise RPCError(resp.reason, resp.status) resp_data = resp.read() resp_data = self.decode(resp_data) if not ('exception_occurred' in resp_data and 'result' in resp_data): raise RPCError('missing response information', resp.status) if resp_data['exception_occurred']: raise RPCError('remote method incurred an exception', resp.status, remote_exception=resp_data['exception']) return resp_data['result'] class RPCClientCached(RPCClient): """ This object builds upon :py:class:`.RPCClient` and provides additional methods for cacheing results in memory. """ def __init__(self, *args, **kwargs): cache_db = kwargs.pop('cache_db', ':memory:') super(RPCClientCached, self).__init__(*args, **kwargs) self.cache_db = sqlite3.connect(cache_db, check_same_thread=False) cursor = self.cache_db.cursor() cursor.execute('CREATE TABLE IF NOT EXISTS cache (method TEXT NOT NULL, options_hash BLOB NOT NULL, return_value BLOB NOT NULL)') self.cache_db.commit() self.cache_lock = threading.Lock() def cache_call(self, method, *options): """ Call a remote method and store the result locally. Subsequent calls to the same method with the same arguments will return the cached result without invoking the remote procedure. Cached results are kept indefinitely and must be manually refreshed with a call to :py:meth:`.cache_call_refresh`. :param str method: The name of the remote procedure to execute. :return: The return value from the remote function. """ options_hash = self.encode(options) if len(options_hash) > 20: options_hash = hashlib.new('sha1', options_hash).digest() options_hash = sqlite3.Binary(options_hash) with self.cache_lock: cursor = self.cache_db.cursor() cursor.execute('SELECT return_value FROM cache WHERE method = ? AND options_hash = ?', (method, options_hash)) return_value = cursor.fetchone() if return_value: return_value = bytes(return_value[0]) return self.decode(return_value) return_value = self.call(method, *options) store_return_value = sqlite3.Binary(self.encode(return_value)) with self.cache_lock: cursor = self.cache_db.cursor() cursor.execute('INSERT INTO cache (method, options_hash, return_value) VALUES (?, ?, ?)', (method, options_hash, store_return_value)) self.cache_db.commit() return return_value def cache_call_refresh(self, method, *options): """ Call a remote method and update the local cache with the result if it already existed. :param str method: The name of the remote procedure to execute. :return: The return value from the remote function. """ options_hash = self.encode(options) if len(options_hash) > 20: options_hash = hashlib.new('sha1', options).digest() options_hash = sqlite3.Binary(options_hash) with self.cache_lock: cursor = self.cache_db.cursor() cursor.execute('DELETE FROM cache WHERE method = ? AND options_hash = ?', (method, options_hash)) return_value = self.call(method, *options) store_return_value = sqlite3.Binary(self.encode(return_value)) with self.cache_lock: cursor = self.cache_db.cursor() cursor.execute('INSERT INTO cache (method, options_hash, return_value) VALUES (?, ?, ?)', (method, options_hash, store_return_value)) self.cache_db.commit() return return_value def cache_clear(self): """Purge the local store of all cached function information.""" with self.cache_lock: cursor = self.cache_db.cursor() cursor.execute('DELETE FROM cache') self.cache_db.commit() self.logger.info('the RPC cache has been purged') return class ServerNonThreaded(http.server.HTTPServer, object): """ This class is used internally by :py:class:`.AdvancedHTTPServer` and is not intended for use by other classes or functions. It is responsible for listening on a single address, TCP port and SSL combination. """ def __init__(self, *args, **kwargs): self.__config = kwargs.pop('config') if not hasattr(self, 'logger'): self.logger = logging.getLogger('AdvancedHTTPServer') self.allow_reuse_address = True self.request_queue = queue.Queue() self.request_embryos = [] self.using_ssl = False super(ServerNonThreaded, self).__init__(*args, **kwargs) def __repr__(self): address = self.server_address[0] if self.socket.family == socket.AF_INET: address += ':' + str(self.server_address[1]) elif self.socket.family == socket.AF_INET6: address = '[' + address + ']:' + str(self.server_address[1]) return "<{0} address: {1} ssl: {2!r}>".format(self.__class__.__name__, address, self.using_ssl) @property def read_checkable_fds(self): return [self] + self.request_embryos def get_config(self): return self.__config def get_request(self): return self.request_queue.get(block=True, timeout=None) def handle_request(self): timeout = self.socket.gettimeout() if timeout is None: timeout = self.timeout elif self.timeout is not None: timeout = min(timeout, self.timeout) try: request, client_address = self.request_queue.get(block=True, timeout=timeout) except queue.Empty: return self.handle_timeout() except OSError: return None if self.verify_request(request, client_address): try: self.process_request(request, client_address) except Exception: self.handle_error(request, client_address) self.shutdown_request(request) except: self.shutdown_request(request) raise else: self.shutdown_request(request) return None def finish_request(self, request, client_address): try: super(ServerNonThreaded, self).finish_request(request, client_address) except IOError: self.logger.warning('IOError encountered in finish_request') except KeyboardInterrupt: self.logger.warning('KeyboardInterrupt encountered in finish_request') self.shutdown() def serve_ready(self): client_socket, address = self.socket.accept() if self.using_ssl: client_socket.settimeout(0) embryo = _RequestEmbryo(self, client_socket, address) embryo.serve_ready() else: client_socket.settimeout(None) self.request_queue.put((client_socket, address)) self.handle_request() def server_bind(self, *args, **kwargs): self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) super(ServerNonThreaded, self).server_bind(*args, **kwargs) def shutdown(self, *args, **kwargs): try: self.socket.shutdown(socket.SHUT_RDWR) except socket.error: pass self.socket.close() class ServerThreaded(socketserver.ThreadingMixIn, ServerNonThreaded): """ This class is used internally by :py:class:`.AdvancedHTTPServer` and is not intended for use by other classes or functions. It is responsible for listening on a single address, TCP port and SSL combination. """ daemon_threads = True class RequestHandler(http.server.BaseHTTPRequestHandler, object): """ This is the primary http request handler class of the AdvancedHTTPServer framework. Custom request handlers must inherit from this object to be compatible. Instances of this class are created automatically. This class will handle standard HTTP GET, HEAD, OPTIONS, and POST requests. Callback functions called handlers can be registered to resource paths using regular expressions in the *handler_map* attribute for GET HEAD and POST requests and *rpc_handler_map* for RPC requests. Non-RPC handler functions that are not class methods of the request handler instance will be passed the instance of the request handler as the first argument. """ if not mimetypes.inited: mimetypes.init() # try to read system mime.types extensions_map = mimetypes.types_map.copy() extensions_map.update({ '': 'application/octet-stream', # Default '.py': 'text/plain', '.rb': 'text/plain', '.c': 'text/plain', '.h': 'text/plain', }) protocol_version = 'HTTP/1.1' wbufsize = 4096 web_socket_handler = None """An optional class to handle Web Sockets. This class must be derived from :py:class:`.WebSocketHandler`.""" def __init__(self, *args, **kwargs): self.cookies = None self.path = None self.wfile = None self._wfile = None self.server = args[2] self.headers_active = False """Whether or not the request is in the sending headers phase.""" self.handler_map = {} """The dictionary object which maps regular expressions of resources to the functions which should handle them.""" self.rpc_handler_map = {} """The dictionary object which maps regular expressions of RPC functions to their handlers.""" for map_name in (None, self.__class__.__name__): handler_map = g_handler_map.get(map_name, {}) for path, function_info in handler_map.items(): function, function_is_rpc = function_info if function_is_rpc: self.rpc_handler_map[path] = function else: self.handler_map[path] = function self.basic_auth_user = None """The name of the user if the current request is using basic authentication.""" self.query_data = None """The parameter data that has been passed to the server parsed as a dict.""" self.raw_query_data = None """The raw data that was parsed into the :py:attr:`.query_data` attribute.""" self.__config = self.server.get_config() """A reference to the configuration provided by the server.""" self.on_init() super(RequestHandler, self).__init__(*args, **kwargs) def setup(self, *args, **kwargs): ret = super(RequestHandler, self).setup(*args, **kwargs) self._wfile = self.wfile return ret def on_init(self): """ This method is meant to be over ridden by custom classes. It is called as part of the __init__ method and provides an opportunity for the handler maps to be populated with entries or the config to be customized. """ pass # over ride me def __get_handler(self, is_rpc=False): handler = None handler_map = (self.rpc_handler_map if is_rpc else self.handler_map) for (path_regex, handler) in handler_map.items(): if re.match(path_regex, self.path): break else: return (None, None) is_method = False self_handler = None if hasattr(handler, '__name__'): self_handler = getattr(self, handler.__name__, None) if self_handler is not None and (handler == self_handler.__func__ or handler == self_handler): is_method = True return (handler, is_method) def version_string(self): return self.__config['server_version'] def respond_file(self, file_path, attachment=False, query=None): """ Respond to the client by serving a file, either directly or as an attachment. :param str file_path: The path to the file to serve, this does not need to be in the web root. :param bool attachment: Whether to serve the file as a download by setting the Content-Disposition header. """ del query file_path = os.path.abspath(file_path) try: file_obj = open(file_path, 'rb') except IOError: self.respond_not_found() return self.send_response(200) self.send_header('Content-Type', self.guess_mime_type(file_path)) fs = os.fstat(file_obj.fileno()) self.send_header('Content-Length', str(fs[6])) if attachment: file_name = os.path.basename(file_path) self.send_header('Content-Disposition', 'attachment; filename=' + file_name) self.send_header('Last-Modified', self.date_time_string(fs.st_mtime)) self.end_headers() shutil.copyfileobj(file_obj, self.wfile) file_obj.close() return def respond_list_directory(self, dir_path, query=None): """ Respond to the client with an HTML page listing the contents of the specified directory. :param str dir_path: The path of the directory to list the contents of. """ del query try: dir_contents = os.listdir(dir_path) except os.error: self.respond_not_found() return if os.path.normpath(dir_path) != self.__config['serve_files_root']: dir_contents.append('..') dir_contents.sort(key=lambda a: a.lower()) displaypath = html.escape(urllib.parse.unquote(self.path), quote=True) f = io.BytesIO() encoding = sys.getfilesystemencoding() f.write(b'\n') f.write(b'\nDirectory listing for ' + displaypath.encode(encoding) + b'\n') f.write(b'\n

Directory listing for ' + displaypath.encode(encoding) + b'

\n') f.write(b'
\n
    \n') for name in dir_contents: fullname = os.path.join(dir_path, name) displayname = linkname = name # Append / for directories or @ for symbolic links if os.path.isdir(fullname): displayname = name + "/" linkname = name + "/" if os.path.islink(fullname): displayname = name + "@" # Note: a link to a directory displays with @ and links with / f.write(('
  • ' + html.escape(displayname, quote=True) + '\n').encode(encoding)) f.write(b'
\n
\n\n\n') length = f.tell() f.seek(0) self.send_response(200) self.send_header('Content-Type', 'text/html; charset=' + encoding) self.send_header('Content-Length', length) self.end_headers() shutil.copyfileobj(f, self.wfile) f.close() return def respond_not_found(self): """Respond to the client with a default 404 message.""" self.send_response_full(b'Resource Not Found\n', status=404) return def respond_redirect(self, location='/'): """ Respond to the client with a 301 message and redirect them with a Location header. :param str location: The new location to redirect the client to. """ self.send_response(301) self.send_header('Content-Length', 0) self.send_header('Location', location) self.end_headers() return def respond_server_error(self, status=None, status_line=None, message=None): """ Handle an internal server error, logging a traceback if executed within an exception handler. :param int status: The status code to respond to the client with. :param str status_line: The status message to respond to the client with. :param str message: The body of the response that is sent to the client. """ (ex_type, ex_value, ex_traceback) = sys.exc_info() if ex_type: (ex_file_name, ex_line, _, _) = traceback.extract_tb(ex_traceback)[-1] line_info = "{0}:{1}".format(ex_file_name, ex_line) log_msg = "encountered {0} in {1}".format(repr(ex_value), line_info) self.server.logger.error(log_msg, exc_info=True) status = (status or 500) status_line = (status_line or http.client.responses.get(status, 'Internal Server Error')).strip() self.send_response(status, status_line) message = (message or status_line) if isinstance(message, (str, bytes)): self.send_header('Content-Length', len(message)) self.end_headers() if isinstance(message, str): self.wfile.write(message.encode(sys.getdefaultencoding())) else: self.wfile.write(message) elif hasattr(message, 'fileno'): fs = os.fstat(message.fileno()) self.send_header('Content-Length', fs[6]) self.end_headers() shutil.copyfileobj(message, self.wfile) else: self.end_headers() return def respond_unauthorized(self, request_authentication=False): """ Respond to the client that the request is unauthorized. :param bool request_authentication: Whether to request basic authentication information by sending a WWW-Authenticate header. """ headers = {} if request_authentication: headers['WWW-Authenticate'] = 'Basic realm="' + self.__config['server_version'] + '"' self.send_response_full(b'Unauthorized', status=401, headers=headers) return def dispatch_handler(self, query=None): """ Dispatch functions based on the established handler_map. It is generally not necessary to override this function and doing so will prevent any handlers from being executed. This function is executed automatically when requests of either GET, HEAD, or POST are received. :param dict query: Parsed query parameters from the corresponding request. """ query = (query or {}) # normalize the path # abandon query parameters self.path = self.path.split('?', 1)[0] self.path = self.path.split('#', 1)[0] original_path = urllib.parse.unquote(self.path) self.path = posixpath.normpath(original_path) words = self.path.split('/') words = filter(None, words) tmp_path = '' for word in words: _, word = os.path.splitdrive(word) _, word = os.path.split(word) if word in (os.curdir, os.pardir): continue tmp_path = os.path.join(tmp_path, word) self.path = tmp_path if self.path == 'robots.txt' and self.__config['serve_robots_txt']: self.send_response_full(self.__config['robots_txt']) return self.cookies = http.cookies.SimpleCookie(self.headers.get('cookie', '')) handler, is_method = self.__get_handler(is_rpc=False) if handler is not None: try: handler(*((query,) if is_method else (self, query))) except Exception: self.respond_server_error() return if not self.__config['serve_files']: self.respond_not_found() return file_path = self.__config['serve_files_root'] file_path = os.path.join(file_path, tmp_path) if os.path.isfile(file_path) and os.access(file_path, os.R_OK): self.respond_file(file_path, query=query) return elif os.path.isdir(file_path) and os.access(file_path, os.R_OK): if not original_path.endswith('/'): # redirect browser, doing what apache does destination = self.path + '/' if self.command == 'GET' and self.query_data: destination += '?' + urllib.parse.urlencode(self.query_data, True) self.respond_redirect(destination) return for index in ['index.html', 'index.htm']: index = os.path.join(file_path, index) if os.path.isfile(index) and os.access(index, os.R_OK): self.respond_file(index, query=query) return if self.__config['serve_files_list_directories']: self.respond_list_directory(file_path, query=query) return self.respond_not_found() return def send_response(self, *args, **kwargs): if self.wfile != self._wfile: self.wfile.close() self.wfile = self._wfile super(RequestHandler, self).send_response(*args, **kwargs) self.headers_active = True # in the event that the http request is invalid, all attributes may not be defined headers = getattr(self, 'headers', {}) protocol_version = getattr(self, 'protocol_version', 'HTTP/1.0').upper() if headers.get('Connection', None) == 'keep-alive' and protocol_version == 'HTTP/1.1': connection = 'keep-alive' else: connection = 'close' self.send_header('Connection', connection) def send_response_full(self, message, content_type='text/plain; charset=UTF-8', status=200, headers=None): self.send_response(status) self.send_header('Content-Type', content_type) self.send_header('Content-Length', len(message)) if headers is not None: for header, value in headers.items(): self.send_header(header, value) self.end_headers() self.wfile.write(message) return def end_headers(self): super(RequestHandler, self).end_headers() self.headers_active = False if self.command == 'HEAD': self.wfile.flush() self.wfile = open(os.devnull, 'wb') def guess_mime_type(self, path): """ Guess an appropriate MIME type based on the extension of the provided path. :param str path: The of the file to analyze. :return: The guessed MIME type of the default if non are found. :rtype: str """ _, ext = posixpath.splitext(path) if ext in self.extensions_map: return self.extensions_map[ext] ext = ext.lower() return self.extensions_map[ext if ext in self.extensions_map else ''] def stock_handler_respond_unauthorized(self, query): """This method provides a handler suitable to be used in the handler_map.""" del query self.respond_unauthorized() return def stock_handler_respond_not_found(self, query): """This method provides a handler suitable to be used in the handler_map.""" del query self.respond_not_found() return def check_authorization(self): """ Check for the presence of a basic auth Authorization header and if the credentials contained within in are valid. :return: Whether or not the credentials are valid. :rtype: bool """ try: store = self.__config.get('basic_auth') if store is None: return True auth_info = self.headers.get('Authorization') if not auth_info: return False auth_info = auth_info.split() if len(auth_info) != 2 or auth_info[0] != 'Basic': return False auth_info = base64.b64decode(auth_info[1]).decode(sys.getdefaultencoding()) username = auth_info.split(':')[0] password = ':'.join(auth_info.split(':')[1:]) password_bytes = password.encode(sys.getdefaultencoding()) if hasattr(self, 'custom_authentication'): if self.custom_authentication(username, password): self.basic_auth_user = username return True return False if not username in store: self.server.logger.warning('received invalid username: ' + username) return False password_data = store[username] if password_data['type'] == 'plain': if password == password_data['value']: self.basic_auth_user = username return True elif hashlib.new(password_data['type'], password_bytes).digest() == password_data['value']: self.basic_auth_user = username return True self.server.logger.warning('received invalid password from user: ' + username) except Exception: pass return False def cookie_get(self, name): """ Check for a cookie value by name. :param str name: Name of the cookie value to retreive. :return: Returns the cookie value if it's set or None if it's not found. """ if not hasattr(self, 'cookies'): return None if self.cookies.get(name): return self.cookies.get(name).value return None def cookie_set(self, name, value): """ Set the value of a client cookie. This can only be called while headers can be sent. :param str name: The name of the cookie value to set. :param str value: The value of the cookie to set. """ if not self.headers_active: raise RuntimeError('headers have already been ended') cookie = "{0}={1}; Path=/; HttpOnly".format(name, value) self.send_header('Set-Cookie', cookie) def do_GET(self): if not self.check_authorization(): self.respond_unauthorized(request_authentication=True) return uri = urllib.parse.urlparse(self.path) self.path = uri.path self.query_data = urllib.parse.parse_qs(uri.query) if self.web_socket_handler is not None and self.headers.get('upgrade', '').lower() == 'websocket': self.web_socket_handler(self) # pylint: disable=not-callable return self.dispatch_handler(self.query_data) return do_HEAD = do_GET def do_POST(self): if not self.check_authorization(): self.respond_unauthorized(request_authentication=True) return content_length = int(self.headers.get('content-length', 0)) data = self.rfile.read(content_length) self.raw_query_data = data content_type = self.headers.get('content-type', '') content_type = content_type.split(';', 1)[0] self.query_data = {} try: if not isinstance(data, str): data = data.decode(self.get_content_type_charset()) if content_type.startswith('application/json'): data = json.loads(data) if isinstance(data, dict): self.query_data = dict([(i[0], [i[1]]) for i in data.items()]) else: self.query_data = urllib.parse.parse_qs(data, keep_blank_values=1) except Exception: self.respond_server_error(400) else: self.dispatch_handler(self.query_data) return def do_OPTIONS(self): available_methods = list(x[3:] for x in dir(self) if x.startswith('do_')) if 'RPC' in available_methods and not self.rpc_handler_map: available_methods.remove('RPC') self.send_response(200) self.send_header('Content-Length', 0) self.send_header('Allow', ', '.join(available_methods)) self.end_headers() def do_RPC(self): if not self.check_authorization(): self.respond_unauthorized(request_authentication=True) return data_length = self.headers.get('content-length') if data_length is None: self.send_error(411) return content_type = self.headers.get('content-type') if content_type is None: self.send_error(400, 'Missing Header: Content-Type') return try: data_length = int(self.headers.get('content-length')) data = self.rfile.read(data_length) except Exception: self.send_error(400, 'Invalid Data') return try: serializer = Serializer.from_content_type(content_type) except ValueError: self.send_error(400, 'Invalid Content-Type') return try: data = serializer.loads(data) except Exception: self.server.logger.warning('serializer failed to load data') self.send_error(400, 'Invalid Data') return if isinstance(data, (list, tuple)): meth_args = data meth_kwargs = {} elif isinstance(data, dict): meth_args = data.get('args', ()) meth_kwargs = data.get('kwargs', {}) else: self.server.logger.warning('received data does not match the calling convention') self.send_error(400, 'Invalid Data') return rpc_handler, is_method = self.__get_handler(is_rpc=True) if not rpc_handler: self.respond_server_error(501) return if not is_method: meth_args = (self,) + tuple(meth_args) response = {'result': None, 'exception_occurred': False} try: response['result'] = rpc_handler(*meth_args, **meth_kwargs) except Exception as error: response['exception_occurred'] = True exc_name = "{0}.{1}".format(error.__class__.__module__, error.__class__.__name__) response['exception'] = dict(name=exc_name, message=getattr(error, 'message', None)) self.server.logger.error('error: ' + exc_name + ' occurred while calling rpc method: ' + self.path, exc_info=True) try: response = serializer.dumps(response) except Exception: self.respond_server_error(message='Failed To Pack Response') return self.send_response(200) self.send_header('Content-Type', serializer.content_type) self.end_headers() self.wfile.write(response) return def log_error(self, msg_format, *args): self.server.logger.warning(self.address_string() + ' ' + msg_format % args) def log_message(self, msg_format, *args): self.server.logger.info(self.address_string() + ' ' + msg_format % args) def get_query(self, name, default=None): """ Get a value from the query data that was sent to the server. :param str name: The name of the query value to retrieve. :param default: The value to return if *name* is not specified. :return: The value if it exists, otherwise *default* will be returned. :rtype: str """ return self.query_data.get(name, [default])[0] def get_content_type_charset(self, default='UTF-8'): """ Inspect the Content-Type header to retrieve the charset that the client has specified. :param str default: The default charset to return if none exists. :return: The charset of the request. :rtype: str """ encoding = default header = self.headers.get('Content-Type', '') idx = header.find('charset=') if idx > 0: encoding = (header[idx + 8:].split(' ', 1)[0] or encoding) return encoding class WakeupFd(object): __slots__ = ('read_fd', 'write_fd') def __init__(self): self.read_fd, self.write_fd = os.pipe() def close(self): os.close(self.read_fd) os.close(self.write_fd) def fileno(self): return self.read_fd class WebSocketHandler(object): """ A handler for web socket connections. """ _opcode_continue = 0x00 _opcode_text = 0x01 _opcode_binary = 0x02 _opcode_close = 0x08 _opcode_ping = 0x09 _opcode_pong = 0x0a _opcode_names = { _opcode_continue: 'continue', _opcode_text: 'text', _opcode_binary: 'binary', _opcode_close: 'close', _opcode_ping: 'ping', _opcode_pong: 'pong' } guid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11' def __init__(self, handler): """ :param handler: The :py:class:`RequestHandler` instance that is handling the request. """ self.handler = handler if not hasattr(self, 'logger'): self.logger = logging.getLogger('AdvancedHTTPServer.WebSocketHandler') headers = self.handler.headers client_extensions = headers.get('Sec-WebSocket-Extensions', '') self.client_extensions = [extension.strip() for extension in client_extensions.split(',')] key = headers.get('Sec-WebSocket-Key', None) digest = hashlib.sha1((key + self.guid).encode('utf-8')).digest() handler.send_response(101, 'Switching Protocols') handler.send_header('Upgrade', 'WebSocket') handler.send_header('Connection', 'Upgrade') handler.send_header('Sec-WebSocket-Accept', base64.b64encode(digest).decode('utf-8')) handler.end_headers() handler.wfile.flush() self.lock = threading.Lock() self.connected = True self.logger.info('web socket has been connected') self.on_connected() self._last_buffer = b'' self._last_opcode = 0 self._last_sent_opcode = 0 while self.connected: try: self._process_message() except socket.error: self.logger.warning('there was a socket error while processing web socket messages') self.close() except Exception: self.logger.error('there was an error while processing web socket messages', exc_info=True) self.close() self.handler.close_connection = 1 def _decode_string(self, data): str = data.decode('utf-8') if sys.version_info[0] == 3: return str # raise an exception on surrogates in python 2.7 to more closely replicate 3.x behaviour for idx, ch in enumerate(str): if 0xD800 <= ord(ch) <= 0xDFFF: raise UnicodeDecodeError('utf-8', '', idx, idx + 1, 'invalid continuation byte') return str def _process_message(self): byte_0 = self.handler.rfile.read(1) if not byte_0: self.close() return byte_0 = ord(byte_0) if byte_0 & 0x70: self.close() return fin = bool(byte_0 & 0x80) opcode = byte_0 & 0x0f length = ord(self.handler.rfile.read(1)) & 0x7f if length == 126: length = struct.unpack('>H', self.handler.rfile.read(2))[0] elif length == 127: length = struct.unpack('>Q', self.handler.rfile.read(8))[0] masks = [b for b in self.handler.rfile.read(4)] if sys.version_info[0] < 3: masks = map(ord, masks) payload = bytearray(self.handler.rfile.read(length)) for idx, char in enumerate(payload): payload[idx] = char ^ masks[idx % 4] payload = bytes(payload) self.logger.debug("received message (len: {0:,} opcode: 0x{1:02x} fin: {2})".format(len(payload), opcode, fin)) if fin: if opcode == self._opcode_continue: opcode = self._last_opcode payload = self._last_buffer + payload self._last_buffer = b'' self._last_opcode = 0 elif self._last_buffer and opcode in (self._opcode_binary, self._opcode_text): self.logger.warning('closing connection due to unflushed buffer in new data frame') self.close() return self.on_message(opcode, payload) return if opcode > 0x02: self.logger.warning('closing connection due to fin flag not set on opcode > 0x02') self.close() return if opcode: if self._last_buffer: self.logger.warning('closing connection due to unflushed buffer in new continuation frame') self.close() return self._last_buffer = payload self._last_opcode = opcode else: self._last_buffer += payload def close(self): """ Close the web socket connection and stop processing results. If the connection is still open, a WebSocket close message will be sent to the peer. """ if not self.connected: return self.connected = False if self.handler.wfile.closed: return if select.select([], [self.handler.wfile], [], 0)[1]: with self.lock: self.handler.wfile.write(b'\x88\x00') self.handler.wfile.flush() self.on_closed() def send_message(self, opcode, message): """ Send a message to the peer over the socket. :param int opcode: The opcode for the message to send. :param bytes message: The message data to send. """ if not isinstance(message, bytes): message = message.encode('utf-8') length = len(message) if not select.select([], [self.handler.wfile], [], 0)[1]: self.logger.error('the socket is not ready for writing') self.close() return buffer = b'' buffer += struct.pack('B', 0x80 + opcode) if length <= 125: buffer += struct.pack('B', length) elif 126 <= length <= 65535: buffer += struct.pack('>BH', 126, length) else: buffer += struct.pack('>BQ', 127, length) buffer += message self._last_sent_opcode = opcode self.lock.acquire() try: self.handler.wfile.write(buffer) self.handler.wfile.flush() except Exception: self.logger.error('an error occurred while sending a message', exc_info=True) self.close() finally: self.lock.release() def send_message_binary(self, message): return self.send_message(self._opcode_binary, message) def send_message_ping(self, message): return self.send_message(self._opcode_ping, message) def send_message_text(self, message): return self.send_message(self._opcode_text, message) def on_closed(self): """ A method that can be over ridden and is called after the web socket is closed. """ pass def on_connected(self): """ A method that can be over ridden and is called after the web socket is connected. """ pass def on_message(self, opcode, message): """ The primary dispatch function to handle incoming WebSocket messages. :param int opcode: The opcode of the message that was received. :param bytes message: The data contained within the message. """ self.logger.debug("processing {0} (opcode: 0x{1:02x}) message".format(self._opcode_names.get(opcode, 'UNKNOWN'), opcode)) if opcode == self._opcode_close: self.close() elif opcode == self._opcode_ping: if len(message) > 125: self.close() return self.send_message(self._opcode_pong, message) elif opcode == self._opcode_pong: pass elif opcode == self._opcode_binary: self.on_message_binary(message) elif opcode == self._opcode_text: try: message = self._decode_string(message) except UnicodeDecodeError: self.logger.warning('closing connection due to invalid unicode within a text message') self.close() else: self.on_message_text(message) elif opcode == self._opcode_continue: self.close() else: self.logger.warning("received unknown opcode: {0} (0x{0:02x})".format(opcode)) self.close() def on_message_binary(self, message): """ A method that can be over ridden and is called when a binary message is received from the peer. :param bytes message: The message data. """ pass def on_message_text(self, message): """ A method that can be over ridden and is called when a text message is received from the peer. :param str message: The message data. """ pass def ping(self): self.send_message_ping(random_string(16)) class Serializer(object): """ This class represents a serilizer object for use with the RPC system. """ def __init__(self, name, charset='UTF-8', compression=None): """ :param str name: The name of the serializer to use. :param str charset: The name of the encoding to use. :param str compression: The compression library to use. """ if not name in g_serializer_drivers: raise ValueError("unknown serializer '{0}'".format(name)) self.name = name self._charset = charset self._compression = compression self.content_type = "{0}; charset={1}".format(self.name, self._charset) if self._compression: self.content_type += '; compression=' + self._compression @classmethod def from_content_type(cls, content_type): """ Build a serializer object from a MIME Content-Type string. :param str content_type: The Content-Type string to parse. :return: A new serializer instance. :rtype: :py:class:`.Serializer` """ name = content_type options = {} if ';' in content_type: name, options_str = content_type.split(';', 1) for part in options_str.split(';'): part = part.strip() if '=' in part: key, value = part.split('=') else: key, value = (part, None) options[key] = value # old style compatibility if name.endswith('+zlib'): options['compression'] = 'zlib' name = name[:-5] return cls(name, charset=options.get('charset', 'UTF-8'), compression=options.get('compression')) def dumps(self, data): """ Serialize a python data type for transmission or storage. :param data: The python object to serialize. :return: The serialized representation of the object. :rtype: bytes """ data = g_serializer_drivers[self.name]['dumps'](data) if sys.version_info[0] == 3 and isinstance(data, str): data = data.encode(self._charset) if self._compression == 'zlib': data = zlib.compress(data) assert isinstance(data, bytes) return data def loads(self, data): """ Deserialize the data into it's original python object. :param bytes data: The serialized object to load. :return: The original python object. """ if not isinstance(data, bytes): raise TypeError("loads() argument 1 must be bytes, not {0}".format(type(data).__name__)) if self._compression == 'zlib': data = zlib.decompress(data) if sys.version_info[0] == 3 and self.name.startswith('application/'): data = data.decode(self._charset) data = g_serializer_drivers[self.name]['loads'](data, (self._charset if sys.version_info[0] == 3 else None)) if isinstance(data, list): data = tuple(data) return data SSLSNICertificate = collections.namedtuple('SSLSNICertificate', ('hostname', 'certfile', 'keyfile')) """ The information for a certificate used by SSL's Server Name Indicator (SNI) extension. .. versionadded:: 2.2.0 .. py:attribute:: hostname The hostname string for requests which should use this certificate information. .. py:attribute:: certfile The path to the SSL certificate file on disk to use for the hostname. .. py:attribute:: keyfile The path to the SSL key file on disk to use for the hostname. """ SSLSNIEntry = collections.namedtuple('SSLSNIEntry', ('certificate', 'context')) class AdvancedHTTPServer(object): """ This is the primary server class for the AdvancedHTTPServer module. Custom servers must inherit from this object to be compatible. When no *address* parameter is specified the address '0.0.0.0' is used and the port is guessed based on if the server is run as root or not and SSL is used. """ def __init__(self, handler_klass, address=None, addresses=None, use_threads=True, ssl_certfile=None, ssl_keyfile=None, ssl_version=None): """ :param handler_klass: The request handler class to use. :type handler_klass: :py:class:`.RequestHandler` :param tuple address: The address to bind to in the format (host, port). :param tuple addresses: The addresses to bind to in the format (host, port, ssl). :param bool use_threads: Whether to enable the use of a threaded handler. :param str ssl_certfile: An SSL certificate file to use, setting this enables SSL. :param str ssl_keyfile: An SSL certificate file to use. :param ssl_version: The SSL protocol version to use. """ if addresses is None: addresses = [] if address is None and not addresses: if ssl_certfile is not None: if os.getuid(): addresses.insert(0, ('0.0.0.0', 8443, True)) else: addresses.insert(0, ('0.0.0.0', 443, True)) else: if os.getuid(): addresses.insert(0, ('0.0.0.0', 8080, False)) else: addresses.insert(0, ('0.0.0.0', 80, False)) elif address: addresses.insert(0, (address[0], address[1], ssl_certfile is not None)) self.ssl_certfile = ssl_certfile self.ssl_keyfile = ssl_keyfile if not hasattr(self, 'logger'): self.logger = logging.getLogger('AdvancedHTTPServer') self.__should_stop = threading.Event() self.__is_shutdown = threading.Event() self.__is_shutdown.set() self.__is_running = threading.Event() self.__is_running.clear() self.__server_thread = None self.__wakeup_fd = None self.__config = { 'basic_auth': None, 'robots_txt': b'User-agent: *\nDisallow: /\n', 'serve_files': False, 'serve_files_list_directories': True, # irrelevant if serve_files == False 'serve_files_root': os.getcwd(), 'serve_robots_txt': True, 'server_version': 'AdvancedHTTPServer/' + __version__ } self.sub_servers = [] """The instances of :py:class:`.ServerNonThreaded` that are responsible for listening on each configured address.""" if use_threads: server_klass = ServerThreaded else: server_klass = ServerNonThreaded for address in addresses: server = server_klass((address[0], address[1]), handler_klass, config=self.__config) use_ssl = (len(address) == 3 and address[2]) server.using_ssl = use_ssl self.sub_servers.append(server) self.logger.info("listening on {0}:{1}".format(address[0], address[1]) + (' with ssl' if use_ssl else '')) self._ssl_sni_entries = None if any([server.using_ssl for server in self.sub_servers]): self._ssl_sni_entries = {} if ssl_version is None or isinstance(ssl_version, str): ssl_version = resolve_ssl_protocol_version(ssl_version) self._ssl_ctx = ssl.SSLContext(ssl_version) self._ssl_ctx.load_cert_chain(ssl_certfile, keyfile=ssl_keyfile) if g_ssl_has_server_sni: self._ssl_ctx.set_servername_callback(self._ssl_servername_callback) for server in self.sub_servers: if not server.using_ssl: continue server.socket = self._ssl_ctx.wrap_socket(server.socket, server_side=True, do_handshake_on_connect=False) if hasattr(handler_klass, 'custom_authentication'): self.logger.debug('a custom authentication function is being used') self.auth_set(True) def _ssl_servername_callback(self, sock, hostname, context): sni_entry = self._ssl_sni_entries.get(hostname) if sni_entry: self.logger.debug('setting a new ssl context for sni hostname: %s', hostname) sock.context = sni_entry.context return None def add_sni_cert(self, hostname, ssl_certfile=None, ssl_keyfile=None, ssl_version=None): """ Add an SSL certificate for a specific hostname as supported by SSL's Server Name Indicator (SNI) extension. See :rfc:`3546` for more details on SSL extensions. In order to use this method, the server instance must have been initialized with at least one address configured for SSL. .. warning:: This method will raise a :py:exc:`RuntimeError` if either the SNI extension is not available in the :py:mod:`ssl` module or if SSL was not enabled at initialization time through the use of arguments to :py:meth:`~.__init__`. .. versionadded:: 2.0.0 :param str hostname: The hostname for this configuration. :param str ssl_certfile: An SSL certificate file to use, setting this enables SSL. :param str ssl_keyfile: An SSL certificate file to use. :param ssl_version: The SSL protocol version to use. """ if not g_ssl_has_server_sni: raise RuntimeError('the ssl server name indicator extension is unavailable') if self._ssl_sni_entries is None: raise RuntimeError('ssl was not enabled on initialization') if ssl_certfile: ssl_certfile = os.path.abspath(ssl_certfile) if ssl_keyfile: ssl_keyfile = os.path.abspath(ssl_keyfile) cert_info = SSLSNICertificate(hostname, ssl_certfile, ssl_keyfile) if ssl_version is None or isinstance(ssl_version, str): ssl_version = resolve_ssl_protocol_version(ssl_version) ssl_ctx = ssl.SSLContext(ssl_version) ssl_ctx.load_cert_chain(ssl_certfile, keyfile=ssl_keyfile) self._ssl_sni_entries[hostname] = SSLSNIEntry(context=ssl_ctx, certificate=cert_info) def remove_sni_cert(self, hostname): """ Remove the SSL Server Name Indicator (SNI) certificate configuration for the specified *hostname*. .. warning:: This method will raise a :py:exc:`RuntimeError` if either the SNI extension is not available in the :py:mod:`ssl` module or if SSL was not enabled at initialization time through the use of arguments to :py:meth:`~.__init__`. .. versionadded:: 2.2.0 :param str hostname: The hostname to delete the SNI configuration for. """ if not g_ssl_has_server_sni: raise RuntimeError('the ssl server name indicator extension is unavailable') if self._ssl_sni_entries is None: raise RuntimeError('ssl was not enabled on initialization') sni_entry = self._ssl_sni_entries.pop(hostname, None) if sni_entry is None: raise ValueError('the specified hostname does not have an sni certificate configuration') @property def sni_certs(self): """ .. versionadded:: 2.2.0 :return: Return a tuple of :py:class:`~.SSLSNICertificate` instances for each of the certificates that are configured. :rtype: tuple """ if not g_ssl_has_server_sni or self._ssl_sni_entries is None: return tuple() return tuple(entry.certificate for entry in self._ssl_sni_entries.values()) @property def server_started(self): return self.__server_thread is not None def _serve_ready(self): read_check = [self.__wakeup_fd] for sub_server in self.sub_servers: read_check.extend(sub_server.read_checkable_fds) all_read_ready, _, _ = select.select(read_check, [], []) for read_ready in all_read_ready: if isinstance(read_ready, (_RequestEmbryo, http.server.HTTPServer)): read_ready.serve_ready() def serve_forever(self, fork=False): """ Start handling requests. This method must be called and does not return unless the :py:meth:`.shutdown` method is called from another thread. :param bool fork: Whether to fork or not before serving content. :return: The child processes PID if *fork* is set to True. :rtype: int """ if fork: if not hasattr(os, 'fork'): raise OSError('os.fork is not available') child_pid = os.fork() if child_pid != 0: self.logger.info('forked child process: ' + str(child_pid)) return child_pid self.__server_thread = threading.current_thread() self.__wakeup_fd = WakeupFd() self.__is_shutdown.clear() self.__should_stop.clear() self.__is_running.set() while not self.__should_stop.is_set(): try: self._serve_ready() except socket.error: self.logger.warning('encountered socket error, stopping server') self.__should_stop.set() self.__is_shutdown.set() self.__is_running.clear() return 0 def shutdown(self): """Shutdown the server and stop responding to requests.""" self.__should_stop.set() if self.__server_thread == threading.current_thread(): self.__is_shutdown.set() self.__is_running.clear() else: if self.__wakeup_fd is not None: os.write(self.__wakeup_fd.write_fd, b'\x00') self.__is_shutdown.wait() if self.__wakeup_fd is not None: self.__wakeup_fd.close() self.__wakeup_fd = None for server in self.sub_servers: server.shutdown() @property def serve_files(self): """ Whether to enable serving files or not. :type: bool """ return self.__config['serve_files'] @serve_files.setter def serve_files(self, value): value = bool(value) if self.__config['serve_files'] == value: return self.__config['serve_files'] = value if value: self.logger.info('serving files has been enabled') else: self.logger.info('serving files has been disabled') @property def serve_files_root(self): """ The web root to use when serving files. :type: str """ return self.__config['serve_files_root'] @serve_files_root.setter def serve_files_root(self, value): self.__config['serve_files_root'] = os.path.abspath(value) @property def serve_files_list_directories(self): """ Whether to list the contents of directories. This is only honored when :py:attr:`.serve_files` is True. :type: bool """ return self.__config['serve_files_list_directories'] @serve_files_list_directories.setter def serve_files_list_directories(self, value): self.__config['serve_files_list_directories'] = bool(value) @property def serve_robots_txt(self): """ Whether to serve a default robots.txt file which denies everything. :type: bool """ return self.__config['serve_robots_txt'] @serve_robots_txt.setter def serve_robots_txt(self, value): self.__config['serve_robots_txt'] = bool(value) @property def server_version(self): """ The server version to be sent to clients in headers. :type: str """ return self.__config['server_version'] @server_version.setter def server_version(self, value): self.__config['server_version'] = str(value) def auth_set(self, status): """ Enable or disable requiring authentication on all incoming requests. :param bool status: Whether to enable or disable requiring authentication. """ if not bool(status): self.__config['basic_auth'] = None self.logger.info('basic authentication has been disabled') else: self.__config['basic_auth'] = {} self.logger.info('basic authentication has been enabled') def auth_delete_creds(self, username=None): """ Delete the credentials for a specific username if specified or all stored credentials. :param str username: The username of the credentials to delete. """ if not username: self.__config['basic_auth'] = {} self.logger.info('basic authentication database has been cleared of all entries') return del self.__config['basic_auth'][username] def auth_add_creds(self, username, password, pwtype='plain'): """ Add a valid set of credentials to be accepted for authentication. Calling this function will automatically enable requiring authentication. Passwords can be provided in either plaintext or as a hash by specifying the hash type in the *pwtype* argument. :param str username: The username of the credentials to be added. :param password: The password data of the credentials to be added. :type password: bytes, str :param str pwtype: The type of the *password* data, (plain, md5, sha1, etc.). """ if not isinstance(password, (bytes, str)): raise TypeError("auth_add_creds() argument 2 must be bytes or str, not {0}".format(type(password).__name__)) pwtype = pwtype.lower() if not pwtype in ('plain', 'md5', 'sha1', 'sha256', 'sha384', 'sha512'): raise ValueError('invalid password type, must be \'plain\', or supported by hashlib') if self.__config.get('basic_auth') is None: self.__config['basic_auth'] = {} self.logger.info('basic authentication has been enabled') if pwtype != 'plain': algorithms_available = getattr(hashlib, 'algorithms_available', ()) or getattr(hashlib, 'algorithms', ()) if pwtype not in algorithms_available: raise ValueError('hashlib does not support the desired algorithm') # only md5 and sha1 hex for backwards compatibility if pwtype == 'md5' and len(password) == 32: password = binascii.unhexlify(password) elif pwtype == 'sha1' and len(password) == 40: password = binascii.unhexlify(password) if not isinstance(password, bytes): password = password.encode('UTF-8') if len(hashlib.new(pwtype, b'foobar').digest()) != len(password): raise ValueError('the length of the password hash does not match the type specified') self.__config['basic_auth'][username] = {'value': password, 'type': pwtype} class ServerTestCase(unittest.TestCase): """ A base class for unit tests with AdvancedHTTPServer derived classes. """ server_class = AdvancedHTTPServer """The :py:class:`.AdvancedHTTPServer` class to use as the server, this can be overridden by subclasses.""" handler_class = RequestHandler """The :py:class:`.RequestHandler` class to use as the request handler, this can be overridden by subclasses.""" def __init__(self, *args, **kwargs): super(ServerTestCase, self).__init__(*args, **kwargs) self.test_resource = "/{0}".format(random_string(40)) """ A resource which has a handler set to it which will respond with a 200 status code and the message 'Hello World!' """ self.server_address = ('localhost', random.randint(30000, 50000)) self._server_kwargs = { 'address': self.server_address } if hasattr(self, 'assertRegexpMatches') and not hasattr(self, 'assertRegexMatches'): self.assertRegexMatches = self.assertRegexpMatches if hasattr(self, 'assertRaisesRegexp') and not hasattr(self, 'assertRaisesRegex'): self.assertRaisesRegex = self.assertRaisesRegexp def setUp(self): RegisterPath("^{0}$".format(self.test_resource[1:]), self.handler_class.__name__)(self._test_resource_handler) self.server = self.server_class(self.handler_class, **self._server_kwargs) self.assertTrue(isinstance(self.server, AdvancedHTTPServer)) self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.daemon = True self.server_thread.start() self.assertTrue(self.server_thread.is_alive()) self.shutdown_requested = False if len(self.server_address) == 3 and self.server_address[2]: context = ssl.create_default_context() context.check_hostname = False context.verify_mode = ssl.CERT_NONE self.http_connection = http.client.HTTPSConnection(self.server_address[0], self.server_address[1], context=context) else: self.http_connection = http.client.HTTPConnection(self.server_address[0], self.server_address[1]) self.http_connection.connect() def _test_resource_handler(self, handler, query): del query handler.send_response_full(b'Hello World!\n') return def assertHTTPStatus(self, http_response, status): """ Check an HTTP response object and ensure the status is correct. :param http_response: The response object to check. :type http_response: :py:class:`http.client.HTTPResponse` :param int status: The status code to expect for *http_response*. """ self.assertTrue(isinstance(http_response, http.client.HTTPResponse)) error_message = "HTTP Response received status {0} when {1} was expected".format(http_response.status, status) self.assertEqual(http_response.status, status, msg=error_message) def http_request(self, resource, method='GET', headers=None): """ Make an HTTP request to the test server and return the response. :param str resource: The resource to issue the request to. :param str method: The HTTP verb to use (GET, HEAD, POST etc.). :param dict headers: The HTTP headers to provide in the request. :return: The HTTP response object. :rtype: :py:class:`http.client.HTTPResponse` """ headers = (headers or {}) if not 'Connection' in headers: headers['Connection'] = 'keep-alive' self.http_connection.request(method, resource, headers=headers) time.sleep(0.025) response = self.http_connection.getresponse() response.data = response.read() return response def tearDown(self): if not self.shutdown_requested: self.assertTrue(self.server_thread.is_alive()) self.http_connection.close() self.server.shutdown() self.server_thread.join(10.0) self.assertFalse(self.server_thread.is_alive()) del self.server def main(): try: server = build_server_from_argparser() except ImportError: server = AdvancedHTTPServer(RequestHandler, use_threads=False) server.serve_files_root = '.' server.serve_files_root = (server.serve_files_root or '.') server.serve_files = True try: server.serve_forever() except KeyboardInterrupt: pass server.shutdown() logging.shutdown() return 0 if __name__ == '__main__': main() AdvancedHTTPServer-2.2.0/docs/000077500000000000000000000000001344227226200160435ustar00rootroot00000000000000AdvancedHTTPServer-2.2.0/docs/source/000077500000000000000000000000001344227226200173435ustar00rootroot00000000000000AdvancedHTTPServer-2.2.0/docs/source/advancedhttpserver.rst000066400000000000000000000024071344227226200237740ustar00rootroot00000000000000:mod:`advancedhttpserver` -- API Reference ========================================== .. module:: advancedhttpserver :synopsis: API Reference Data ---- .. data:: g_serializer_drivers :annotation: .. data:: g_ssl_has_server_sni :annotation: Functions --------- .. autofunction:: build_server_from_argparser .. autofunction:: build_server_from_config .. autofunction:: random_string .. autofunction:: resolve_ssl_protocol_version Classes ------- .. autoclass:: AdvancedHTTPServer :members: :special-members: __init__ :undoc-members: .. autoclass:: RegisterPath :members: :special-members: __init__ :undoc-members: .. autoclass:: RequestHandler :members: .. autoclass:: RPCClient :members: :special-members: __init__ :undoc-members: .. autoclass:: RPCClientCached :members: :undoc-members: .. autoclass:: Serializer :members: :special-members: __init__ :undoc-members: .. autoclass:: ServerNonThreaded :members: .. autoclass:: ServerTestCase :members: .. autoclass:: ServerThreaded :members: .. autoclass:: SSLSNICertificate .. autoclass:: WebSocketHandler :members: Exceptions ---------- .. autoexception:: RPCError :members: :undoc-members: .. autoexception:: RPCConnectionError :members: AdvancedHTTPServer-2.2.0/docs/source/conf.py000066400000000000000000000201701344227226200206420ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # AdvancedHTTPServer documentation build configuration file, created by # sphinx-quickstart on Wed Jun 4 10:53:31 2014. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os _prj_root = os.path.dirname(__file__) _prj_root = os.path.relpath(os.path.join('..', '..'), _prj_root) _prj_root = os.path.abspath(_prj_root) sys.path.insert(1, _prj_root) import advancedhttpserver # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. needs_sphinx = '1.6' add_module_names = False # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.coverage', 'sphinx.ext.intersphinx', 'sphinx.ext.viewcode' ] intersphinx_mapping = { 'python': ('https://docs.python.org/3/', None), } # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'AdvancedHTTPServer' copyright = '2013-2015, Spencer McIntyre' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = advancedhttpserver.__version__ # The full version, including alpha/beta/rc tags. release = advancedhttpserver.__version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = [] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'sphinx_rtd_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'AdvancedHTTPServerdoc' # -- Options for LaTeX output -------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'AdvancedHTTPServer.tex', u'AdvancedHTTPServer Documentation', u'Spencer McIntyre', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'advancedhttpserver', u'AdvancedHTTPServer Documentation', [u'Spencer McIntyre'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------------ # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'AdvancedHTTPServer', u'AdvancedHTTPServer Documentation', u'Spencer McIntyre', 'AdvancedHTTPServer', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' AdvancedHTTPServer-2.2.0/docs/source/index.rst000066400000000000000000000017571344227226200212160ustar00rootroot00000000000000AdvancedHTTPServer ================== AdvancedHTTPServer is a light weight module that provides a set of classes for quickly making HTTP servers for a variety of purposes. It focuses on a light and powerful design with an emphasis on portability. It was designed after and builds upon Python's standard :py:mod:`http.server` module module. AdvancedHTTPServer is released under the BSD license and can be freely distributed and packaged with other software. Features -------- AdvancedHTTPServer provides out of the box support for additional commonly needed features such as: - Threaded request handling - Binding to multiple interfaces - SSL and SNI support - Registering handler functions to HTTP resources - A default robots.txt file - Basic authentication - The HTTP verbs GET, HEAD, POST, and OPTIONS - Remote Procedure Call (RPC) over HTTP - WebSockets .. _technical-docs: .. toctree:: :caption: Technical Documentation :numbered: :maxdepth: 1 overview.rst advancedhttpserver.rst AdvancedHTTPServer-2.2.0/docs/source/overview.rst000066400000000000000000000244641344227226200217550ustar00rootroot00000000000000.. default-domain:: py .. py:currentmodule:: advancedhttpserver Getting Started =============== The AdvancedHTTPServer module is composed of two main classes which implement the bulk of the provided functionality. These two classes are :py:class:`AdvancedHTTPServer` and :py:class:`RequestHandler`. Just like Python's :py:mod:`http.server` module, the server takes a class **not an instance of a class** and is responsible for responding to individual requests at the TCP connection level. The :py:class:`RequestHandler` instance is initialized automatically by the server when a request is received. The following sections outline how to accomplish common tasks using AdvancedHTTPServer. Binding To Interfaces --------------------- Bind to a single interface using the *address* (singular) keyword argument to the :meth:`AdvancedHTTPServer.__init__` method. .. code-block:: python server = AdvancedHTTPServer(RequestHandler, address=('0.0.0.0', 8081)) .. deprecated:: 2.0.12 The *address* keyword argument has been deprecated in favor of the *addresses* keyword argument. It should not be used in new code. Bind to one or more interfaces using the *addresses* (plural) keyword argument to the :meth:`AdvancedHTTPServer.__init__` method. .. code-block:: python server = AdvancedHTTPServer(RequestHandler, addresses=( # address, port, use ssl ('0.0.0.0', 80, False), ('0.0.0.0', 8080, False) )) Enabling SSL ------------ To enable SSL, pass a PEM file path using the *ssl_certfile* keyword argument to the :meth:`AdvancedHTTPServer.__init__` method. This will be the default certificate. Additional certificates can be configured with TLS's Server Name Indication (SNI) extension using the :meth:`AdvancedHTTPServer.add_sni_cert` method. .. code-block:: python server = AdvancedHTTPServer(RequestHandler, address=('0.0.0.0', 443), ssl_certfile='/path/to/the/certificate.pem' ) An insecure, self-signed certificate suitable for testing can be created using the following openssl command: .. code-block:: shell openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout cert.pem Enabling Basic Authentication ----------------------------- Basic authentication can be enabled by adding credentials to a :class:`AdvancedHTTPServer` instance using its :meth:`AdvancedHTTPServer.auth_add_creds` method which takes a username and password. The *pwtype* keyword argument can optionally be used to specify that the password is a hash. .. code-block:: python server = AdvancedHTTPServer(RequestHandler) server.auth_add_creds('admin', 'Sup3rS3cr3t!') Using RPC --------- AdvancedHTTPServer supports a custom form of RPC over HTTP using the ``RPC`` verb. To register RPC methods in a :py:class:`RequestHandler` they must be added to the :py:attr:`RequestHandler.rpc_handler_map` dictionary. Unlike standard HTTP request handlers, RPC request handlers can take arbitrary arguments and key word arguments. To define an RPC capable :py:class:`RequestHandler`: .. code-block:: python # define a custom RequestHandler inheriting from the original class RPCHandler(RequestHandler): def on_init(self): # add to rpc_handler_map instead of handler_map self.rpc_handler_map['/xor'] = self.rpc_xor def rpc_xor(self, key, data): return ''.join(map(lambda x: chr(ord(x) ^ key), data)) # initialize the server with the custom handler server = AdvancedHTTPServer(RPCHandler) To call methods from an RPC capable :py:class:`RequestHandler`: .. code-block:: python # in this case the server is running at http://localhost:8080/ rpc = RPCClient(('localhost', 8080)) rpc('xor', 1, 'test') Passing Variables To The Request Handler ---------------------------------------- The :py:class:`RequestHandler` instance is passed the instance of the :py:class:`ServerNonThreaded` which received the request. This attribute can be used to pass forward values from the top level :py:class:`AdvancedHTTPServer` object. .. code-block:: python class DemoHandler(RequestHandler): def do_init(self): # access the value from the subserver instance self.some_value = self.server.some_value class DemoServer(AdvancedHTTPServer): def __init__(self, some_value, *args, **kwargs): # initialize the server first, this sets self.sub_servers super(DemoServer, self).__init__(*args, **kwargs) # iterate through self.sub_servers and set the attribute to forward for server in self.sub_servers: server.some_value = some_value some_value = 'Hello World!' server = DemoServer(some_value, DemoHandler) Registering Request Handlers ---------------------------- AdvancedHTTPServer provides two distinct methods of registering methods to handle either HTTP or RPC requests. These methods are provided so the user may select the one they prefer to work with. Modifying The Handler Map ^^^^^^^^^^^^^^^^^^^^^^^^^ The :py:class:`RequestHandler` class initializes the empty dictionaries for :py:attr:`RequestHandler.handler_map` and :py:attr:`RequestHandler.rpc_handler_map`. Both are keyed by a regular expression which is applied to the path of the HTTP request to find a valid handler method. These maps can be set by overriding the :py:meth:`RequestHandler.on_init` method hook. The method must take a single argument (in addition to the standard class method ``self`` argument which goes first) which is the parsed query string. .. code-block:: python class DemoHandler(RequestHandler): def on_init(self): # over ride on_init and add a generic http request handler method # this references a method which is defined later self.handler_map['^hello-world$'] = self.res_hello_world def res_hello_world(self, query): # ... return Using RegisterPath ^^^^^^^^^^^^^^^^^^ The :py:class:`RegisterPath` class can be used as a decorator to allow handler methods to be registered in the handler map. This approach does not require writing a :py:class:`RequestHandler` class and the handlers can be simple functions. The functions must take two arguments, the first is the active :py:class:`RequestHandler` instance and the second is the parsed query string. The *handler* keyword argument to :py:meth:`RegisterPath.__init__` specifies an optional :py:class:`RequestHandler` to register the handler method with. By default, the handler is treated as a global handler and is registered for all :py:class:`RequestHandler` instances. Alternatively, a specific handler can be specified either by a reference to the class or by the class's name. .. code-block:: python # register a global handler for all RequestHandler instances @RegisterPath('^register-path-global$') def register_path_global(server, query): # ... return # register a handler only for DemoHandler by it's name @RegisterPath('^register-path-name$', 'DemoHandler') def register_path_name(server, query): # ... return # register a handler only for DemoHandler by it's class reference @RegisterPath('^register-path-class$', DemoHandler) def register_path_class(server, query): # ... return Stacking RegisterPath """"""""""""""""""""" Since :py:class:`RegisterPath` does not modify or wrap the handler method it is possible to "stack" the decorators to register a single handler for multiple paths. .. code-block:: python @RegisterPath('^register-path-class-double$', DemoHandler) @RegisterPath('^register-path-class$', DemoHandler) def register_path_class(server, query): # ... return Handling Requests ----------------- HTTP requests (and RPC requests) are dispatched to handlers defined by the :py:class:`RequestHandler`. Two dictionaries exist, one for dispatching HTTP requests and another specifically for RPC requests. Both dictionaries use regular expressions as keys and functions to be called as value. Standard HTTP requests such as GET and POST use the following standard function signature: .. code-block:: python def some_http_handler(self, query): message = b'Hello World!\r\n\r\n' self.send_response(200) self.send_header('Content-Type', 'text/plain') self.send_header('Content-Length', len(message)) self.end_headers() self.wfile.write(message) return RPC requests use an arbitrary function signature supporting both positional (required) and keyword (optional) arguments. The caller must then specify these arguments as necessary following the standard Python rules. The value returned by an RPC handler is returned to the remote caller. .. code-block:: python # define an RPC handler method accepting two arguments def some_rpc_handler(self, arg1, kwarg1=None): # return None to the caller return Accessing Headers ^^^^^^^^^^^^^^^^^ Request headers can be accessed from both standard HTTP and RPC handlers through the :py:attr:`RequestHandler.headers` attribute. Header strings are **case insensitive**. .. code-block:: python def some_http_handler(self, query): # get the Accept header if it exists, otherwise an empty string accept_header = self.headers.get('Accept', '') message = b'Accept Header: ' + accept_header.encode('utf-8') self.send_response(200) self.send_header('Content-Type', 'text/plain') self.send_header('Content-Length', len(message)) self.end_headers() self.wfile.write(message) return Accessing Query Parameters ^^^^^^^^^^^^^^^^^^^^^^^^^^ HTTP requests are passed the parsed query parameters in the *query* argument to the registered handler. This parameter is a dictionary keyed by the field name with a list of the values defined for the field name. .. note:: The parsed query data uses an array for the value to store each occurrence of field. Usually it's desirable to just access the first or last instance but it is important to note that all are available. .. code-block:: python def some_http_handler(self, query): # get the value of id from the query or a list containing an empty string # so the first member can be referenced without raising an exception id_value = query.get('id', [''])[0] message = b'id value: ' + id_value.encode('utf-8') self.send_response(200) self.send_header('Content-Type', 'text/plain') self.send_header('Content-Length', len(message)) self.end_headers() self.wfile.write(message) return AdvancedHTTPServer-2.2.0/examples/000077500000000000000000000000001344227226200167315ustar00rootroot00000000000000AdvancedHTTPServer-2.2.0/examples/demo.py000077500000000000000000000057451344227226200202450ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # demo.py # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of the project nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # import logging from advancedhttpserver import * from advancedhttpserver import __version__ class DemoHandler(RequestHandler): def on_init(self): self.handler_map['^redirect-to-google$'] = lambda handler, query: self.respond_redirect('http://www.google.com/') self.handler_map['^hello-world$'] = self.res_hello_world self.handler_map['^exception$'] = self.res_exception self.rpc_handler_map['/xor'] = self.rpc_xor def res_hello_world(self, query): message = b'Hello World!\r\n\r\n' self.send_response(200) self.send_header('Content-Type', 'text/plain') self.send_header('Content-Length', len(message)) self.end_headers() self.wfile.write(message) return def rpc_xor(self, key, data): return ''.join(map(lambda x: chr(ord(x) ^ key), data)) def res_exception(self, query): raise Exception('this is an exception, oh noes!') def main(): print("AdvancedHTTPServer version: {0}".format(__version__)) logging.getLogger('').setLevel(logging.DEBUG) console_log_handler = logging.StreamHandler() console_log_handler.setLevel(logging.INFO) console_log_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(message)s")) logging.getLogger('').addHandler(console_log_handler) server = AdvancedHTTPServer(DemoHandler) #server.auth_add_creds('demouser', 'demopass') server.server_version = 'AdvancedHTTPServerDemo' try: server.serve_forever() except KeyboardInterrupt: server.shutdown() return 0 if __name__ == '__main__': main() AdvancedHTTPServer-2.2.0/examples/redirect.py000066400000000000000000000053721344227226200211130ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # redirect.py # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of the project nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # import argparse import logging import sys from advancedhttpserver import * from advancedhttpserver import __version__ class RedirectHandler(RequestHandler): target_url = 'http://127.0.0.1' def on_init(self): self.handler_map['.*'] = self.redirect def redirect(self, query): print(self.path) self.send_response(302) self.send_header('Location', self.target_url) self.end_headers() return def main(): parser = argparse.ArgumentParser(description='AdvancedHTTPServer Redirect', conflict_handler='resolve') parser.add_argument('target_url', help='the url to redirect to') arguments = parser.parse_args() RedirectHandler.target_url = arguments.target_url print("AdvancedHTTPServer version: {0}".format(__version__)) print('Redirecting to: ' + arguments.target_url) logging.getLogger('').setLevel(logging.DEBUG) console_log_handler = logging.StreamHandler() console_log_handler.setLevel(logging.INFO) console_log_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(message)s")) logging.getLogger('').addHandler(console_log_handler) server = AdvancedHTTPServer(RedirectHandler) try: server.serve_forever() except KeyboardInterrupt: server.shutdown() return 0 if __name__ == '__main__': main() AdvancedHTTPServer-2.2.0/examples/websockets.py000077500000000000000000000044421344227226200214630ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # websockets.py # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of the project nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # from advancedhttpserver import * from advancedhttpserver import __version__ class DemoWebSocketHandler(WebSocketHandler): def on_message_binary(self, message): self.send_message(self._opcode_binary, message) def on_message_text(self, message): if len(message) > 64: print(message[:61] + '...') else: print(message) self.send_message(self._opcode_text, message) class DemoHandler(RequestHandler): web_socket_handler = DemoWebSocketHandler def main(): server = build_server_from_argparser(handler_klass=DemoHandler) print("AdvancedHTTPServer version: {0}".format(__version__)) server.server_version = 'AdvancedHTTPServerDemo' try: server.serve_forever() except KeyboardInterrupt: server.shutdown() return 0 if __name__ == '__main__': main() AdvancedHTTPServer-2.2.0/setup.py000066400000000000000000000062241344227226200166310ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # setup.py # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of the SecureState Consulting nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # Homepage: https://github.com/zeroSteiner/AdvancedHTTPServer # Author: Spencer McIntyre (zeroSteiner) import os import sys base_directory = os.path.dirname(__file__) try: from setuptools import setup, find_packages except ImportError: print('This project needs setuptools in order to build. Install it using your package') print('manager (usually python-setuptools) or via pip (pip install setuptools).') sys.exit(1) with open(os.path.join(base_directory, 'README.rst'), 'r') as file_h: long_description = file_h.read() from advancedhttpserver import __version__ DESCRIPTION = """\ A standalone web server built on Python\'s BaseHTTPServer.\ """ setup( name='AdvancedHTTPServer', version=__version__, author='Spencer McIntyre', description=DESCRIPTION, long_description=long_description, url='https://github.com/zeroSteiner/AdvancedHTTPServer', license='BSD', py_modules=['advancedhttpserver'], classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'Intended Audience :: End Users/Desktop', 'Intended Audience :: Information Technology', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: BSD License', 'Operating System :: POSIX', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Topic :: Internet :: WWW/HTTP :: HTTP Servers', 'Topic :: Software Development :: Libraries :: Python Modules' ] ) AdvancedHTTPServer-2.2.0/tests.py000066400000000000000000000413411344227226200166320ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # tests.py # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above # copyright notice, this list of conditions and the following disclaimer # in the documentation and/or other materials provided with the # distribution. # * Neither the name of the project nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # import base64 import datetime import hashlib import logging import os import random import ssl import sys import time import unittest from advancedhttpserver import AdvancedHTTPServer from advancedhttpserver import RegisterPath from advancedhttpserver import RequestHandler from advancedhttpserver import RPCClient from advancedhttpserver import RPCClientCached from advancedhttpserver import RPCError from advancedhttpserver import Serializer from advancedhttpserver import ServerTestCase from advancedhttpserver import WebSocketHandler from advancedhttpserver import build_server_from_config from advancedhttpserver import has_msgpack from advancedhttpserver import random_string from advancedhttpserver import resolve_ssl_protocol_version if sys.version_info[0] < 3: import httplib http = type('http', (), {'client': httplib}) from ConfigParser import ConfigParser else: import http.client from configparser import ConfigParser try: import websocket except ImportError: has_websocket = False else: has_websocket = True if hasattr(logging, 'NullHandler'): null_handler = logging.NullHandler() else: null_handler = logging.StreamHandler(open(os.devnull, 'w')) logging.getLogger('AdvancedHTTPServer').addHandler(null_handler) ssl_context = ssl.create_default_context() ssl_context.check_hostname = False ssl_context.verify_mode = ssl.CERT_NONE test_certfile = os.path.join(os.path.dirname(__file__), 'advancedhttpserver.pem') def random_binary(size): binary_data = bytearray() for _ in range(0, size): binary_data.append(random.randint(0, 0xff)) return bytes(binary_data) class EchoWebSocketHandler(WebSocketHandler): def on_message_binary(self, message): self.send_message(self._opcode_binary, message) def on_message_text(self, message): self.send_message(self._opcode_text, message) class EchoWebSocketRequestHandler(RequestHandler): web_socket_handler = EchoWebSocketHandler class ServerHTTPTests(ServerTestCase): def _test_authentication(self, username, password): response = self.http_request(self.test_resource, 'GET') self.assertHTTPStatus(response, 401) response = self.http_request(self.test_resource, 'HEAD') self.assertHTTPStatus(response, 401) response = self.http_request(self.test_resource, 'POST') self.assertHTTPStatus(response, 401) auth_headers = {'Authorization': 'Basic ' + base64.b64encode("{0}:{1}".format(username, password).encode('utf-8')).decode('utf-8')} response = self.http_request(self.test_resource, 'GET', headers=auth_headers) self.assertHTTPStatus(response, 200) self.server.auth_set(False) response = self.http_request(self.test_resource, 'GET') self.assertHTTPStatus(response, 200) def _test_serializer_obj(self, serializer, obj, klass): obj_encoded = serializer.dumps(obj) obj_decoded = serializer.loads(obj_encoded) self.assertTrue(obj_decoded.__class__ == klass) self.assertNotEqual(obj_encoded, obj_decoded) self.assertEqual(obj_decoded, obj) def _test_serializer_hooks(self, serializer): self._test_serializer_obj(serializer, datetime.datetime.utcnow(), datetime.datetime) self._test_serializer_obj(serializer, datetime.datetime.utcnow().date(), datetime.date) self._test_serializer_obj(serializer, datetime.datetime.utcnow().time(), datetime.time) def _rpc_test_double_handler(self, handler, value): return value * 2 def _rpc_test_datetime_handler(self, handler): return datetime.datetime.now() def _rpc_test_throw_exception(self, handler): raise RuntimeError('this is an error!') def setUp(self): self.rpc_test_double = "{0}".format(random_string(40)) self.rpc_test_datetime = "{0}".format(random_string(40)) self.rpc_test_throw_exception = "{0}".format(random_string(40)) RegisterPath("/{0}".format(self.rpc_test_double), self.handler_class.__name__, is_rpc=True)(self._rpc_test_double_handler) RegisterPath("/{0}".format(self.rpc_test_datetime), self.handler_class.__name__, is_rpc=True)(self._rpc_test_datetime_handler) RegisterPath("/{0}".format(self.rpc_test_throw_exception), self.handler_class.__name__, is_rpc=True)(self._rpc_test_throw_exception) super(ServerHTTPTests, self).setUp() def build_rpc_client(self, username=None, password=None, cached=False, use_ssl=False): if cached: klass = RPCClientCached else: klass = RPCClient rpc_client = klass( self.server_address, username=username, password=password, use_ssl=use_ssl, ssl_context=ssl_context ) return rpc_client def test_authentication_hash(self): username = random_string(8) password = random_string(12) password_hash = hashlib.new('md5', password.encode('utf-8')).hexdigest() self.server.auth_add_creds(username, password_hash, 'md5') self._test_authentication(username, password) password_hash = hashlib.new('md5', password.encode('utf-8')).digest() self.server.auth_add_creds(username, password_hash, 'md5') self._test_authentication(username, password) def test_authentication_plain(self): username = random_string(8) password = random_string(12) self.server.auth_add_creds(username, password) self._test_authentication(username, password) def test_authentication_bad_credentials(self): self.server.auth_add_creds(random_string(8), random_string(12)) auth_headers = {'Authorization': 'Basic ' + base64.b64encode("{0}:{1}".format(random_string(8), random_string(12)).encode('utf-8')).decode('utf-8')} response = self.http_request(self.test_resource, 'GET', headers=auth_headers) self.assertHTTPStatus(response, 401) def test_connection_close(self): headers = {'Connection': 'close'} response = self.http_request('/' + random_string(30), 'GET', headers=headers) self.assertHTTPStatus(response, 404) self.assertIsNone(self.http_connection.sock) response = self.http_request(self.test_resource, 'GET', headers=headers) self.assertHTTPStatus(response, 200) self.assertIsNone(self.http_connection.sock) def test_connection_keep_alive(self): headers = {'Connection': 'keep-alive'} response = self.http_request('/' + random_string(30), 'GET', headers=headers) self.assertHTTPStatus(response, 404) self.assertIsNotNone(self.http_connection.sock) response = self.http_request(self.test_resource, 'GET', headers=headers) self.assertHTTPStatus(response, 200) self.assertIsNotNone(self.http_connection.sock) def test_fake_resource(self): response = self.http_request('/' + random_string(30), 'GET') self.assertHTTPStatus(response, 404) response = self.http_request('/' + random_string(30), 'POST') self.assertHTTPStatus(response, 404) def test_resolve_ssl_protocol_version(self): default_version = resolve_ssl_protocol_version() self.assertTrue(isinstance(default_version, int)) for version_constant in (a for a in dir(ssl) if a.startswith('PROTOCOL_')): version_name = version_constant[9:] version = getattr(ssl, version_constant) self.assertEqual(resolve_ssl_protocol_version(version_name), version) def test_robots_dot_text(self): response = self.http_request('/robots.txt', 'GET') self.assertHTTPStatus(response, 200) self.assertEqual(b'User-agent: *\nDisallow: /\n', response.data) self.server.serve_robots_txt = False response = self.http_request('/robots.txt', 'GET') self.assertHTTPStatus(response, 404) def test_rpc_basic(self): rpc = self.build_rpc_client() self.run_rpc_tests(rpc) @unittest.skipUnless(has_msgpack, 'this test requires the msgpack package') def test_rpc_msgpack(self): rpc = self.build_rpc_client() rpc.set_serializer('binary/message-pack') self.run_rpc_tests(rpc) def test_rpc_authentication(self): username = random_string(8) password = random_string(12) self.server.auth_add_creds(username, password) rpc = self.build_rpc_client() self.assertRaisesRegex(RPCError, r'the server responded with 401 \'Unauthorized\'', self.run_rpc_tests, rpc) rpc = self.build_rpc_client(username=username, password=random_string(12)) self.assertRaisesRegex(RPCError, r'the server responded with 401 \'Unauthorized\'', self.run_rpc_tests, rpc) rpc = self.build_rpc_client(username=username, password=password) self.run_rpc_tests(rpc) def test_rpc_cached(self): rpc = self.build_rpc_client(cached=True) dt1 = rpc.cache_call(self.rpc_test_datetime) self.assertIsInstance(dt1, datetime.datetime) time.sleep(0.5) dt2 = rpc.cache_call(self.rpc_test_datetime) self.assertIsInstance(dt2, datetime.datetime) self.assertEqual(dt1, dt2) def test_rpc_compression(self): rpc = self.build_rpc_client() rpc.set_serializer('application/json', compression='zlib') self.run_rpc_tests(rpc) def test_serializer_build(self): serializer = Serializer.from_content_type('application/json') self.assertIsInstance(serializer, Serializer) self.assertEqual(serializer.name, 'application/json') def test_serializer_json(self): serializer = Serializer('application/json') self._test_serializer_hooks(serializer) @unittest.skipUnless(has_msgpack, 'this test requires the msgpack package') def test_serializer_msgpack(self): serializer = Serializer('binary/message-pack') self._test_serializer_hooks(serializer) def test_verb_fake(self): response = self.http_request(self.test_resource, 'FAKE') self.assertHTTPStatus(response, 501) def test_verb_get(self): response = self.http_request(self.test_resource, 'GET') self.assertHTTPStatus(response, 200) self.assertTrue(b'Hello World!' in response.data) def test_verb_head(self): response = self.http_request(self.test_resource, 'HEAD') self.assertHTTPStatus(response, 200) self.assertTrue(len(response.data) == 0) def test_verb_options(self): response = self.http_request(self.test_resource, 'OPTIONS') self.assertHTTPStatus(response, 200) self.assertTrue(len(response.data) == 0) allow_header = response.getheader('Allow') self.assertIsNotNone(allow_header) should_allow = set(['POST', 'HEAD', 'RPC', 'OPTIONS', 'GET']) real_allow = set(allow_header.split(', ')) self.assertSetEqual(real_allow, should_allow) def run_rpc_tests(self, rpc): dt = rpc(self.rpc_test_datetime) self.assertIsInstance(dt, datetime.datetime) number = random.randint(0, 10000) doubled = rpc(self.rpc_test_double, number) self.assertEqual(doubled, number * 2) with self.assertRaisesRegex(RPCError, '^a remote exception occurred$'): rpc(self.rpc_test_throw_exception) class ServerHTTPSTests(ServerHTTPTests): def __init__(self, *args, **kwargs): super(ServerHTTPSTests, self).__init__(*args, **kwargs) self._server_kwargs['ssl_certfile'] = test_certfile self.server_address = (self.server_address[0], self.server_address[1], True) def build_rpc_client(self, *args, **kwargs): kwargs['use_ssl'] = True return super(ServerHTTPSTests, self).build_rpc_client(*args, **kwargs) class ServerBindHTTPTests(ServerTestCase): def __init__(self, *args, **kwargs): super(ServerBindHTTPTests, self).__init__(*args, **kwargs) self.addresses = ( ('127.0.0.1', random.randint(30000, 50000)), ('127.0.0.1', random.randint(30000, 50000), False) ) self.server_address = self.addresses[0] self._server_kwargs = { 'addresses': self.addresses } def test_bind_multiple_ports(self): for address in self.addresses: self.http_connection.close() if len(address) == 3 and address[2]: self.http_connection = http.client.HTTPSConnection(address[0], address[1], context=ssl_context) else: self.http_connection = http.client.HTTPConnection(address[0], address[1]) resp = self.http_request('/') self.assertHTTPStatus(resp, 404) class ServerBindMixTests(ServerBindHTTPTests): def __init__(self, *args, **kwargs): super(ServerBindMixTests, self).__init__(*args, **kwargs) self.addresses = ( ('127.0.0.1', random.randint(30000, 50000), True), # https ('127.0.0.1', random.randint(30000, 50000), False) # http ) self.server_address = self.addresses[0] self._server_kwargs['addresses'] = self.addresses self._server_kwargs['ssl_certfile'] = test_certfile class ServerBuildTests(unittest.TestCase): def test_build_from_config(self): config_section = random_string(8) config = ConfigParser() config.add_section(config_section) config.set(config_section, 'ip', '127.0.0.1') config.set(config_section, 'port', str(random.randint(30000, 50000))) server = build_server_from_config(config, config_section) self.assertIsInstance(server, AdvancedHTTPServer) server.shutdown() class WebSocketHTTPTests(ServerTestCase): handler_class = EchoWebSocketRequestHandler def __init__(self, *args, **kwargs): super(WebSocketHTTPTests, self).__init__(*args, **kwargs) self._ws = None def _get_ws(self): self._ws = websocket.WebSocket() self._ws.connect("ws://{0}:{1}/".format(*self.server_address)) return self._ws def tearDown(self, *args, **kwargs): super(WebSocketHTTPTests, self).tearDown(*args, **kwargs) ws = getattr(self, '_ws', None) if ws is not None and ws.connected: ws.close() @unittest.skipUnless(has_websocket, 'this test requires the websocket-client package') def test_send_message_binary(self): ws = self._get_ws() test_bytes = random_binary(32) ws.send(test_bytes, websocket.ABNF.OPCODE_BINARY) resp = ws.recv() self.assertIsInstance(resp, bytes) self.assertEqual(test_bytes, resp) return @unittest.skipUnless(has_websocket, 'this test requires the websocket-client package') def test_send_message_text(self): ws = self._get_ws() test_string = random_string(32) ws.send(test_string, websocket.ABNF.OPCODE_TEXT) resp = ws.recv() self.assertIsInstance(resp, str) self.assertEqual(test_string, resp) return @unittest.skipUnless(has_websocket, 'this test requires the websocket-client package') def test_send_ping_without_fin(self): ws = self._get_ws() ws.send_frame(websocket.ABNF.create_frame(b'ping', websocket.ABNF.OPCODE_PING, 0)) ws.recv() self.assertFalse(ws.connected) @unittest.skipUnless(has_websocket, 'this test requires the websocket-client package') def test_send_without_cont(self): ws = self._get_ws() ws.send_frame(websocket.ABNF.create_frame(random_string(10), websocket.ABNF.OPCODE_TEXT, 0)) ws.send_frame(websocket.ABNF.create_frame(random_string(10), websocket.ABNF.OPCODE_TEXT, 0)) ws.recv() self.assertFalse(ws.connected) @unittest.skipUnless(has_websocket, 'this test requires the websocket-client package') def test_binary_fragmentation(self): ws = self._get_ws() data = random_binary(32) ws.send_frame(websocket.ABNF.create_frame(data[:16], websocket.ABNF.OPCODE_BINARY, 0)) ws.send_frame(websocket.ABNF.create_frame(data[16:], websocket.ABNF.OPCODE_CONT, 1)) self.assertEqual(ws.recv(), data) @unittest.skipUnless(has_websocket, 'this test requires the websocket-client package') def test_text_fragmentation(self): ws = self._get_ws() string = random_string(32) ws.send_frame(websocket.ABNF.create_frame(string[:16], websocket.ABNF.OPCODE_TEXT, 0)) ws.send_frame(websocket.ABNF.create_frame(string[16:], websocket.ABNF.OPCODE_CONT, 1)) self.assertEqual(ws.recv(), string) class WebSocketHTTPSTests(WebSocketHTTPTests): def __init__(self, *args, **kwargs): super(WebSocketHTTPSTests, self).__init__(*args, **kwargs) self._server_kwargs['ssl_certfile'] = test_certfile self.server_address = (self.server_address[0], self.server_address[1], True) def _get_ws(self): self._ws = websocket.WebSocket(sslopt={'cert_reqs': ssl.CERT_NONE}) self._ws.connect("wss://{0}:{1}/".format(*self.server_address)) return self._ws if __name__ == '__main__': unittest.main()