def translate_path(self, path_):
"""
Now accepts local fitting paths automatically
E.g. "/path/to/www-dir/foo.png" is valid if that folder exists.
Now it won't change the path to "/path/to/www-dir/foo.png/path/to/www-dir/foo.png", like it did before.
:param path: path for the webserver.
:return:
"""
if path.exists(path_):
return path_
if py3:
super(BetterHTTPRequestHandler, self).translate_path(path_)
else:
SimpleHTTPRequestHandler.translate_path(self, path_)
return path_
def __init__(self, req, addr, only_upgrade=False, file_only=False,
no_parent=False):
self.only_upgrade = only_upgrade # only allow upgrades
self.webroot = os.path.realpath(".")
self.file_only = file_only
self.no_parent = no_parent
SimpleHTTPRequestHandler.__init__(self, req, addr, object())
def end_headers(self):
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Headers', 'x-request-timestamp, x-signature, electricitymap-token')
self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
self.send_header('Pragma', 'no-cache')
self.send_header('Expires', '0')
SimpleHTTPRequestHandler.end_headers(self)
def do_GET(self):
if self.path == "/shutdown/":
self.wfile.write("HTTP/1.1 200 OK\n\nShutting down...".encode())
self.send_response(200)
subprocess.Popen(["shutdown", "-h", "now"]).wait()
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_HEAD(self):
"""Serve a HEAD request."""
content = self._regenerate(self.path)
if content:
self._send_regenerated_head(content)
else:
SimpleHTTPRequestHandler.do_HEAD(self)
def __init__(self, request, client_address, server):
self._logger = get_ws_logger(self)
self.origin = server.origin
self.port = server.port
self.permissive = server.permissive
SimpleHTTPRequestHandler.__init__(self, request,
client_address, server)
def do_HEAD(self):
parsed_path = urllib.parse.urlparse(self.path)
if parsed_path.path.startswith("/echo"):
message = '\n'.join(
[
'CLIENT VALUES:',
'client_address=%s (%s)' % (self.client_address, self.address_string()),
'command=%s' % self.command,
'path=%s' % self.path,
'real path=%s' % parsed_path.path,
'query=%s' % parsed_path.query,
'request_version=%s' % self.request_version,
'',
'HEADERS:',
'%s' % self.headers,
]
)
self.send_response(200)
self.end_headers()
self.wfile.write(message.encode('utf-8'))
elif parsed_path.path.startswith("/redirect"):
self.send_response(301)
self.send_header('Location', "/echo")
self.end_headers()
else:
SimpleHTTPRequestHandler.do_HEAD(self)
return
def do_POST(self):
params = urlparse(self.path)
if params.path in self.handlers:
self.handlers[params.path](self)
else:
SimpleHTTPRequestHandler.do_POST(self)
def do_GET(self):
if self.path == '/+CSCOE+/logon.html':
self.redirect('/+CSCOE+/logon.html?fcadbadd=1')
return
elif self.path.startswith('/+CSCOE+/logon.html?') and 'reason=1' in self.path:
self.wfile.write(self.send_file('logon_failure').getvalue())
return
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self,*args,**kwds):
tmp = self.path.split('/')
# redirect?
if (len(tmp) == 3) and (tmp[0] == tmp[2]) and tmp[0] == '':
self.send_response(301)
self.send_header('Location', self.path + 'html/')
else:
SimpleHTTPRequestHandler.do_GET(self,*args,**kwds)
def do_GET(self):
""" Handle http requests to serve html/image files only """
print( self.path, self.translate_path(self.path))
permitted_extensions = ['.html','.png','.svg','.jpg', '.js']
if not os.path.splitext(self.path)[1] in permitted_extensions:
self.send_error(404, 'File Not Found/Allowed')
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
"""Handle GET request. Calls handle_websocket(). If unsuccessful,
and web server is enabled, SimpleHTTPRequestHandler.do_GET will be called."""
if not self.handle_websocket():
if self.only_upgrade:
self.send_error(405, "Method Not Allowed")
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
"""Serve a GET request."""
if not self.allow_path():
self.send_error(403)
elif self.is_brat():
self.run_brat_direct()
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
"""Serve a GET request."""
content = self._regenerate(self.path)
if content:
self._send_regenerated_head(content)
self.wfile.write(content)
else:
SimpleHTTPRequestHandler.do_GET(self)
def log_message(self, format, *args):
if DEBUG:
try:
SimpleHTTPRequestHandler.log_message(self, format, *args)
except IOError:
pass
else:
return
def handle(self):
# When using run_once, we have a single process, so
# we cannot loop in BaseHTTPRequestHandler.handle; we
# must return and handle new connections
if self.run_once:
self.handle_one_request()
else:
SimpleHTTPRequestHandler.handle(self)
def do_POST(self):
"""Handle POST request. If web server is enabled,
SimpleHTTPRequestHandler.do_GET will be called."""
if self.only_upgrade:
self.send_error(405, "Method Not Allowed")
else:
# SimpleHTTPRequestHandler has no do_POST function, but we don't need
# anything special, just to respond in the same way as the GET
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self, method='GET'):
#copy all data into a place we can see later.
self.wfile = FileWrapper(self.wfile)
#give the actual work of handling the request to SimpleHTTPRequestHandler
SimpleHTTPRequestHandler.do_GET(self)
#by this time, the shim file object we created previously is
#full of the response data and is ready to display.
print('')
print(self._heading('HTTP Response'))
print(self.wfile)
def do_GET(s):
print(s.path)
if s.path.lower().endswith(".stl"):
filename = "." + s.path
if os.path.exists(filename):
stream_mesh_file(s, filename)
return
# if we get here, we didn't get an stl file to stream
# call the parent's get
C_simple_handler.do_GET(s)
def do_GET( self ):
urlParams = urlparse(self.path)
if os.access( '.' + os.sep + urlParams.path, os.R_OK ):
SimpleHTTPRequestHandler.do_GET(self);
else:
self.send_response(200)
self.send_header( 'Content-type', 'text/html' )
self.end_headers()
with open('index.html', 'r') as f:
html = f.read()
self.wfile.write( html.encode() )
def do_GET(self):
pr = urllib.parse.urlparse(self.path)
if pr.path == '/v':
params = urllib.parse.parse_qs(pr.query)
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(self.getPost(pr.path, params['p'][0]).encode())
self.wfile.flush()
else:
SimpleHTTPRequestHandler.do_GET(self)
def translate_path(self, path):
if os.path.exists(path):
return path
if py3:
super(MyHTTPRequestHandler, self).translate_path(path)
else:
SimpleHTTPRequestHandler.translate_path(self, path)
#half = int(len(path)/2)
#if path.startswith("/") and len(path) % 2 == 0 and path[half:] == path[:half]:
# return path[half:]
return path
def do_GET(self):
with open('index.html') as index_file_handle:
url_params = urlparse.urlparse(self.path)
if os.access('.{}{}'.format(
os.sep, url_params.path), os.R_OK
):
SimpleHTTPRequestHandler.do_GET(self)
else:
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(index_file_handle.read().encode('utf8'))
def do_GET(self):
if self.path not in ('/', '/termlib.js'):
self.send_response(404)
self.send_header('Content-type', 'text/plain')
self.end_headers()
self.wfile.write(b'404')
return
os.chdir(os.path.dirname(__file__))
if PY3:
super().do_GET()
else:
SimpleHTTPRequestHandler.do_GET(self)
os.chdir(cwd)
def do_GET(self):
if (self.headers.get('upgrade') and
self.headers.get('upgrade').lower() == 'websocket'):
# Just indicate that an WebSocket upgrade is needed
self.last_code = 101
self.last_message = "101 Switching Protocols"
elif self.only_upgrade:
# Normal web request responses are disabled
self.last_code = 405
self.last_message = "405 Method Not Allowed"
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
if self.path == "/":
self.send_response(200)
self.send_header('Content-Type', 'text/plain')
self.end_headers()
user_agent = self.headers.get('User-Agent')
messages = ('Have a nice day', 'So long', 'Come again soon')
self.write("""
Hello person from %s.
Your user agent is %s.
%s.
""" % (self.client_address[0], user_agent or "unknown", choice(messages)))
return
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
"""
/packages.tar - serve the contents of the folder referenced in
self.server.packages as a streamd .tar file
/packages/* - serve the files of the folder referenced in
self.server.packages (chrooting into it)
/* - serve the files of the folder referenced in
self.server.chroot
"""
if self.path == "/packages.tar":
self._serve_folder_as_tar(self.server.packages)
return
SimpleHTTPRequestHandler.do_GET(self)
def parse_request(self):
if not SimpleHTTPRequestHandler.parse_request(self):
return False
host, port, resource = http_header_util.parse_uri(self.path)
print 'Got ' + self.path #FIXME
if resource is None:
self._logger.info('WS Invalid URI: %r', self.path)
self._logger.info('WS Fallback to normal HTTP.')
return True
if (not self.permissive and (host is None or self.origin is None or
host.startswith('file://') or
host != self.origin)) or \
(self.permissive and host is not None and
self.origin is not None and
not host.startswith('file://') and host != self.origin):
self._logger.info('WS Invalid host: %r (expected: %r)',
host, self.origin)
self._logger.info('WS Fallback to normal HTTP.')
return True
if port is not None and self.port is not None and port != self.port:
self._logger.info('WS Invalid port: %r (expected: %r)',
port, self.port)
self._logger.info('WS Fallback to normal HTTP.')
return True
self.path = resource
return self.handle_ws(resource)
def end_headers(self):
response_headers = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query).get('response_headers')
if response_headers:
headers = json.loads(response_headers[0])
for header, value in headers:
self.send_header(header, value)
return SimpleHTTPRequestHandler.end_headers(self)
def do_GET(self):
# Parse query string, make sure we have a callback.
url = urlparse(self.path)
if '.jsonp' != url.path[-6:]: return SimpleHTTPRequestHandler.do_GET(self)
query = parse_qs(url.query)
if 'callback' not in query: raise Exception('No callback specified')
callback = query['callback'][-1]
# Get data for different JSONp calls
try:
if '/colorvalue.jsonp' == url.path:
data = color.colorvalue(query['colordef'][0], query['txo[]'])
elif '/makeconversion.jsonp' == url.path:
data = color.makeconversion(loads(query['txspec'][0]))
elif '/receive.jsonp' == url.path:
data = message.receive()
elif '/send.jsonp' == url.path:
data = message.send(query['subject'][0], query['body'][0])
elif '/signrawtransaction.jsonp' == url.path:
data = bitcoin.signrawtransaction(
query['rawtx'][0],
loads(query['inputs'][0]),
query['keys[]']
)
else:
data = {'error': 'Did not understand ' + url.path}
except (KeyError, ValueError): data = {'error': 'Wrong parameters', 'query': query}
# Send the reply as jsonp
self.send_response(200)
self.send_header('Content-type', 'application/javascript')
self.end_headers()
self.wfile.write(bytes(callback + '(' + dumps(data) + ');', 'UTF-8'))
def finish(self):
if self.rec:
self.rec.write("'EOF'];\n")
self.rec.close()
SimpleHTTPRequestHandler.finish(self)
def end_headers (self):
#ensure we can use SharedArrayBuffer in our webpages
self.send_header('Cross-Origin-Opener-Policy', 'same-origin')
self.send_header('Cross-Origin-Embedder-Policy', 'require-corp')
SimpleHTTPRequestHandler.end_headers(self)
def __init__(self, req, client_addr, server):
"""Constructor, call the base constructor and set up session."""
# Track if this was an authenticated request
self.authenticated = False
SimpleHTTPRequestHandler.__init__(self, req, client_addr, server)
self.protocol_version = 'HTTP/1.1'
def end_headers(self):
self.send_header('Cache-Control', 'no-cache')
SimpleHTTPRequestHandler.end_headers(self)
def list_directory(self, path):
if self.file_only:
self.send_error(404, "No such file")
else:
return SimpleHTTPRequestHandler.list_directory(self, path)
def __init__(self, request, client_address, server):
self.temp_files = []
SimpleHTTPRequestHandler.__init__(
self, request, client_address, server)
def send_response(self, code, message=None):
# Save the status code
self.last_code = code
SimpleHTTPRequestHandler.send_response(self, code, message)
def do_GET(self):
SimpleHTTPRequestHandler.do_GET(self)
def end_headers(self):
# Include additional response headers here. CORS for example:
#self.send_header('Access-Control-Allow-Origin', '*')
SimpleHTTPRequestHandler.end_headers(self)
def setup(self):
SimpleHTTPRequestHandler.setup(self)
self.connected = False
def send_header(self, keyword, value):
if keyword.lower() == 'server':
return
SimpleHTTPRequestHandler.send_header(self, keyword, value)
def setup(self):
SimpleHTTPRequestHandler.setup(self)
self.request.settimeout(3)
def end_headers(self):
self.send_header('Access-Control-Allow-Origin', '*')
SimpleHTTPRequestHandler.end_headers(self)
def do_HEAD(self):
SimpleHTTPRequestHandler.do_HEAD(self)
self.delete_temp_files()
def do_GET(self):
from confply import pushd
query_list = None
# split the query out if need be
if "?" in self.path:
self.path, query_list = self.path.split("?")
if "&" in query_list:
query_list = query_list.split("&")
else:
query_list = [query_list]
# put the queries into a dict
queries = {}
if query_list is not None:
for q in query_list:
k, v = q.split("=")
queries[k] = v
if self.path.startswith("/api/") and launcher_path is not None:
response = {"ok": False}
headers = {}
headers["Content-Type"] = "text/json"
if "/api/get.aliases" == self.path:
response["ok"] = True
response["aliases"] = aliases
pass
elif "/api/get.launcher" == self.path:
response["ok"] = True
response["path"] = launcher_path
pass
elif "/api/get.config.dict" == self.path:
with pushd(os.path.dirname(launcher_path)):
if "path" in queries and os.path.exists(queries["path"]):
response["ok"] = True
config = get_config_dict(queries["path"])
# #todo: deal with functions.
response["dict"] = {**config}
else:
response["ok"] = False
response["error"] = "invalid path"
elif "/api/get.configs" == self.path:
response["ok"] = True
response["configs"] = list(configs)
else:
self.send_response(404)
for k, v in headers.items():
self.send_header(k, v)
response["error"] = "api call not found "+self.path
self.end_headers()
self.wfile.write(bytes(json.dumps(response), "utf-8"))
return
self.send_response(200)
for k, v in headers.items():
self.send_header(k, v)
self.end_headers()
self.wfile.write(bytes(json.dumps(response), "utf-8"))
return
in_path = self.translate_path(self.path)
in_path = os.path.relpath(in_path, self.directory)
if in_path in whitelist:
SimpleHTTPRequestHandler.do_GET(self)
else:
self.send_response(404)
self.end_headers()
pass
def do_GET(self):
"""
Handle GET request
"""
config = configparser.ConfigParser()
config.read('config.ini')
consumer_key = config['APP']['XERO_CONSUMER_KEY']
consumer_secret = config['APP']['XERO_CONSUMER_SECRET']
callback_url = config['APP']['CALLBACK_URL']
accounts_and_vendors_files_path = config['APP'][
'ACCOUNTS_AND_VENDORS_FILES_PATH']
vendors_file_name = config['APP']['VENDORS_FILE_NAME']
accounts_file_name = config['APP']['ACCOUNTS_FILE_NAME']
if consumer_key is None or consumer_secret is None:
raise KeyError(
'Please define both XERO_CONSUMER_KEY and XERO_CONSUMER_SECRET variables in config.ini file'
)
if callback_url is None:
raise KeyError('Please define callback_url in config.ini file')
if accounts_and_vendors_files_path is None or vendors_file_name is None or vendors_file_name is None:
raise KeyError(
'Please define Account and Vendors file names and paths in config.ini file'
)
print("Serving path: {}".format(self.path))
path = urlparse(self.path)
if path.path == '/do-auth':
credentials = PublicCredentials(consumer_key,
consumer_secret,
callback_uri=callback_url)
# Save generated credentials details to persistent storage
for key, value in credentials.state.items():
OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value})
# Redirect to Xero at url provided by credentials generation
self.redirect_response(credentials.url)
return
elif path.path == '/oauth':
params = dict(parse_qsl(path.query))
if 'oauth_token' not in params or 'oauth_verifier' not in params or 'org' not in params:
self.send_error(500, message='Missing parameters required.')
return
stored_values = OAUTH_PERSISTENT_SERVER_STORAGE
credentials = PublicCredentials(**stored_values)
try:
credentials.verify(params['oauth_verifier'])
# Resave our verified credentials
for key, value in credentials.state.items():
OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value})
except XeroException as e:
self.send_error(500,
message='{}: {}'.format(
e.__class__, e.message))
return
# Once verified, api can be invoked with xero = Xero(credentials)
self.redirect_response('/verified')
return
elif path.path == '/verified':
stored_values = OAUTH_PERSISTENT_SERVER_STORAGE
credentials = PublicCredentials(**stored_values)
try:
xero = Xero(credentials)
except XeroException as e:
self.send_error(500,
message='{}: {}'.format(
e.__class__, e.message))
return
page_body = ''
vendors = xero.contacts.filter(IsSupplier=True)
accounts = xero.accounts.all()
if vendors:
vendors_file = accounts_and_vendors_files_path + '/' + vendors_file_name
with open(vendors_file, 'w') as fileVendors:
json.dump(vendors,
fileVendors,
indent=4,
sort_keys=True,
default=str)
page_body += ('Check vendors list in ' +
accounts_and_vendors_files_path + '/' +
vendors_file_name + '<br>')
else:
page_body += 'No vendors.\n'
if accounts:
accounts_file = accounts_and_vendors_files_path + '/' + accounts_file_name
with open(accounts_file, 'w') as fileAccounts:
json.dump(accounts,
fileAccounts,
indent=4,
sort_keys=True,
default=str)
page_body += ('Check account list in ' +
accounts_and_vendors_files_path + '/' +
accounts_file_name)
else:
page_body += 'No accounts.\n'
self.page_response(title='Downloading vendor and account files',
body=page_body)
return
SimpleHTTPRequestHandler.do_GET(self)
def end_headers(self):
self.send_header("Access-Control-Allow-Origin", "*")
SimpleHTTPRequestHandler.end_headers(self)
def log_request(self, code='-', size='-'):
if self.verbose:
SimpleHTTPRequestHandler.log_request(self, code, size)
def translate_path(self, path):
path = SimpleHTTPRequestHandler.translate_path(self, path)
relpath = os.path.relpath(path, os.getcwd())
fullpath = os.path.join(self.server.base_path, relpath)
return fullpath
def __init__(self, req, client_addr, server):
""" Contructor, call the base constructor and set up session """
self._session = None
SimpleHTTPRequestHandler.__init__(self, req, client_addr, server)
def do_HEAD(self):
if self.only_upgrade:
self.send_error(405, "Method Not Allowed")
else:
SimpleHTTPRequestHandler.do_HEAD(self)
def __init__(self, *args, **kwargs):
path = urlparse(config.site.url).path
self.error_template = self.error_template.format(path, path)
SimpleHTTPRequestHandler.__init__(self, *args, **kwargs)
def do_GET(self):
if re.search('/api/global_regex', self.path):
print(self.path.split('/'))
#This URL will trigger our sample function and send what it returns back to the browser
self.send_response(200)
self.send_header('Content-type', 'application/json; charset=UTF-8')
self.end_headers()
f = open("api/global_regex.json", "r")
# all_regex = json.loads(f.read())
self.wfile.write(f.read().encode()) # call sample function here
return
if re.search('/api/regex/.*', self.path):
token = self.path.split('/')[-1]
#This URL will trigger our sample function and send what it returns back to the browser
self.send_response(200)
self.send_header('Content-type', 'application/json; charset=UTF-8')
self.end_headers()
f = open("api/global_regex.json", "r")
all_regex = json.loads(f.read())
res_regex = [x for x in all_regex if x["token"] == token][0]
self.wfile.write(
json.dumps(res_regex).encode()) #call sample function here
return
# Path que redirecciona que carga el fichero index.html pero con los datos de pyramid_globals modificados
if re.search('/api/r/.*', self.path):
return
# pyramid_globals = {
# "regex": "Test",
# "description": "No description",
# "title": "Untitled Regex",
# "strFlags": "",
# "testString": "My test data",
# "isOwner": true,
# "token": "MpF1RYmqLxOyd2E0",
# "tier": "",
# "flavor": "javascript",
# "unitTests": "[]",
# "email": ""
# }
if re.search('/tools/off', self.path):
self.send_response(200)
self.send_header('Content-type', 'text/html; charset=UTF-8')
self.end_headers()
self.wfile.write("Bye!".encode())
time.sleep(2)
server.socket.close()
quit()
else:
#serve files, and directory listings by following self.path from
#current working directory
try:
SimpleHTTPRequestHandler.do_GET(self)
except Exception as err:
print(err)
server.socket.close()
quit()
def __init__(self, request, client_address, server_socket):
SimpleHTTPRequestHandler.__init__(self, request, client_address,
server_socket)
def __init__(self, req, addr, only_upgrade=False):
self.only_upgrade = only_upgrade # only allow upgrades
SimpleHTTPRequestHandler.__init__(self, req, addr, object())
def do_GET(self):
# self.path = 'dist/' + self.path
SimpleHTTPRequestHandler.do_GET(self)
def end_headers(self):
self.send_header('Cross-Origin-Opener-Policy', 'same-origin')
self.send_header('Cross-Origin-Embedder-Policy', 'require-corp')
SimpleHTTPRequestHandler.end_headers(self)
def end_headers(self):
#self.send_header('Access-Control-Allow-Origin', website)
self.send_header('Access-Control-Allow-Origin', "http://henriquemiranda.github.io")
SimpleHTTPRequestHandler.end_headers(self)
def send_head(self):
path = self.path.split("?",1)[0].split("#",1)[0]
#strip path after second slash:
while path.rfind("/", 1)>0:
path = path[:path.rfind("/", 1)]
script = self.script_paths.get(path)
log("send_head() script(%s)=%s", path, script)
if script:
log("request for %s handled using %s", path, script)
content = script(self)
return content
path = self.translate_path(self.path)
if not path or not os.path.exists(path):
self.send_error(404, "Path not found")
return None
if os.path.isdir(path):
if not path.endswith('/'):
# redirect browser - doing basically what apache does
self.send_response(301)
self.send_header("Location", path + "/")
self.end_headers()
return None
for index in "index.html", "index.htm":
index = os.path.join(path, index)
if os.path.exists(index):
path = index
break
else:
if not self.directory_listing:
self.send_error(403, "Directory listing forbidden")
return None
return SimpleHTTPRequestHandler.list_directory(self, path).read()
ext = os.path.splitext(path)[1]
f = None
try:
# Always read in binary mode. Opening files in text mode may cause
# newline translations, making the actual size of the content
# transmitted *less* than the content-length!
f = open(path, 'rb')
fs = os.fstat(f.fileno())
content_length = fs[6]
content_type = EXTENSION_TO_MIMETYPE.get(ext)
if not content_type:
if not mimetypes.inited:
mimetypes.init()
ctype = mimetypes.guess_type(path, False)
if ctype and ctype[0]:
content_type = ctype[0]
log("guess_type(%s)=%s", path, content_type)
if content_type:
self.extra_headers["Content-type"] = content_type
accept = self.headers.get('accept-encoding', '').split(",")
accept = tuple(x.split(";")[0].strip() for x in accept)
content = None
log("accept-encoding=%s", csv(accept))
for enc in HTTP_ACCEPT_ENCODING:
#find a matching pre-compressed file:
if enc not in accept:
continue
compressed_path = "%s.%s" % (path, enc) #ie: "/path/to/index.html.br"
if not os.path.exists(compressed_path):
continue
if not os.path.isfile(compressed_path):
log.warn("Warning: '%s' is not a file!", compressed_path)
continue
if not os.access(compressed_path, os.R_OK):
log.warn("Warning: '%s' is not readable", compressed_path)
continue
st = os.stat(compressed_path)
if st.st_size==0:
log.warn("Warning: '%s' is empty", compressed_path)
continue
log("sending pre-compressed file '%s'", compressed_path)
#read pre-gzipped file:
f.close()
f = None
f = open(compressed_path, 'rb')
content = f.read()
assert content, "no data in %s" % compressed_path
self.extra_headers["Content-Encoding"] = enc
break
if not content:
content = f.read()
assert len(content)==content_length, \
"expected %s to contain %i bytes but read %i bytes" % (path, content_length, len(content))
if content_length>128 and \
("gzip" in accept) and \
("gzip" in HTTP_ACCEPT_ENCODING) \
and (ext not in (".png", )):
#gzip it on the fly:
import zlib
assert len(content)==content_length, \
"expected %s to contain %i bytes but read %i bytes" % (path, content_length, len(content))
gzip_compress = zlib.compressobj(9, zlib.DEFLATED, zlib.MAX_WBITS | 16)
compressed_content = gzip_compress.compress(content) + gzip_compress.flush()
if len(compressed_content)<content_length:
log("gzip compressed '%s': %i down to %i bytes", path, content_length, len(compressed_content))
self.extra_headers["Content-Encoding"] = "gzip"
content = compressed_content
f.close()
f = None
#send back response headers:
self.send_response(200)
self.extra_headers.update({
"Content-Length" : len(content),
"Last-Modified" : self.date_time_string(fs.st_mtime),
})
self.end_headers()
except IOError as e:
self.close_connection = True
log("send_head()", exc_info=True)
log.error("Error sending '%s':", path)
emsg = str(e)
if emsg.endswith(": '%s'" % path):
log.error(" %s", emsg.rsplit(":", 1)[0])
else:
log.error(" %s", e)
try:
self.send_error(404, "File not found")
except OSError:
log("failed to send 404 error - maybe some of the headers were already sent?", exc_info=True)
return None
finally:
if f:
try:
f.close()
except OSError:
log("failed to close", exc_info=True)
return content
def do_GET(self):
logging.error(self.headers)
SimpleHTTPRequestHandler.do_GET(self)
