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)