def do_GET(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_GET(self) return
def do_GET(self): params = urlparse(self.path) if params.path in self.handlers: self.handlers[params.path](self) else: SimpleHTTPRequestHandler.do_GET(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_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): 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): """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 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): """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): """ 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_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(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 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): 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.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 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): """ /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 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): if self.headers.get("upgrade") and self.headers.get("upgrade").lower() == "websocket": if self.headers.get("sec-websocket-key1") or self.headers.get("websocket-key1"): # For Hixie-76 read out the key hash self.headers.__setitem__("key3", self.rfile.read(8)) # 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): # 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 do_GET(self, method='GET'): """Handles a GET request the same way as SimpleHTTPRequestHandler, but also prints the full text of the response to standard output.""" #Replace the file object being used to output response with a #shim that copies all outgoing data into a place we can see #later. Then, give the actual work of handling the request to #SimpleHTTPRequestHandler. self.wfile = FileWrapper(self.wfile) SimpleHTTPRequestHandler.do_GET(self) #By this time, the shim file object we created previously is #full of the response data, and is ready to be displayed. The #request has also been displayed, since it was logged by #log_request() (called by SimpleHTTPRequestHandler's do_GET) print("") print(self._heading("HTTP Response")) print(self.wfile)
def do_GET(self): abspath = os.path.realpath("." + (self.path.split("?")[0])) 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" elif self.file_only and not os.path.isfile(abspath): self.send_response(404, "No such file") elif self.no_parent and not abspath.startswith(self.webroot): self.send_response(403, "Hidden resources") else: SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): """ Artificially slow down the response to make sure there are no race conditions. """ sleep(0.5) return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): if self.path == '/ip': self.send_response(200) self.send_header('Content-type', 'text/html') self.end_headers() self.wfile.write('ip adresiniz %s' % self.client_address[0]) return else: return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): if self.path == "/style.css" or self.path == "/favicon.ico": SimpleHTTPRequestHandler.do_GET(self) else: self.write_html_headers() self.write_template("header") parsed_query = parse_qs(urlparse(self.path).query) if self.path == "/": self.write_template("index") elif self.path == "/single/": table, row = poprandomrow(get_table(self.filename)) row.update(dict(timestamp=formatted_time())) self.write_template("single", substitution=row) elif "/edit" in self.path: uri = parsed_query.get("uri") if(uri): for row in get_table(self.filename): if(uri[0] == row["uri"]): row.update(dict(timestamp=formatted_time())) self.write_template("single", substitution=row) else: self.write_template("new", substitution=dict(timestamp=formatted_time())) #elif self.path == "/archive/": #TODO merge into /search/ # for row in get_table(self.filename): # if(row["rating"] == 0): # rating==never, thus inactive # self.write_template("archive", # substitution=row) #TODO doesnt work any longer correctly: notes/mdnotes elif "/search" in self.path: q = parsed_query.get("q") minratings = parsed_query.get("minrating") minrating = int(minratings[0]) if minratings else 0 maxratings = parsed_query.get("maxrating") maxrating = int(maxratings[0]) if maxratings else 0 regex = re.compile(q[0], re.IGNORECASE) if q else re.compile("") for row in get_table(self.filename): if(minrating <= row["rating"] <= maxrating): if(regex.search(row["notes"]) or regex.search(row["title"])): self.write_template("all", substitution=row) else: self.write_template("error") self.write_template("footer")
def do_GET(self): # Browsing to ?quit=1 will kill the server cleanly. _, _, _, query, _ = urlsplit(self.path) if query: params = parse_qs(query) if '1' in params.get('quit', []): self._SendNothingAndDie() return return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): key = re.search('ajpvnc_key=' + str(self.session) + r';*[\s|$]', str(self.headers)) if not key: # Wrong security cookie print ('No key!') self.last_code = 403 self.last_message = "403 Forbidden" return None if (self.headers.get('upgrade') and self.headers.get('upgrade').lower() == 'websocket'): if (self.headers.get('sec-websocket-key1') or self.headers.get('websocket-key1')): # For Hixie-76 read out the key hash self.headers.__setitem__('key3', self.rfile.read(8)) # 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): #global auth_key ''' Present frontpage with user authentication. ''' if self.headers.get('authorization') == None: self.do_AUTHHEAD() self.wfile.write(b'no auth header received') pass elif self.headers.get('authorization') == auth_keyWord_b64: return SimpleHTTPRequestHandler.do_GET(self) pass else: self.do_AUTHHEAD() #print(self.headers.get('authorization')) self.wfile.write(b'not authenticated') pass
def do_GET(self): url = urlparse(self.path) print("url: '%s' url.path: '%s'" % (url, url.path)) if url.path == "" or url.path == "/": self.redirect("/login.html") if url.path == "/authenticate": self.redirect("/homepage.html") return if url.path == '/admin/shutdown': print("server shutdown has been requested") os.kill(os.getpid(), signal.SIGHUP) return SimpleHTTPRequestHandler.do_GET(self)
def downloadFile(self, relPath, parameters): print("Downloading: " + relPath) fullPath = base_dir(relPath) if not os.path.isfile(fullPath): return self.notFound(relpath) if "i" in parameters and parameters["i"]: SimpleHTTPRequestHandler.do_GET(self) return derp, ext = os.path.splitext(relPath) ext = ext[1:].lower() f = open(fullPath, 'rb') self.send_response(200) if ext == "html" or ext == "htm": self.send_header('Content-type', 'text/html;charset=utf-8') dat = f.read() self.send_header("Content-length", len(dat)) if config.protocol == "HTTP/1.1": self.send_header('Connection', 'Close') self.end_headers() self.wfile.write(dat) self.wfile.flush() f.close()
def do_GET(self): url = urlparse(self.path) print("url: '%s' url.path: '%s'" % (url, url.path)) if url.path == "" or url.path == "/": self.redirect("/login.html") if url.path == "/authenticate": self.redirect("/homepage.html") return if url.path == '/admin/shutdown': print("server shutdown has been requested") os.kill(os.getpid(), signal.SIGHUP) return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): """ Present frontpage with user authentication. """ global api_key match = self.token_pattern.search(self.path) if match: prefix_length = len(match.group(0)) - 1 new_path = self.path[prefix_length:] found_api_key = match.group(1) if found_api_key == api_key: self.path = new_path return SimpleHTTPRequestHandler.do_GET(self) self.send_response(403) self.send_header("Content-type", "text/html") self.end_headers() self.wfile.write(b"no valid api key received")
def do_GET(self): if self.path == '/': self.path = 'public/index.html' return SimpleHTTPRequestHandler.do_GET(self) elif self.path == '/negotiate': token = build_authentication_token( sys.argv[1], 'stream', roles=[ 'webpubsub.sendToGroup.stream', 'webpubsub.joinLeaveGroup.stream' ]) print(token) self.send_response(200) self.send_header('Content-Type', 'application/json') self.end_headers() self.wfile.write(json.dumps({'url': token['url']}).encode())
def do_GET(self): current_time = time.localtime() elapsed_time = time.time() - server_start string_current_t = time.strftime("%a, %d %b %Y %H:%M:%S", current_time) #string_elapsed_t = time.strftime("%a, %d %b %Y %H:%M:%S", elapsed_time) cpu_usage = psutil.cpu_percent() memory_usage = psutil.virtual_memory() process_list = '' for process in psutil.process_iter(): try: process_info = process.as_dict(attrs=['pid', 'name']) process_list += "PID " + str( process_info['pid'] ) + " " + "NAME " + process_info['name'] + "\n " except psutil.NoSuchProcess: pass path = '/usr/bin/serverscripts/index_bkp.html' index_file = open(path) f = index_file.read() index_file.close() f = re.sub(r"hhh", process_list, f) f = re.sub(r"aaa", string_current_t, f) f = re.sub(r"bbb", str(elapsed_time), f) f = re.sub(r"ccc", processor, f) f = re.sub(r"ddd", str(cpu_usage), f) f = re.sub(r"eee", str(memory_usage), f) f = re.sub(r"ggg", linux, f) self.path = '/usr/bin/serverscripts/index.html' index_file = open(self.path, 'w') index_file.write(f) index_file.close() print("connection recieved") return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): path, qs = self.path.split("?") if '?' in self.path else [ self.path, "" ] switcher = { "/hello": get_page_hello, "/goodbye": get_page_goodbye, "/pages": get_page_about_me, "/pages/hobby": get_page_hobby, } if path in switcher: msg = switcher[path](qs) self.send_response(200) self.send_header("content-type", "text/plain") self.send_header("content-length", str(len(msg))) self.end_headers() self.wfile.write(msg.encode()) else: return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): path, qs = self.path.split("?") if '?' in self.path else [ self.path, "" ] path = path.rstrip('/') switcher = { "/hello": page_hello, "/goodbye": page_goodbye, "/resume": page_p } if path in switcher: msg = switcher[path](qs) self.send_response(200) self.send_header("Content-type", "text/plain") self.send_header("Content-length", str(len(msg))) self.end_headers() self.wfile.write(msg.encode()) else: return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): try: # Get code from Raindrop code = parse_qs(urlparse(self.path).query).get("code", str)[0] except TypeError: # If a request was made without a code, just display an error message self.path = "/auth_error.html" else: # We got the code, so we use that to request a token from Raindrop, which we use a PHP script to do # because of issues with SSL root certificates in some versions of Python on macOS, # which makes this unreliable to do in Python if we should keep this thing small and simple but still safe. token_result = os.popen("/usr/bin/php raindrop-get-token.php '" + code.replace("'", "'\\''") + "'").read() if token_result == "success": # If we succeeded in getting the token, display information about the authentication being successful self.path = "/auth_info.html" else: # If we failed to get the token, display information about the authentication having failed self.path = "/auth_error.html" # Stop the webserver in 2 seconds, so we have time to display the info web page before it quits os.system("sleep 2 && " + kill_command + " &") return SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): MOVE_PREFIX = '/move/' if self.path == '/init': environment = Environment(INIT_ENVIRONMENT) # return self.__send_json({'env' : environment.get(), 'actor' : environment.get_actor_state()}) return self.__send_json(environment.get()) elif self.path == '/': self.path = '/web/index.html' elif self.path.startswith(MOVE_PREFIX): env = json.loads(unquote(self.path[len(MOVE_PREFIX):])) env_text = '\n'.join(map(lambda r: ' '.join(r), env)) environment = Environment(env_text) state = environment.get_actor_state() strategy = build_strategy() load_from_file(strategy) action = strategy.next_action(state, 0) environment.perform_action(action) response = { 'env': environment.get(), 'terminal': environment.actor_in_terminal_state, 'stats': { 'ε': strategy.ε, 'scores': strategy.scores, 'episode': strategy.episode } } return self.__send_json(response) return SimpleHTTPRequestHandler.do_GET(self)
def do_POST(self): print('got POST to {path}'.format(path=self.path)) global Session session = Session() request_ip, request_port = self.request.getpeername() content_length = int(self.headers.get('Content-Length')) content_type, pdict = cgi.parse_header( self.headers.get('content-type')) data = dict() if content_type == 'application/json': post_body = self.rfile.read(content_length) data = simplejson.loads(post_body) elif content_type == 'multipart/form-data': # ошибка если использовать str pdict['boundary'] = bytes(pdict['boundary'], 'utf-8') data = cgi.parse_multipart(self.rfile, pdict) print('post data', data) if '{api}/service/diag'.format(api=API_VERSION) == self.path: self.create_diagnostic(request_ip, data, session) return if '{api}/service'.format(api=API_VERSION) == self.path: self.create_service(request_ip, data, session) return if '{api}/runner'.format(api=API_VERSION) == self.path: self.create_runner(request_ip, data, session) self.change_workplace(request_ip, data, session) return return SimpleHTTPRequestHandler.do_GET(self)
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 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): # self.path = 'dist/' + self.path SimpleHTTPRequestHandler.do_GET(self)
def do_FILE(self, path): self.path = path return ReqHandler.do_GET(self)
def takeVideo(self): SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): # List of pages. pages = ['home', 'add', 'datasets', 'detector'] # Homepage on root. if self.path == '/': self.path = '/home' # Selected page. page = self.path.split('/')[1] # Check if the current request is a page. if page in pages: # Get the response page template. lookup = TemplateLookup(directories=['templates/']) template = lookup.get_template(page + '.mako') # Set the response page headers. self.send_response(200) self.send_header('Content-Type', 'text/html; charset=utf-8') self.end_headers() # Page specific fields. fields = {} if page == 'datasets': # Datasets page, get the list of datasets. fields['datasets'] = getAllDatasets() elif page == 'detector': # Detector page, get the dataset id. datasetId = self.path.split('/')[2] # Get the dataset name. name = getDatasetName(datasetId) # Add the name to the fields. fields['name'] = name # Open the dataset. with open('uploads/' + datasetId + '.csv', 'r') as file: # Read the CSV column names. columnIdsLine = file.readline().rstrip() columnIds = columnIdsLine.split(',') # Make a dictonary for the column names. columnNames = {} # Get the column names. allFields = getFields() category = '' # Get the descriptions for the columns. for field in allFields: if field['isCategory'] == '1': category = field['description'] elif field['id'] in columnIds: label = '' if category != '': label += category + ' - ' label += field['description'] columnNames[field['id']] = label # Add the column names to the fields. fields['columns'] = columnNames # Render the response page template. self.wfile.write(bytes(template.render(fields=fields), 'utf-8')) # Get response is ready. return # Else, give back the file from the public folder. self.path = 'public' + self.path return SimpleHTTPRequestHandler.do_GET(self)
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 do_GET(self): if ('/index.html' in self.path) or (self.path == '/' in self.path): data_banco = self.node.get_data('cadastro', '*', 'data_cadastro = (select max(data_cadastro) from cadastro)')[0] #datatime(year, month, day, hour, minute, second, microsecond) f = self.send_head_custom() if f: aux= f.read() aux= array('B',struct.unpack('B'*len(aux),aux)) #aux = str(f.read(), 'utf-8').strip('\'b') #print(aux) colunas = [] linha =[] if data_banco[7] != None: colunas.append('Modo') if data_banco[7] == 1: linha.append('Horário e intervalo de irrigação') if data_banco[7] == 2: linha.append('Umidade mínima e máxima') if data_banco[7] == 3: linha.append('Umidade mínima e intervalo de irrigação') if data_banco[7] == 4: linha.append('Temperatura mínima e máxima') if data_banco[7] == 5: linha.append('Temperatura máxima e intervalo de irrigação') if data_banco[7] == 6: linha.append('Umidade e Temperatura') if data_banco[1] != None: colunas.append('Data de Cadastro') string = data_banco[1].strftime('%d %b,%Y %H:%M') linha.append(string) if data_banco[8] != None: colunas.append('Horário de Irrigação') hora = int(data_banco[8]/60) minutos = data_banco[8]%60 linha.append(str(hora) + ":" + str(minutos)) if data_banco[2] != None: colunas.append('Intervalo de Irrigação') linha.append(data_banco[2]) if data_banco[3] != None: colunas.append('Umidade Mínima') linha.append(data_banco[3]) if data_banco[4] != None: colunas.append('Umidade Máxima') linha.append(data_banco[4]) if data_banco[5] != None: colunas.append('Temperatura Mínima') linha.append(data_banco[5]) if data_banco[6] != None: colunas.append('Temperatura Máxima') linha.append(data_banco[6]) html = '<table class=\"table\"><thead><tr>' for coluna in colunas: html += '<th scope=\"col\">' + str(coluna) + '</th>' html += '</tr></thead><tbody><tr>' for l in linha: html += '<td>'+str(l)+'</td>' html += '</tr></tbody></table>' html= html.encode('utf-8') to_format= array('B',struct.unpack('B'*len(html),html)) idx = aux.index(123) while idx < len(aux): if aux[idx+1]==123 and aux[idx+2]==125 and aux[idx+3]==125: aux= aux[:idx]+to_format+aux[idx+4:] break idx += aux[idx+1:].index(123) #aux = aux.format(*to_format) self.send_header("Content-Length", len(aux)) self.end_headers() self.wfile.write(aux) f.close() else: SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): if self.pre_check(): SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers)) SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): SimpleHTTPRequestHandler.do_GET(self) self.delete_temp_files()
def do_GET(self): """ Handles the browser access (GET requests). """ client_host, client_port, is_ipv6 = \ RequestHandler._get_client_host_port(self.client_address) self.auth_session = self.__check_session_cookie() username = self.auth_session.user if self.auth_session else 'Anonymous' LOG.debug("%s:%s -- [%s] GET %s", client_host if not is_ipv6 else '[' + client_host + ']', client_port, username, self.path) product_endpoint, path = routing.split_client_GET_request(self.path) if self.path == '/live': self.__handle_liveness() return if self.path == '/ready': self.__handle_readiness() return if self.server.manager.is_enabled and not self.auth_session \ and routing.is_protected_GET_entrypoint(path): # If necessary, prompt the user for authentication. returnto = '?returnto=' + \ urllib.parse.quote_plus(self.path.lstrip('/')) \ if self.path != '/' else '' self.send_response(307) # 307 Temporary Redirect self.send_header('Location', '/login.html' + returnto) self.send_header('Connection', 'close') self.end_headers() self.wfile.write(b'') return if product_endpoint is not None and product_endpoint != '': # Route the user if there is a product endpoint in the request. product = self.server.get_product(product_endpoint) if not product: # Give an error if the user tries to access an invalid product. LOG.info("Product endpoint '%s' does not exist.", product_endpoint) self.send_error( 404, "The product {0} does not exist.".format(product_endpoint)) return # Try to reconnect in these cases. # Do not try to reconnect if there is a schema mismatch. reconnect_cases = [ DBStatus.FAILED_TO_CONNECT, DBStatus.MISSING, DBStatus.SCHEMA_INIT_ERROR ] # If the product is not connected, try reconnecting... if product.db_status in reconnect_cases: LOG.error( "Request's product '%s' is not connected! " "Attempting reconnect...", product_endpoint) product.connect() if product.db_status != DBStatus.OK: # If the reconnection fails, # redirect user to the products page. self.send_response(307) # 307 Temporary Redirect self.send_header("Location", '/products.html') self.end_headers() return if path == '' and not self.__has_access_permission(product): LOG.warning( "User '%s' does not have permission to access " "the '%s' product.", username, product_endpoint) self.send_response(307) # 307 Temporary Redirect self.send_header('Location', '/products.html') self.send_header('Connection', 'close') self.end_headers() self.wfile.write(b'') return if path == '' and not self.path.endswith('/'): # /prod must be routed to /prod/index.html first, so later # queries for web resources are '/prod/style...' as # opposed to '/style...', which would result in 'style' # being considered product name. LOG.info("Redirecting user from /%s to /%s/index.html", product_endpoint, product_endpoint) # WARN: Browsers cache '308 Permanent Redirect' responses, # in the event of debugging this, use Private Browsing! self.send_response(308) self.send_header( "Location", self.path.replace(product_endpoint, product_endpoint + '/', 1)) self.end_headers() return # In other cases when '/prod/' is already in the request, # serve the main page and the resources, for example: # /prod/(index.html) -> /(index.html) # /prod/styles/(...) -> /styles/(...) self.path = self.path.replace("{0}/".format(product_endpoint), "", 1) else: # No product endpoint in the request. if self.path in ['/', '/index.html']: # In case the homepage is requested and only one product # exists, try to skip the product list and redirect the user # to the runs immediately. only_product = self.server.get_only_product() if only_product: if only_product.db_status == DBStatus.OK: LOG.info("Redirecting '/' to ONLY product '/%s'", only_product.endpoint) self.send_response(307) # 307 Temporary Redirect self.send_header("Location", '/{0}'.format(only_product.endpoint)) self.end_headers() return else: LOG.error("ONLY product '/%s' has database issues...", only_product.endpoint) self.send_response(307) # 307 Temporary Redirect self.send_header("Location", '/products.html') self.end_headers() return # If multiple products exist, route homepage queries to # serve the product list. LOG.debug("Serving product list as homepage.") self.path = '/products.html' self.send_response(200) # 200 OK SimpleHTTPRequestHandler.do_GET(self) # Actual serving of file.
def do_GET(self): if self.only_upgrade: self.send_error(405, "Method Not Allowed") else: SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): url = urlparse(self.path) if url.path.endswith('.html'): SimpleHTTPRequestHandler.do_GET(self) return tables = Base.metadata.tables table_name = url.path[1:] if table_name in tables.keys(): database = tables[table_name] else: self.send_response(404) return # here, so as not to override __init__ # pylint: disable=W0201 self.queries = {} if url.query: self.queries = parse_qs(url.query) self.send_headers() # here, so as not to override __init__ # pylint: disable=W0201 self.deltas = { \ 'minutes_ago': minutes_ago, \ 'hours_ago': hours_ago, \ 'days_ago': days_ago, \ 'weeks_ago': weeks_ago, \ 'months_ago': months_ago, \ 'years_ago': years_ago \ } if table_name == 'connections' and 'geoip' in self.queries: self.geoip() return elif 'chartjs' in self.queries: self.chartjs(table_name) return elif 'passwords' in self.queries: self.get_top_passwords() return elif 'usernames' in self.queries: self.get_top_usernames() return elif 'attacks' in self.queries: self.get_daily_attacks() return query = select([database]) for delta in self.deltas: if delta in self.queries: diff = int(self.queries[delta][0]) query = session.query(database).join(Connections) \ .filter(Connections.created_at > self.deltas[delta](diff)) break results = session.execute(query) if 'handd' in self.queries: self.header_and_data(database, results) return dump = json.dumps([dict(r) for r in results], default=alchemyencoder) # JSONP if 'callback' in self.queries: self.wfile.write(self.queries['callback'][0].encode() + b'(') self.wfile.write(dump[1:-1].encode()) self.wfile.write(b')') else: self.wfile.write(dump.encode())
def do_GET(self): logging.error(self.headers) SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self): try: SimpleHTTPRequestHandler.do_GET(self) except Exception as e: self.handle_exception(e)
def do_GET(self): if self.path != '/cam': return SimpleHTTPRequestHandler.do_GET(self) self.serving = True
def serve(self, http_handler, page: dict, config: dict, site: KartDict, map: KartMap): http_handler.path = self.base_url + http_handler.path return SimpleHTTPRequestHandler.do_GET(http_handler)
def do_GET(self): """ Handle GET request """ consumer_key = os.environ.get('XERO_CONSUMER_KEY') consumer_secret = os.environ.get('XERO_CONSUMER_SECRET') if consumer_key is None or consumer_secret is None: raise KeyError( 'Please define both XERO_CONSUMER_KEY and XERO_CONSUMER_SECRET environment variables' ) print("Serving path: {}".format(self.path)) path = urlparse(self.path) if path.path == '/do-auth': credentials = PublicCredentials( consumer_key, consumer_secret, callback_uri='http://localhost:8000/oauth') # 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 = 'Your contacts:<br><br>' contacts = xero.contacts.all() if contacts: page_body += '<br>'.join( [str(contact) for contact in contacts]) else: page_body += 'No contacts' self.page_response(title='Xero Contacts', body=page_body) return SimpleHTTPRequestHandler.do_GET(self)