def main(args=None, default_port=8000):
""" Run the echo HTTP server. """
args = build_arg_parser().parse_args(args)
port = args.port
if port is None:
port = default_port
bound = False
while not bound:
try:
httpd = BaseHTTPServer.HTTPServer((args.address, port),
EchoHTTPRequestHandler)
except socket.error:
port += 1
if port > 65535:
raise ValueError("No available port found")
else:
bound = True
else:
httpd = BaseHTTPServer.HTTPServer((args.address, int(port)),
EchoHTTPRequestHandler)
print("httpd-echo, Copyright © 2017 rpatterson, 2021 Greg Werbin")
print("This program comes with ABSOLUTELY NO WARRANTY.")
print(
"This is Free Software, and you are welcome to redistribute it under certain conditions."
)
print("Echoing HTTP at http://{0}:{1} ...".format(args.address, port))
httpd.serve_forever()
def manual_flow(self):
params = {
'client_id': self.client_id,
'redirect_uri': self.redirect_uri,
'response_type': 'code',
'scope': 'all',
'state': str(uuid.uuid4()),
}
query = urllib.parse.urlencode(params)
url_parts = ('https', self.host, self.authorize_endpoint, None,
query, None)
url = urllib.parse.urlunparse(url_parts)
webbrowser.open_new(url)
server_address = ('', self.port)
httpd = BaseHTTPServer.HTTPServer(server_address, OAuthResponseHandler)
sa = httpd.socket.getsockname()
print('Server started on {}:{}...'.format(sa[0], sa[1]))
httpd.handle_request()
if httpd.query_params.get('state') == params['state']:
code = httpd.query_params.get('code')
credentials = self.request_access_token('authorization_code',
code=code)
return credentials
def start_http_server(image_id, image_data):
def _get_http_handler_class(fixture):
class StaticHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header('Content-Length', str(len(fixture)))
self.end_headers()
self.wfile.write(fixture)
return
def do_HEAD(self):
self.send_response(200)
self.send_header('Content-Length', str(len(fixture)))
self.end_headers()
return
def log_message(self, *args, **kwargs):
# Override this method to prevent debug output from going
# to stderr during testing
return
return StaticHTTPRequestHandler
server_address = ('127.0.0.1', 0)
handler_class = _get_http_handler_class(image_data)
httpd = BaseHTTPServer.HTTPServer(server_address, handler_class)
port = httpd.socket.getsockname()[1]
pid = os.fork()
if pid == 0:
httpd.serve_forever()
else:
return pid, port
def get_webdriver_request_headers(webdriver):
# There's a small chance that the port was taken since the call of
# get_unused_port(), so make sure we try as often as needed
while True:
port = get_unused_port()
try:
server = BaseHTTPServer.HTTPServer(('', port), HTTPRequestHandler)
logger.info("监听PORT："+str(port))
break
except socket.error:
pass
threading.Thread(target=server.handle_request).start()
original_window_handle = webdriver.current_window_handle
# webdriver.execute_script("window.open('http://127.0.0.1:%d/');" % port)
requests.get("http://127.0.0.1:%d/" % port)
update_headers_mutex.acquire()
# Possibly optional: Make sure that the webdriver didn't switch the window
# handle to the newly opened window. Behaviors of different webdrivers seem
# to differ greatly here
if webdriver.current_window_handle != original_window_handle:
webdriver.switch_to.window(original_window_handle)
global headers
headers_ = headers
headers = None
# Remove the host header, which will simply contain the localhost address
# of the HTTPRequestHandler instance
del headers_['host']
return headers_
def get_webdriver_request_headers(webdriver):
# There's a small chance that the port was taken since the call of get_unused_port(), so make sure we try as often
# as needed
while True:
port = get_unused_port()
try:
server = BaseHTTPServer.HTTPServer(('', port), HTTPRequestHandler)
break
except socket.error:
pass
threading.Thread(target=server.handle_request).start()
original_window_handle = webdriver.current_window_handle
webdriver.execute_script("window.open('http://127.0.0.1:%d/', '_blank');" % port)
update_headers_mutex.acquire()
# Not optional: Make sure that the webdriver didn't switch the window handle to the newly opened window. Behaviors
# of different webdrivers seem to differ here. Workaround for Firefox: If a new window is opened via JavaScript as a
# new tab, requesting self.current_url never returns. Explicitly switching to the current window handle again seems
# to fix this issue.
webdriver.switch_to.window(original_window_handle)
global headers
headers_ = headers
headers = None
# Remove the host header, which will simply contain the localhost address of the HTTPRequestHandler instance
del headers_['host']
return headers_
def __init__(self, port):
class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_POST(self):
def verify(signature, data):
try:
sha, signature = signature.split('=')
except ValueError:
return False
if sha != 'sha1':
return False
mac = hmac.new(os.environb.get(b'SECRET', bytes()), data,
hashlib.sha1)
return hmac.compare_digest(mac.hexdigest(), signature)
length = int(self.headers.get('Content-Length', 0))
data = self.rfile.read(length)
if not verify(self.headers.get('X-Hub-Signature'), data):
self.send_error(403)
return
event = self.headers.get('X-GitHub-Event')
if event == 'ping':
self.send_response(200)
return
if event == 'release':
data = json.loads(data)
url = data.get('clone_url')
tag = data.get('release', {}).get('tag_name')
PyPI.release(url, tag)
self.send_response(200)
self.server = BaseHTTPServer.HTTPServer(('', port), RequestHandler)
def __init__(self):
self.received = []
self.paused = False
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_POST(handler):
start = time.time()
while self.paused:
if time.time() > (start + 0.5):
raise Exception('Paused HTTP server timeout')
time.sleep(0.001)
length = int(handler.headers['Content-Length'])
raw_body = handler.rfile.read(length).decode('utf-8')
if handler.path != '/ignore':
self.received.append({'headers': handler.headers,
'json_body': json.loads(raw_body),
'path': handler.path,
'method': handler.command})
handler.send_response(200)
handler.end_headers()
return ()
def log_request(self, *args):
pass
self.server = BaseHTTPServer.HTTPServer(('localhost', 0), Handler)
self.server.timeout = 0.5
self.thread = Thread(target=self.server.serve_forever, args=(0.1,))
self.thread.daemon = True
self.thread.start()
def _make_server(port, request_handler):
server = BaseHTTPServer.HTTPServer(("localhost", port), request_handler)
t = threading.Thread(target=server.serve_forever)
# Set daemon just in case something fails
t.daemon = True
t.start()
return server, t
def on_server_start(self):
"""Initialize service."""
handler = AMTServerHandler
handler.emit = self.add_alert_to_queue
self.server = BaseHTTPServer.HTTPServer(("0.0.0.0", AMT_PORT), handler)
self.signal_ready()
self.server.serve_forever()
def __init__(self, port, cert, root, report_size):
class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
path = self.path.split('?', 1)[0].split('#', 1)[0]
path = urllib.parse.unquote(path)
path = posixpath.normpath(path)
path = os.path.join(root, path.lstrip('/'))
try:
with open(path, 'rb') as f:
data = f.read()
self.send_response(200)
content_type = 'application/json' if 'versioneers' in path else 'application/octet-stream'
self.send_header('Content-Type', content_type)
self.send_header('Content-Transfer-Encoding', 'binary')
if report_size:
self.send_header('Content-Length', len(data))
self.end_headers()
self.wfile.write(data)
except FileNotFoundError:
self.send_error(404)
self.server = BaseHTTPServer.HTTPServer(('', port), RequestHandler)
if cert:
self.server.socket = ssl.wrap_socket(self.server.socket, certfile=cert, server_side=True)
def start_server():
class OAuthRedirectHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
parsed_path = urlparse(self.path)
query = parse_qs(parsed_path.query)
access_token = query["access_token"][
0] if "access_token" in query else None
if not access_token:
print("Something went wrong! Please try again.")
sys.exit()
print("Access token auto-detected!")
access_token_queue.put(access_token)
# Redirect user's browser
self.send_response(301)
self.send_header(
"Location", "{}/{}".format(get_base_http_url(),
"/oauth/github/success"))
self.end_headers()
# Silence logs
def log_message(self, _format, *args):
return
server = BaseHTTPServer.HTTPServer((LOOPBACK, port),
OAuthRedirectHandler)
server_started_queue.put(True)
server.handle_request()
def __init__(self, cb, listening_address, **kwargs):
super(EventForwarderHTTPSource, self).__init__()
self.daemon = True
http_parts = urllib.parse.urlparse(listening_address)
addr_parts = http_parts.netloc.split(":")
listening_host = addr_parts[0]
if len(addr_parts) == 2:
port = int(addr_parts[1])
listening_host = addr_parts[0]
else:
if http_parts.scheme == "https":
port = 443
else:
port = 80
self.listening_address = listening_address
self.httpd = BaseHTTPServer.HTTPServer(
(listening_host, port), SimpleHTTPServer.SimpleHTTPRequestHandler)
if http_parts.scheme == "https":
keyfile = kwargs.get("keyfile", None)
certfile = kwargs.get("certfile", None)
if not keyfile or not certfile:
raise CredentialError(
"Need to specify 'keyfile' and 'certfile' for HTTPS")
self.httpd.socket = ssl.wrap_socket(self.httpd.socket,
certfile=certfile,
keyfile=keyfile,
server_side=True)
def test_list_fail(lib):
proxy = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock)
proxy.expectations = [
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (501, {}, "")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {}, "")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {},
"lskj")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""), (200, {},
"{}")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {}, "{\"objects\":[]}")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {}, "{\"prefixes\":[]}")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {}, "{\"objects\":[]\"prefixes\":[]}")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {}, "{\"objects\":[{}]\"prefixes\":[]}")),
]
proxy_url = str(proxy.server_name) + ':' + str(proxy.server_port)
service = Service(proxy)
service.start()
cfg = json.dumps({"NS": {"proxy": proxy_url}}).encode('utf-8')
try:
lib.test_init(cfg, b"NS")
lib.test_list_badarg(cfg, b"NS")
while len(proxy.expectations) > 0:
# invalid HTTP reply status
lib.test_list_fail(cfg, b"NS", b"NS/ACCT/JFS")
assert (0 == len(proxy.expectations))
finally:
proxy.shutdown()
service.join()
def __init__(self, is_chief):
self._init()
self._lock = Lock()
self._thread = None
self.started = False
self.is_chief = is_chief
if is_chief:
self._httpd = BaseHTTPServer.HTTPServer((FLAGS.coord_host, FLAGS.coord_port), TrainingCoordinator.make_handler(self))
def start_mock_server(port, daemon=True):
mock_server = BaseHTTPServer.HTTPServer(('localhost', port),
MockServerRequestHandler)
mock_server_thread = Thread(target=mock_server.serve_forever)
if daemon:
mock_server_thread.setDaemon(True)
mock_server_thread.start()
return mock_server
def __init__(self, ota_filename, serving_range):
threading.Thread.__init__(self)
# serving_payload and serving_range are class attributes and the
# UpdateHandler class is instantiated with every request.
UpdateHandler.serving_payload = ota_filename
UpdateHandler.serving_range = serving_range
self._httpd = BaseHTTPServer.HTTPServer(('127.0.0.1', 0), UpdateHandler)
self.port = self._httpd.server_port
def run_server(root, server_address, initialized):
os.chdir(root)
SimpleHTTPRequestHandler.protocol_version = "HTTP/1.0"
httpd = BaseHTTPServer.HTTPServer(server_address, SimpleHTTPRequestHandler)
sa = httpd.socket.getsockname()
print("Serving HTTP on {0} port {1}...".format(sa[0], sa[1]))
initialized.set()
httpd.serve_forever()
def __init__(self, processor, address, proto_factory):
"""Initialize an FHttpServer.
Args:
processor: FProcessor used to process requests.
address: tuple of host name and port.
proto_factory: FProtocolFactory used to read requests and write
responses.
"""
class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_POST(self):
length = self.headers.getheader('Content-Length')
payload = b64decode(self.rfile.read(int(length)))
response_limit = int(self.headers.getheader(
'x-frugal-payload-limit', 0))
if len(payload) <= 4:
logging.exception(
'Invalid request frame length {}'.format(len(payload)))
self.send_response(400)
self.end_headers()
return
itrans = TTransport.TMemoryBuffer(payload[4:])
otrans = TTransport.TMemoryBuffer()
iprot = proto_factory.get_protocol(itrans)
oprot = proto_factory.get_protocol(otrans)
try:
processor.process(iprot, oprot)
except TApplicationException:
# Continue so the exception is sent to the client
pass
except Exception:
self.send_response(400)
self.end_headers()
return
# Encode response.
response = otrans.getvalue()
if len(response) > response_limit > 0:
self.send_response(413)
self.end_headers()
return
frame_length = pack('!I', len(response))
frame = b64encode(frame_length + response)
self.send_response(200)
self.send_header('Content-Type', 'application/x-frugal')
self.send_header('Content-Length', len(frame))
self.send_header('Content-Transfer-Encoding', 'base64')
self.end_headers()
self.wfile.write(frame)
self._httpd = BaseHTTPServer.HTTPServer(address, RequestHandler)
def start_server(self):
def do_GET(self):
"""Serve a GET request."""
f = self.send_head()
if f:
try:
self.copyfile(f, self.wfile)
finally:
f.close()
t = threading.Thread(target=self.server.shutdown)
t.daemon = True
t.start()
print(
'File transfer was completed.Server is shutdowning.....'
)
def translate_path(self, path):
"""Translate a /-separated PATH to the local filename syntax.
Components that mean special things to the local file system
(e.g. drive or directory names) are ignored. (XXX They should
probably be diagnosed.)
"""
import posixpath
from six.moves.urllib_parse import unquote
# abandon query parameters
path = path.split('?', 1)[0]
path = path.split('#', 1)[0]
# Don't forget explicit trailing slash when normalizing. Issue17324
trailing_slash = path.rstrip().endswith('/')
path = posixpath.normpath(unquote(path))
words = filter(None, path.split('/'))
path = to_abs_path()
for word in words:
if os.path.dirname(word) or word in (os.curdir, os.pardir):
# Ignore components that are not a simple file/directory name
continue
path = os.path.join(path, word)
if trailing_slash:
path += '/'
return path
print('Starting Server.....')
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET = do_GET
SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path = translate_path
try:
server = BaseHTTPServer.HTTPServer(
('', self.port), SimpleHTTPServer.SimpleHTTPRequestHandler)
except Exception as e:
print(e)
print('Server has already started')
else:
thread = threading.Thread(target=server.serve_forever,
name='server')
thread.deamon = True
thread.start()
thread.join()
os.remove(self.send_path)
def __init__(self):
sock = socket.socket()
sock.bind(('', 0))
self.port = sock.getsockname()[1]
self.blocking = True
self._server = BaseHTTPServer.HTTPServer(('127.0.0.1', self.port),
CallbackHandler)
self._server.result = {}
self._server.stop = self.stop
def __init__(self, test_server_spawner_port, port_forwarder, max_instances):
self.server = BaseHTTPServer.HTTPServer(('', test_server_spawner_port),
SpawningServerRequestHandler)
self.server_port = self.server.server_port
_logger.info('Started test server spawner on port: %d.', self.server_port)
self.server.port_forwarder = port_forwarder
self.server.test_servers = {}
self.server.max_instances = max_instances
def __init__(self, is_chief):
self._init()
self._lock = Lock()
self._thread = None
self.started = False
self.is_chief = is_chief
if is_chief:
self._httpd = BaseHTTPServer.HTTPServer(
('localhost', 2500), TrainingCoordinator.make_handler(self))
def __init__(self, port):
Thread.__init__(self)
self.port = port
self.uri = 'http://localhost:%d' % port
self.server = BaseHTTPServer.HTTPServer(('localhost', port),
MockServerRequestHandler)
self.server.server_wrapper = self
self.matchers = {}
self.requests = queue.Queue()
def run_ssl_server():
cert_file = os.path.join(CERTIFICATE_DIR, 'server.pem')
httpd = BaseHTTPServer.HTTPServer((SSL_SERVER_ADDRESS, SSL_SERVER_PORT), StandaloneAppsResponseHandler)
httpd.socket = ssl.wrap_socket(httpd.socket, certfile=cert_file, server_side=False)
httpd.timeout = 5
threading.Thread(target=httpd.handle_request).start()
time.sleep(0.5)
return httpd
def main(port=8000):
server = BaseHTTPServer.HTTPServer(('0.0.0.0', port), SimpleHTTPRequestHandler)
try:
print('Serving HTTP on 0.0.0.0 port %d ...' % port)
print('local IP address is %s' % globals()['_stash'].libcore.get_lan_ip())
server.serve_forever()
except KeyboardInterrupt:
print('Server shutting down ...')
server.server_close()
def main(_):
server_address = ('localhost', FLAGS.port)
clusters = load_clusters(FLAGS.clusters_path)
# Default to overwriting the input.
output_path = FLAGS.output_path or FLAGS.clusters_path
def create_request_handler(*args):
return handler.LabelerHTTPRequestHandler(clusters, output_path, *args)
server = BaseHTTPServer.HTTPServer(server_address, create_request_handler)
print('Listening on port %d...', FLAGS.port)
server.serve_forever()
def main(args=None, default_port=8000):
"""
Run the echo HTTP server.
"""
import argparse
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--address',
'-a',
default='localhost',
help='Hostname or IP address to accept requests on.')
parser.add_argument(
'--port',
'-p',
help='Port to accept requests on. '
'If not specified, use the first available port after 8000.')
args = parser.parse_args(args)
port = args.port
if port is None:
port = default_port
bound = False
while not bound:
try:
httpd = BaseHTTPServer.HTTPServer((args.address, port),
EchoHTTPRequestHandler)
except socket.error:
port += 1
if port > 65535:
raise ValueError('No available port found')
else:
bound = True
else:
httpd = BaseHTTPServer.HTTPServer((args.address, int(port)),
EchoHTTPRequestHandler)
print('Echoing HTTP at http://{0}:{1} ...'.format(args.address, port))
httpd.serve_forever()
def run(self):
"""Start the HTTP server thread."""
self.server = http_server.HTTPServer(
server_address=(self.host, self.port),
RequestHandlerClass=self.request_handler)
self.server.requests = self.requests_queue
self.server.responses = self.responses_queue
self.server.handler_attributes = self.handler_attributes
self.server.timeout = self.timeout
self.server.interval = self.interval
nothing = lambda msg: None
self.server.log_callback = self.logger.debug if self.logger else nothing
self.server.serve_forever()
def __init__(self):
assert issubclass(self._HANDLER_CLS, Handler), self._HANDLER_CLS
self._closed = False
self._stopped = False
self._server = BaseHTTPServer.HTTPServer(('127.0.0.1', 0),
self._HANDLER_CLS)
self._server.parent = self
self._server.url = self.url = 'http://127.0.0.1:%d' % (
self._server.server_port)
self._thread = threading.Thread(target=self._run, name='httpd')
self._thread.daemon = True
self._thread.start()
logging.info('%s', self.url)
def get_http_server(address=None, port=None):
addon = xbmcaddon.Addon('plugin.video.youtube')
address = address if address else addon.getSetting('kodion.http.listen')
address = address if re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', address) else '0.0.0.0'
port = int(port) if port else 50152
try:
server = BaseHTTPServer.HTTPServer((address, port), YouTubeRequestHandler)
return server
except socket.error as e:
xbmc.log('[plugin.video.youtube] HTTPServer: Failed to start |{address}:{port}| |{response}|'.format(address=address, port=port, response=str(e)), xbmc.LOGDEBUG)
xbmcgui.Dialog().notification(addon.getAddonInfo('name'), str(e),
xbmc.translatePath('special://home/addons/{0!s}/icon.png'.format(addon.getAddonInfo('id'))),
5000, False)
return None
