def connect(self, attempts=1):
try:
self._server = BaseHTTPServer.HTTPServer(('127.0.0.1', self.port),
CallbackHandler)
except socket.error:
if attempts < 5:
self.port += random.randint(1, 1000)
self.connect(attempts + 1)
else:
logging.info(
"Unable to start local server, proceeding manually")
class FakeServer():
def serve_forever(self):
pass
self._server = FakeServer()
def test_url(self):
archive_path = self.archive_path
port = random.choice(xrange(7000, 10000))
server_address = ("127.0.0.1", port)
httpd = BaseHTTPServer.HTTPServer(
server_address, ArchiveServerHandlerFactory(archive_path))
t = threading.Thread(target=httpd.serve_forever)
t.start()
bootstrap(self.path, "http://127.0.0.1:%s" % port)
httpd.shutdown()
self.assertEqual(
sorted(fileList(self.path, relative=True)),
sorted(fileList(self.skeleton_path, relative=True)),
)
def run_http_server(request_handler_class):
while True:
port = get_unused_port()
try:
server = BaseHTTPServer.HTTPServer(('', port), request_handler_class)
break
except socket.error:
pass
def run():
while True:
server.handle_request()
thread = threading.Thread(target=run)
thread.daemon = True
thread.start()
return 'http://127.0.0.1:%d/' % port
def gzip_server(gzipped_json):
class MyHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "application/octet-stream")
s.end_headers()
s.wfile.write(gzipped_json)
host = ''
port = 8080
addr = host, port
httpd = BaseHTTPServer.HTTPServer(addr, MyHandler)
url = 'http://localhost:{port}/'.format(**locals())
try:
threading.Thread(target=httpd.serve_forever).start()
yield url
finally:
httpd.shutdown()
httpd.server_close()
def get_http_server(address=None, port=None):
addon_id = 'plugin.video.youtube'
addon = xbmcaddon.Addon(addon_id)
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:
logger.log_debug(
'HTTPServer: Failed to start |{address}:{port}| |{response}|'.
format(address=address, port=port, response=str(e)))
xbmcgui.Dialog().notification(
addon.getAddonInfo('name'), str(e),
"{}/icon.png".format(addon.getAddonInfo('path')), 5000, False)
return None
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
def serve_page(self, port, callback):
# This is an array so AppConfigHandler doesn't create an instance variable when trying to set the state to False
running = [True]
class AppConfigHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
path, query = self.path.split('?', 1)
if path == '/close':
self.send_response(200)
self.end_headers()
self.wfile.write("OK")
running[0] = False
callback(query)
else:
self.send_response(404)
self.end_headers()
self.wfile.write("Not Found")
server = BaseHTTPServer.HTTPServer(('', port), AppConfigHandler)
while running[0]:
server.handle_request()
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 start_standalone_http_server():
def _get_http_handler_class():
class StaticHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
data = b"Hello World!!!"
self.send_response(http.OK)
self.send_header('Content-Length', str(len(data)))
self.end_headers()
self.wfile.write(data)
return
return StaticHTTPRequestHandler
server_address = ('127.0.0.1', 0)
handler_class = _get_http_handler_class()
httpd = BaseHTTPServer.HTTPServer(server_address, handler_class)
port = httpd.socket.getsockname()[1]
thread = threading.Thread(target=httpd.serve_forever)
thread.daemon = True
thread.start()
return thread, httpd, port
def test_has(lib):
proxy = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock)
proxy.expectations = [
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(204, {}, "")),
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(404, {}, "")),
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(500, {}, "")),
]
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_has(cfg, b"NS", b"NS/ACCT/JFS//plop")
lib.test_has_not(cfg, b"NS", b"NS/ACCT/JFS//plop")
lib.test_has_fail(cfg, b"NS", b"NS/ACCT/JFS//plop")
finally:
proxy.shutdown()
service.join()
assert (0 == len(proxy.expectations))
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):
"""
Request handler implements a frugal HTTP handler.
"""
def do_POST(self):
"""
do_POST implements POST method on a frugal server.
"""
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 %s',
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 __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)
def do_POST(self):
def dechunk(f):
bio = io.BytesIO()
while True:
chunksize = bytearray()
while not chunksize.endswith(b'\r\n'):
chunksize += f.read(1)
chunksize = chunksize.decode().split(':')[0]
chunksize = int(chunksize, 16)
if chunksize == 0:
break
chunk = f.read(chunksize)
assert(f.read(2) == b'\r\n')
bio.write(chunk)
bio.seek(0)
return bio
def verify_hash(f, hashtype, hsh):
try:
chksum = hashlib.new(hashtype)
except ValueError:
return False
chksum.update(f.read())
return chksum.hexdigest() == hsh
if self.headers.get('Transfer-Encoding') == 'chunked':
fp = dechunk(self.rfile)
else:
fp = self.rfile
data = cgi.FieldStorage(fp=fp, headers=self.headers,
environ={'REQUEST_METHOD': 'POST'},
# accept maximum of 10MB of data
limit=10 * 1024 * 1024)
try:
if 'filename' in data:
resp = b'Missing'
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.send_header('Content-Length', len(resp))
self.end_headers()
self.wfile.write(resp)
else:
hashtype = [k for k in data.keys() if k.endswith('sum')][0]
hsh = data[hashtype].value
hashtype = hashtype.split('sum')[0]
if verify_hash(data['file'].file, hashtype, hsh):
self.send_response(204)
self.end_headers()
else:
self.send_error(500)
except (KeyError, IndexError):
self.send_error(400)
self.server = BaseHTTPServer.HTTPServer(('', port), RequestHandler)
if cert:
self.server.socket = ssl.wrap_socket(self.server.socket, certfile=cert, server_side=True)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
self.wfile.write(_MY_VERSION)
elif self.path == '/dump':
# yaml module is not installed on Macs and Windows machines by default
# so we import it lazily (/dump action is only used for debugging)
import yaml
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
now = time.time()
self.wfile.write(
yaml.dump({
'pool':
pool,
'in_use':
dict((k, now - v) for k, v in in_use.items())
}))
elif self.path == '/quitquitquit':
self.send_response(200)
self.end_headers()
keep_running = False
httpd = BaseHTTPServer.HTTPServer(('', args.port), Handler)
while keep_running:
httpd.handle_request()
sys.stderr.flush()
print('done')
def receive(
address,
include_body=True,
include_client=False,
include_method=False,
include_path=False,
include_version=False,
):
"""Receives data sent using HTTP requests.
Provides a simple HTTP server that receives client requests, converting
each request into Pipecat records.
Parameters
----------
address: (host, port) tuple, required
TCP address and IP port to be bound for listening to requests.
Yields
------
record: dict
Records will contain `client`, `version`, `method`, `path`, and `body` keys containing
the content of each request.
"""
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
server_version = "Pipecat/" + pipecat.__version__
record = {}
def create_record(self):
request_size = int(self.headers.get("Content-length", 0))
Handler.record.clear()
if include_body:
pipecat.record.add_field(Handler.record, "body", self.rfile.read(request_size))
if include_client:
pipecat.record.add_field(Handler.record, "client", self.client_address)
if include_method:
pipecat.record.add_field(Handler.record, "method", self.command)
if include_path:
pipecat.record.add_field(Handler.record, "path", self.path)
if include_version:
pipecat.record.add_field(Handler.record, "version", self.request_version)
self.send_response(200)
self.end_headers()
def do_GET(self):
self.create_record()
def do_PUT(self):
self.create_record()
def do_POST(self):
self.create_record()
def do_DELETE(self):
self.create_record()
def log_message(self, format, *args):
log.debug(format, *args)
server = BaseHTTPServer.HTTPServer(address, Handler)
while True:
server.handle_request()
yield Handler.record
def test_get(lib):
http, services, urls = [], [], []
http.append(BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock))
for _ in range(3):
http.append(BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock))
for h in http:
urls.append(http2url(h))
services.append(Service(h))
rawx_expectations = [
(("/0000000000000000000000000000000000000000000000000000000000000000",
{
"Range": "bytes=0-63"
}, ""), (200, {
"Content-Range": "bytes=0-63/64"
}, "0" * 64)),
(("/0000000000000000000000000000000000000000000000000000000000000001",
{
"Range": "bytes=0-63"
}, ""), (200, {
"Content-Range": "bytes=0-63/64"
}, "0" * 64)),
(("/0000000000000000000000000000000000000000000000000000000000000004",
{
"Range": "bytes=0-15"
}, ""), (200, {
"Content-Range": "bytes=0-15/16"
}, "0" * 16)),
(("/0000000000000000000000000000000000000000000000000000000000000005",
{
"Range": "bytes=0-15"
}, ""), (200, {
"Content-Range": "bytes=0-15/16"
}, "0" * 16)),
(("/0000000000000000000000000000000000000000000000000000000000000006",
{
"Range": "bytes=0-15"
}, ""), (200, {
"Content-Range": "bytes=0-15/16"
}, "0" * 16)),
(("/0000000000000000000000000000000000000000000000000000000000000007",
{
"Range": "bytes=0-15"
}, ""), (200, {
"Content-Range": "bytes=0-15/16"
}, "0" * 16)),
]
for h in http[1:]:
h.expectations = rawx_expectations
czero = "000000000000000000000000000000000000000000000000000000000000000"
hash_zero = "00000000000000000000000000000000"
http[0].expectations = [
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(503, {}, "")),
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""), (200, {
"x-oio-content-meta-chunk-method":
"plain"
}, "[]")),
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(200, {
"x-oio-content-meta-chunk-method": "plain"
},
json.dumps([
{
"url": "http://%s/%s%d" % (urls[1], czero, 0),
"pos": "0",
"size": 64,
"hash": hash_zero
},
]))),
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(200, {
"x-oio-content-meta-chunk-method": "plain"
},
json.dumps([
{
"url": "http://%s/%s%d" % (urls[1], czero, 1),
"pos": "0",
"size": 64,
"hash": hash_zero
},
{
"url": "http://%s/%s%d" % (urls[2], czero, 2),
"pos": "0",
"size": 64,
"hash": hash_zero
},
{
"url": "http://%s/%s%d" % (urls[3], czero, 3),
"pos": "0",
"size": 64,
"hash": hash_zero
},
]))),
(("/v3.0/NS/content/show?acct=ACCT&ref=JFS&path=plop", {}, ""),
(200, {
"x-oio-content-meta-chunk-method": "plain"
},
json.dumps([
{
"url": "http://%s/%s%d" % (urls[1], czero, 4),
"pos": "0.0",
"size": 16,
"hash": hash_zero
},
{
"url": "http://%s/%s%d" % (urls[2], czero, 5),
"pos": "1.0",
"size": 16,
"hash": hash_zero
},
{
"url": "http://%s/%s%d" % (urls[3], czero, 6),
"pos": "2.0",
"size": 16,
"hash": hash_zero
},
{
"url": "http://%s/%s%d" % (urls[3], czero, 7),
"pos": "3.0",
"size": 16,
"hash": hash_zero
},
]))),
]
for s in services:
s.start()
cfg = json.dumps({"NS": {"proxy": urls[0]}}).encode('utf-8')
try:
lib.test_init(cfg, b"NS")
lib.test_get_fail(cfg, b"NS", b"NS/ACCT/JFS//plop")
lib.test_get_fail(cfg, b"NS", b"NS/ACCT/JFS//plop")
lib.test_get_success(cfg, b"NS", b"NS/ACCT/JFS//plop", 64)
lib.test_get_success(cfg, b"NS", b"NS/ACCT/JFS//plop", 64)
lib.test_get_success(cfg, b"NS", b"NS/ACCT/JFS//plop", 64)
finally:
for h in http:
assert (0 == len(h.expectations))
h.shutdown()
for s in services:
s.join()
def test_list_ok(lib):
names = ("plap", "plep", "plip", "plop", "plup", "plyp")
proxy = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), DumbHttpMock)
proxy.expectations = [
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {}, "{\"objects\":[],\"prefixes\":[]}")),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {},
json.dumps({
"objects": [{
"name": x,
"hash": "0000",
"size": 0,
"version": 1
} for x in names],
"prefixes": [],
}))),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS&prefix=pla", {}, ""),
(200, {},
json.dumps({
"objects": [{
"name": x,
"hash": "0000",
"size": 0,
"version": 1
} for x in names if x.startswith("pla")],
"prefixes": [],
}))),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS&marker=plap", {}, ""),
(200, {
"X-Oio-list-truncated": False,
"X-Oio-list-next": "plep",
},
json.dumps({
"objects": [{
"name": "plep",
"hash": "0000",
"size": 0,
"version": 1
}],
"prefixes": [],
}))),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS", {}, ""),
(200, {
"X-Oio-list-truncated": True,
"X-Oio-list-next": "plep",
},
json.dumps({
"objects": [
{
"name": "plap",
"hash": "0000",
"size": 0,
"version": 1
},
{
"name": "plep",
"hash": "0000",
"size": 0,
"version": 1
},
],
"prefixes": [],
}))),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS&max=2", {}, ""),
(200, {
"X-Oio-list-truncated": True,
"X-Oio-list-next": "plep",
},
json.dumps({
"objects": [
{
"name": "plap",
"hash": "0000",
"size": 0,
"version": 1
},
{
"name": "plep",
"hash": "0000",
"size": 0,
"version": 1
},
],
"prefixes": [],
}))),
(("/v3.0/NS/container/list?acct=ACCT&ref=JFS&marker=plap&max=1", {},
""), (200, {
"X-Oio-list-truncated": False,
"X-Oio-list-next": "plep",
},
json.dumps({
"objects": [{
"name": "plep",
"hash": "0000",
"size": 0,
"version": 1
}],
"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_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 0, None, None,
None, 0)
lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 6, None, None,
None, 0)
lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 1, b"pla",
None, None, 0)
lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 1, None,
b"plap", None, 0)
lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 2, None, None,
None, 0)
lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 2, None, None,
None, 2)
lib.test_list_success_count(cfg, b"NS", b"NS/ACCT/JFS", 1, None,
b"plap", None, 1)
finally:
proxy.shutdown()
service.join()
assert (0 == len(proxy.expectations))
def serve_sensor_page(self, pypkjs_port, port=None):
controller = self
self.port = port or self._choose_port()
class SensorPageHandler(BaseHTTPServer.BaseHTTPRequestHandler):
PERMITTED_PATHS = {
'static/js/backbone-min.js', 'static/js/backbone-min.map',
'static/js/propeller.min.js', 'static/js/sensors.js',
'static/js/underscore-min.js', 'static/js/underscore-min.map',
'static/js/websocket.js', 'static/compass-arrow.png',
'static/compass-rose.png',
'static/stylesheets/normalize.min.css',
'static/stylesheets/sensors.css'
}
def do_HEAD(self):
self.send_response(200)
self.end_headers()
def do_GET(self):
requested_file = self.path.rsplit('/', 1)[1]
file_path = self.path.lstrip('/')
if requested_file == '':
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(
SENSOR_PAGE_HTML.format(
websocket_host="'{}'".format(controller._get_ip()),
websocket_port="'{}'".format(pypkjs_port)))
elif file_path in self.PERMITTED_PATHS:
try:
file_contents = open(
os.path.join(
os.path.dirname(os.path.realpath(__file__)),
file_path))
self.send_response(200)
self.end_headers()
self.wfile.write(file_contents.read())
except IOError:
self.send_response(404)
self.end_headers()
self.wfile.write("Not Found")
else:
self.send_response(403)
self.end_headers()
self.wfile.write("Forbidden")
def log_request(self, code='-', size='-'):
logger.debug("{} - - [{}] '{}' {} {}".format(
self.client_address[0], self.log_date_time_string(),
self.requestline, code, size))
server = BaseHTTPServer.HTTPServer(('', self.port), SensorPageHandler)
try:
url = "http://{}:{}".format(self._get_ip(), server.server_port)
url_code = pyqrcode.create(url)
print(url_code.terminal(quiet_zone=1))
print(
"==================================================================================================="
)
print(
"Please scan the QR code or enter the following URL in your mobile browser:\n{}"
.format(url))
print(
"==================================================================================================="
)
except socket.error:
print(
"Unable to determine local IP address. Please browse to port {} on this machine from your mobile "
"browser.".format(server.server_port))
print("\nUse Ctrl-C to stop sending sensor data to the emulator.\n")
try:
server.serve_forever()
except KeyboardInterrupt:
print("Stopping...")
server.server_close()
time.sleep(2) # Wait for WS connection to die between phone/QEMU
def init_server():
srv = BaseHTTPServer.HTTPServer(("127.0.0.1", 7331), RequestHandler)
event.set()
srv.handle_request()
srv.server_close()
def start(self):
self.server = BaseHTTPServer.HTTPServer(("localhost", 0), FakeHTTPRequestHandler)
self.server_thread = threading.Thread(target=self.serve)
self.server_thread.daemon = True
self.server_thread.start()
fp.close()
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('-p', '--port', action='store', dest='port', type='int', default=PORT, help='TCP port number')
parser.add_option('-a', '--authorization', action='store_true', dest='authorization', default=False, help='Require authorization')
parser.add_option('-u', '--username', action='store', dest='username', default='username', help='User name for HTTP Proxy authorization, unquoted')
parser.add_option('-w', '--password', action='store', dest='password', default='password', help='Password for HTTP Proxy authorization, unquoted')
parser.add_option('-r', '--realm', action='store', dest='realm', default='realm', help='Realm for HTTP Proxy authorization')
parser.add_option('-t', '--translate', action='store', dest='translate', metavar='HOSTNAME', help='Translate requests for this host name to localhost')
parser.add_option('-f', '--fork', action='store_true', dest='fork', default=False, help='Fork daemon process')
parser.add_option('-v', '--verbose', action='store_true', dest='verbose', default=False, help='Output verbose informations')
(options, arguments) = parser.parse_args()
httpd = BaseHTTPServer.HTTPServer(('', int(options.port)), Proxy)
if options.fork:
pid = os.fork()
if pid == 0:
for fd in range(3):
os.close(fd)
fd2 = os.open(os.devnull, fd == 0 and os.O_RDONLY or os.O_WRONLY)
if fd2 != fd:
os.dup2(fd2, fd)
os.close(fd2)
httpd.serve_forever()
else:
print("proxy_pid=%d proxy_port=%d" % (pid, httpd.server_port))
else:
try:
print("proxy_pid=%d proxy_port=%d" % (os.getpid(), httpd.server_port))
def _create_http_server(listen_ip, listen_port, root_dir):
return BaseHTTPServer.HTTPServer(
(listen_ip, listen_port),
_generate_request_handler(root_dir),
)
