def __initialize(self, config):
try:
host, port = split_host_port(config['listen'], None)
except Exception:
raise ValueError(
'Invalid "restapi" config: expected <HOST>:<PORT> for "listen", but got "{0}"'
.format(config['listen']))
if self.__listen is not None: # changing config in runtime
self.shutdown()
self.__listen = config['listen']
self.__ssl_options = self.__get_ssl_options(config)
HTTPServer.__init__(self, (host, port), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
self.__protocol = 'http'
# wrap socket with ssl if 'certfile' is defined in a config.yaml
# Sometime it's also needed to pass reference to a 'keyfile'.
if self.__ssl_options.get('certfile'):
import ssl
ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ctx.load_cert_chain(**self.__ssl_options)
self.socket = ctx.wrap_socket(self.socket, server_side=True)
self.__protocol = 'https'
return True
def __init__(self, port, session):
self._logger = logging.getLogger(self.__class__.__name__)
self.port = port
self.session = session
self.vod_fileindex = None
self.vod_download = None
self.vod_info = defaultdict(
dict
) # A dictionary containing info about the requested VOD streams.
for _ in xrange(10000):
try:
HTTPServer.__init__(self, ("127.0.0.1", self.port),
VideoRequestHandler)
self._logger.debug("Listening at %d", self.port)
break
except socket.error:
self._logger.debug("Listening failed at %d", self.port)
self.port += 1
continue
self.server_thread = None
self.daemon_threads = True
self.allow_reuse_address = True
def __init__(self,
boat,
behaviour_manager,
waypoint_manager,
server_address,
RequestHandlerClass,
bind_and_activate=True):
HTTPServer.__init__(self, server_address, RequestHandlerClass,
bind_and_activate)
log.info('boatd api listening on %s:%s', *server_address)
self.boat = boat
self.behaviour_manager = behaviour_manager
self.waypoint_manager = waypoint_manager
self.running = True
# set API endpoints for GETs
self.handles = {
'/': self.boatd_info,
'/boat': self.boat_attr,
'/relative_wind': self.relative_wind,
'/active': self.boat_active,
'/behaviours': self.behaviours,
'/waypoints': self.waypoints,
}
# set API endpoints for POSTs
self.post_handles = {
'/': self.boatd_post,
'/behaviours': self.behaviours_post,
'/waypoints': self.waypoints_post,
}
def __init__(self, server_address, RequestHandlerClass,
ssl_context=None, request_queue_size=None):
# This overrides the implementation of __init__ in python's
# SocketServer.TCPServer (which BaseHTTPServer.HTTPServer
# does not override, thankfully).
HTTPServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family,
self.socket_type)
self.ssl_context = ssl_context
if ssl_context:
class TSafeConnection(tsafe.Connection):
def settimeout(self, *args):
self._lock.acquire()
try:
return self._ssl_conn.settimeout(*args)
finally:
self._lock.release()
def gettimeout(self):
self._lock.acquire()
try:
return self._ssl_conn.gettimeout()
finally:
self._lock.release()
self.socket = TSafeConnection(ssl_context, self.socket)
self.server_bind()
if request_queue_size:
self.socket.listen(request_queue_size)
self.server_activate()
def __init__(self, boat, behaviour_manager,
server_address, RequestHandlerClass, bind_and_activate=True):
HTTPServer.__init__(self, server_address, RequestHandlerClass,
bind_and_activate)
log.info('boatd api listening on %s:%s', *server_address)
self.boat = boat
self.behaviour_manager = behaviour_manager
self.running = True
# set API endpoints for GETs
self.handles = {
'/': self.boatd_info,
'/boat': self.boat_attr,
'/wind': self.wind,
'/active': self.boat_active,
'/behaviours': self.behaviours,
}
# set API endpoints for POSTs
self.post_handles = {
'/': self.boatd_post,
'/behaviours': self.behaviours_post,
}
def __init__(self, patroni, config):
self._auth_key = base64.b64encode(config['auth'].encode(
'utf-8')).decode('utf-8') if 'auth' in config else None
host, port = config['listen'].split(':')
HTTPServer.__init__(self, (host, int(port)), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
protocol = 'http'
# wrap socket with ssl if 'certfile' is defined in a config.yaml
# Sometime it's also needed to pass reference to a 'keyfile'.
options = {
option: config[option]
for option in ['certfile', 'keyfile'] if option in config
}
if options.get('certfile'):
import ssl
self.socket = ssl.wrap_socket(self.socket,
server_side=True,
**options)
protocol = 'https'
self.connection_string = '{0}://{1}/patroni'.format(
protocol, config.get('connect_address', config['listen']))
self.patroni = patroni
self.daemon = True
def __init__(self, RequestHandlerClass):
HTTPServer.__init__(self, None, RequestHandlerClass, False)
self.requestHandler = RequestHandlerClass
# TODO provide proper limit for this queue
self.queue = TaskQueue("http-server", sys.maxint)
def __init__(self, patroni, config):
self.connection_string = 'http://{}/patroni'.format(config.get('connect_address', None) or config['listen'])
host, port = config['listen'].split(':')
HTTPServer.__init__(self, (host, int(port)), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
self.patroni = patroni
self.daemon = True
def __init__(self, addr, handler, root, userpwd):
HTTPServer.__init__(self, addr, handler)
self.root = root
self.userpwd = userpwd # WebDav Auth user:passwd
if len(userpwd) > 0:
self.auth_enable = True
else:
self.auth_enable = False
def __init__(self, addr, handler, root, userpwd):
HTTPServer.__init__(self, addr, handler)
self.root = root
self.userpwd = userpwd # WebDAV Auth user:passwd
if len(userpwd)>0:
self.auth_enable = True
else:
self.auth_enable = False
def __init__(self):
"""Create the stub and start listening on a local port"""
# Choose a local open port
address = ('', 0)
# Start the server
HTTPServer.__init__(self, address, GradingRequestHandler)
self.start()
def __init__(self, server_address, handler, impl, meta):
'''
:param server_address: address of the server
:param handler: handler for requests
:param impl: reference to the implementation object
'''
HTTPServer.__init__(self, server_address, handler)
self.impl = impl
self.meta = meta
def __init__(self, server_address, handler, impl, meta):
'''
:param server_address: address of the server
:param handler: handler for requests
:param impl: reference to the implementation object
'''
HTTPServer.__init__(self, server_address, handler)
self.impl = impl
self.meta = meta
def __init__(self, store, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
self.sessions = {}
self.store = store
if self.server_port != 80:
self.base_url = ('http://%s:%s/' %
(self.server_name, self.server_port))
else:
self.base_url = 'http://%s/' % (self.server_name, )
def __init__(self, store, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
self.sessions = {}
self.store = store
if self.server_port != 80:
self.base_url = ('http://%s:%s/' %
(self.server_name, self.server_port))
else:
self.base_url = 'http://%s/' % (self.server_name,)
def __httpserver_init(self, host, port):
dual_stack = self.__has_dual_stack()
if host in ('', '*'):
host = None
info = socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
# in case dual stack is not supported we want IPv4 to be preferred over IPv6
info.sort(key=lambda x: x[0] == socket.AF_INET, reverse=not dual_stack)
self.address_family = info[0][0]
HTTPServer.__init__(self, info[0][-1][:2], RestApiHandler)
def __init__(self):
"""Start listening on a local port for responses from the xqueue"""
# Create an empty list in which to store request records
self._request_list = []
# Choose an open local port
address = ('', 0)
# Create and start the server
HTTPServer.__init__(self, address, LoggingRequestHandler)
self.start()
def __init__(self, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
if self.server_port != 80:
self.base_url = ('http://%s:%s/' %
(self.server_name, self.server_port))
else:
self.base_url = 'http://%s/' % (self.server_name,)
self.openid = None
self.approved = {}
self.lastCheckIDRequest = {}
def __init__(self, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
if self.server_port != 80:
self.base_url = ('http://%s:%s/' %
(self.server_name, self.server_port))
else:
self.base_url = 'http://%s/' % (self.server_name, )
self.openid = None
self.approved = {}
self.lastCheckIDRequest = {}
def __init__(
self,
crl_url_path,
crl_directory,
server_address,
RequestHandlerClass,
):
if not crl_url_path.endswith('/'):
raise ValueError("crl_url_path %r must end with a slash" %
crl_url_path)
self.crl_url_path = crl_url_path
self.crl_directory = crl_directory
HTTPServer.__init__(self, server_address, RequestHandlerClass)
def __init__(self, port_num,
response={'username': '******', 'external_id': 1}):
'''
Initialize the mock Comment Service server instance.
*port_num* is the localhost port to listen to
*response* is a dictionary that will be JSON-serialized
and sent in response to comment service requests.
'''
self._response_str = json.dumps(response)
handler = MockCommentServiceRequestHandler
address = ('', port_num)
HTTPServer.__init__(self, address, handler)
def __init__(self,
server_address,
RequestHandlerClass,
client_id,
client_secret,
bind_and_activate=True):
HTTPServer.__init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=bind_and_activate)
self.logger = logging.getLogger('auth_server.http')
self.client_id = client_id
self.client_secret = client_secret
self.listening_event = threading.Event()
def __init__(self, response='', address=None):
self.received = None
self.response = response
if address!=None:
HTTPServer.__init__(self, address, handler)
else:
for port in range(1024,65536):
try:
HTTPServer.__init__(self, ('localhost', port), handler)
except socket.error as e:
if e.errno!=98: # Address already in use
raise
else:
break
else:
raise Exception('No open ports')
def __httpserver_init(self, host, port):
dual_stack = self.__has_dual_stack()
if host in ('', '*'):
host = None
info = socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE)
# in case dual stack is not supported we want IPv4 to be preferred over IPv6
info.sort(key=lambda x: x[0] == socket.AF_INET, reverse=not dual_stack)
self.address_family = info[0][0]
try:
HTTPServer.__init__(self, info[0][-1][:2], RestApiHandler)
except socket.error:
logger.error(
"Couldn't start a service on '%s:%s', please check your `restapi.listen` configuration", host, port)
raise
def __initialize(self, config):
self.__ssl_options = self.__get_ssl_options(config)
self.__listen = config['listen']
host, port = config['listen'].rsplit(':', 1)
HTTPServer.__init__(self, (host, int(port)), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
self.__protocol = 'http'
# wrap socket with ssl if 'certfile' is defined in a config.yaml
# Sometime it's also needed to pass reference to a 'keyfile'.
if self.__ssl_options.get('certfile'):
import ssl
self.socket = ssl.wrap_socket(self.socket, server_side=True, **self.__ssl_options)
self.__protocol = 'https'
self.__set_connection_string(config.get('connect_address'))
def __initialize(self, config):
self.__ssl_options = self.__get_ssl_options(config)
self.__listen = config['listen']
host, port = config['listen'].split(':')
HTTPServer.__init__(self, (host, int(port)), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
self.__protocol = 'http'
# wrap socket with ssl if 'certfile' is defined in a config.yaml
# Sometime it's also needed to pass reference to a 'keyfile'.
if self.__ssl_options.get('certfile'):
import ssl
self.socket = ssl.wrap_socket(self.socket, server_side=True, **self.__ssl_options)
self.__protocol = 'https'
self.__set_connection_string(config.get('connect_address'))
def __init__(self, port_num=0):
"""
Configure the server to listen on localhost.
Default is to choose an arbitrary open port.
"""
address = ('0.0.0.0', port_num)
HTTPServer.__init__(self, address, self.HANDLER_CLASS)
# Create a dict to store configuration values set by the client
self.config = dict()
# Start the server in a separate thread
server_thread = threading.Thread(target=self.serve_forever)
server_thread.daemon = True
server_thread.start()
# Log the port we're using to help identify port conflict errors
LOGGER.debug('Starting service on port {0}'.format(self.port))
def __init__(self, patroni, config):
self._auth_key = base64.b64encode(config['auth'].encode('utf-8')).decode('utf-8') if 'auth' in config else None
host, port = config['listen'].split(':')
HTTPServer.__init__(self, (host, int(port)), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
protocol = 'http'
# wrap socket with ssl if 'certfile' is defined in a config.yaml
# Sometime it's also needed to pass reference to a 'keyfile'.
options = {option: config[option] for option in ['certfile', 'keyfile'] if option in config}
if options.get('certfile'):
import ssl
self.socket = ssl.wrap_socket(self.socket, server_side=True, **options)
protocol = 'https'
self.connection_string = '{0}://{1}/patroni'.format(protocol, config.get('connect_address', config['listen']))
self.patroni = patroni
self.daemon = True
def __init__(self, patroni, config):
self._auth_key = base64.b64encode(config["auth"].encode("utf-8")).decode("utf-8") if "auth" in config else None
host, port = config["listen"].split(":")
HTTPServer.__init__(self, (host, int(port)), RestApiHandler)
Thread.__init__(self, target=self.serve_forever)
self._set_fd_cloexec(self.socket)
protocol = "http"
# wrap socket with ssl if 'certfile' is defined in a config.yaml
# Sometime it's also needed to pass reference to a 'keyfile'.
options = {option: config[option] for option in ["certfile", "keyfile"] if option in config}
if options.get("certfile", None):
import ssl
self.socket = ssl.wrap_socket(self.socket, server_side=True, **options)
protocol = "https"
self.connection_string = "{}://{}/patroni".format(protocol, config.get("connect_address", config["listen"]))
self.patroni = patroni
self.daemon = True
def __init__(self, port, session):
self._logger = logging.getLogger(self.__class__.__name__)
self.port = port
self.session = session
self.vod_fileindex = None
self.vod_download = None
self.vod_info = defaultdict(dict) # A dictionary containing info about the requested VOD streams.
for _ in xrange(10000):
try:
HTTPServer.__init__(self, ("127.0.0.1", self.port), VideoRequestHandler)
self._logger.debug("Listening at %d", self.port)
break
except socket.error:
self._logger.debug("Listening failed at %d", self.port)
self.port += 1
continue
self.server_thread = None
self.daemon_threads = True
self.allow_reuse_address = True
def __init__(self, RequestHandlerClass):
HTTPServer.__init__(self, None, RequestHandlerClass, False)
self.requestHandler = RequestHandlerClass
self.queue = TaskQueue("http-server", _MAX_QUEUE_TASKS)
def __init__(self, server, routes=(), static_dirs=(), *args, **kwargs):
self._server = server
self._routes.extend(routes)
self._static_dirs.extend(static_dirs)
HTTPServer.__init__(self, *args, **kwargs)
def do_bind(self):
"""Perform HTTP server binding and activation."""
HTTPServer.__init__(self, (self.host, self.port), HTTPRequestHandler)
def __init__(self, address, handler):
HTTPServer.__init__(self, address, handler)
self.response_queue = queue.Queue()
def __init__(self, server_address, RequestHandlerClass, client_id, client_secret, bind_and_activate=True):
HTTPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate=bind_and_activate)
self.logger = logging.getLogger('auth_server.http')
self.client_id = client_id
self.client_secret = client_secret
self.listening_event = threading.Event()
def __init__(self, timeout=-1):
self.timeout = None if timeout < 0 else timeout
self.__methods__ = {}
self.__methods__.update(self._setup(self))
HTTPServer.__init__(self, self._localhost(), RequestHandler)
log("httpd: server started on: {}".format(self.server_address))
def __init__(self, client, subscription_manager, *args, **kwargs):
self.client = client
self.subscription_manager = subscription_manager
HTTPServer.__init__(self, *args, **kwargs)
def __init__(self, RequestHandlerClass):
HTTPServer.__init__(self, None, RequestHandlerClass, False)
self.requestHandler = RequestHandlerClass
self.queue = TaskQueue("http-server", _MAX_QUEUE_TASKS)
def __init__(self, address, handler):
HTTPServer.__init__(self, address, handler)
self.response_queue = queue.Queue()
def __init__(self, server_address, request_handler, path):
self.path = path
HTTPServer.__init__(self, server_address, request_handler)
def __init__(self, base_path, *args, **kwargs):
HTTPServer.__init__(self, *args, **kwargs)
self.RequestHandlerClass.base_path = base_path
def __init__(self, server_address, request_handler, path):
self.path = path
HTTPServer.__init__(self, server_address, request_handler)
def do_bind(self):
"""Perform HTTP server binding and activation."""
HTTPServer.__init__(self, (self.host, self.port), HTTPRequestHandler)
def __init__(self, server_address, RequestHandlerClass,
ssl_context=None, request_queue_size=None):
assert not ssl_context, "pyOpenSSL not installed"
HTTPServer.__init__(self, server_address, RequestHandlerClass)
if request_queue_size:
self.socket.listen(request_queue_size)