def main(socketmodule=None): if socketmodule is None: socketmodule = socket app, port = get_args() if app == 'myapp': s = socketmodule.socket() host = socketmodule.getfqdn() if port == 0: port = random.randint(8000, 9999) s.bind((host, port)) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) s.listen(5) print 'Entering infinite loop; hit CTRL-C to exit' while True: c, (client_host, client_port) = s.accept() print 'Got connection from', client_host, client_port handle_connection(c, client_port) elif app == 'image': imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() from wsgiref.simple_server import make_server host = socketmodule.getfqdn() if port == 0: port = random.randint(8000, 9999) httpd = make_server('', port, wsgi_app) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) try: httpd.serve_forever() finally: imageapp.teardown() elif app == 'altdemo': p = create_publisher() wsgi_app = quixote.get_wsgi_app() from wsgiref.simple_server import make_server host = socketmodule.getfqdn() if port == 0: port = random.randint(8000, 9999) p.is_thread_safe = True httpd = make_server('', port, wsgi_app) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) httpd.serve_forever() elif app in ('quotes', 'chat'): if port == 0: port = random.randint(8000, 9999) os.chdir(app) os.system("python2.7 %s-server %d" % (app, port))
def main(): parser = argparse.ArgumentParser() parser.add_argument( '-A', '--runApp', help = 'Application to run (image/altdemo/myapp)' ) parser.add_argument( '-p', '--portNumb', help = 'Specified port number', type=int ) args = parser.parse_args() # Handle port input (if there) if args.portNumb: port = args.portNumb else: port = random.randint(8000, 9999) # Determine what app to create if args.runApp == 'myapp': wsgi_app = make_app() elif args.runApp == 'image': imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.runApp == 'altdemo': p = create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.runApp == 'quotes': import quotes wsgi_app = quotes.setup() elif args.runApp == 'chat': import chat wsgi_app = chat.setup() elif args.runApp == 'cookie': import cookieapp wsgi_app = cookieapp.wsgi_app else: print 'Invalid Application...' return s = socket.socket() # Create a socket object host = socket.getfqdn() # Get local machine name s.bind((host, port)) # Bind to the port print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) s.listen(5) # Now wait for client connection. print 'Entering infinite loop; hit CTRL-C to exit' while True: # Establish connection with client. c, (client_host, client_port) = s.accept() print 'Got connection from', client_host, client_port try: handle_connection(c, port, wsgi_app) finally: imageapp.teardown()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-A",help="What application to run") parser.add_argument("-p",help="What port to use",type=int) args = parser.parse_args() if not args.A: print "Please specify an app with -A" return -1; if args.p: port = args.p else: port = random.randint(8000, 9999) if args.A == "image": imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.A == "altdemo": p = quixote.demo.altdemo.create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.A == "myapp": wsgi_app = make_app() elif args.A == "chat": wsgi_app = chatapp.ChatApp('./chat/html') elif args.A == "quotes": wsgi_app = quoteapp.QuotesApp('quotes/quotes.txt','./quotes/html') elif args.A == "cookie": wsgi_app = cookieapp.wsgi_app else: print "App not found" return -1; s = socket.socket() # Create a socket object host = socket.getfqdn() # Get local machine name s.bind((host, port)) # Bind to the port print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) s.listen(5) # Now wait for client connection. print 'Entering infinite loop; hit CTRL-C to exit' while True: # Establish connection with client. c, (client_host, client_port) = s.accept() print 'Got connection from', client_host, client_port handle_connection(c,wsgi_app)
def main(): s = socket.socket() # Create a socket object. host = socket.getfqdn() # Get local machine name. parser = argparse.ArgumentParser() #creating a parser parser.add_argument("-A", choices=['image', 'altdemo', 'myapp', 'quotes', 'chat', 'cookie'], help='Choose which app you would like to run') parser.add_argument("-p", type=int, help="Choose the port you would like to run on.") args = parser.parse_args() #Check to see if a port is specified if args.p == None: port = random.randint(8000, 9999) #Creating WSGI app s.bind((host, port)) else: port = args.p s.bind((host, port)) if args.A == 'myapp': wsgi_app = make_app() elif args.A == "image": imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.A == "altdemo": p = create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.A == "quotes": directory_path = './quotes/' wsgi_app = quotes.create_quotes_app(directory_path + 'quotes.txt', directory_path + 'html') elif args.A == "chat": wsgi_app = chat.create_chat_app('./chat/html') elif args.A == "cookie": wsgi_app = make_cookie_app() else: wsgi_app = make_app() #In the event that no argument is passed just make my_app print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) s.listen(5) #wait for client connection print 'Entering infinite loop; hit CTRL+C to exit' while True: #Establish a connection with the client c, (client_host, client_port) = s.accept() print 'Got connection from', client_host, client_port handle_connection(c, wsgi_app) #handle connection(c, validate_app) return
def main(): parse = argparse.ArgumentParser() parse.add_argument( '-A', '--run_app', help = 'Application to run (image/altdemo/myapp)' ) parse.add_argument( '-p', '--port_numb', help = 'Port number', type=int ) args = parse.parse_args() # Take care of port handling if args.port_numb: port = args.port_numb else: port = random.randrange(8000,9999) # Running the new apps if args.run_app == "myapp": wsgi_app = create_app() elif args.run_app == "image": imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() elif args.run_app == "altdemo": p = imageapp.create() wsgi_app = quixote.get_wsgi_app() elif args.run_app == "chat": import chat wsgi_app == chat.setup() elif args.run_app == "cookie": wsgi_app = cookie_app.wsgi_app elif args.run_app == "quotes": import quotes wgsgi_app = quotes.setup() else: raise Exception("Invalid app.") s = socket.socket() # Create a socket object host = socket.getfqdn() # Get local machine name s.bind((host, port)) # Bind to the port print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) s.listen(5) # Now wait for client connection. print 'Entering infinite loop; hit CTRL-C to exit' while True: # Establish connection with client. c, (client_host, client_port) = s.accept() print 'Got connection from', client_host, client_port handle_connection(c, port, wsgi_app)
def make_imageapp(): global _setup_complete if not _setup_complete: imageapp.setup() p = imageapp.create_publisher() _setup_complete = True return quixote.get_wsgi_app()
def main(): parser = argparse.ArgumentParser() parser.add_argument("-p", "--port", type=int, default=0) parser.add_argument("-A", "--app", default="simple") args = parser.parse_args() port = args.port appname = args.app ### if appname == "simple": from app import make_app the_wsgi_app = make_app() elif appname == "imageapp": import imageapp, quixote imageapp.setup() p = imageapp.create_publisher() the_wsgi_app = quixote.get_wsgi_app() elif appname == "cookie": import cookieapp the_wsgi_app = cookieapp.wsgi_app host = socket.getfqdn() # Get local machine name if port == 0: port = random.randint(8000, 9999) httpd = make_server("", port, the_wsgi_app) print "Serving at http://%s:%d/..." % (host, port) httpd.serve_forever()
def create_publisher(): # sets global Quixote publisher Publisher(TopDirectory(), display_exceptions='plain') # return a WSGI wrapper for the Quixote Web app. app = quixote.get_wsgi_app() app.publisher.is_thread_safe = True return app
def make_app(): global _the_app if _the_app is None: p = create_publisher() _the_app = quixote.get_wsgi_app() return _the_app
def setup(self): wsgi_app = None x = sys.stdout # Quixote mangles sys.stdout; save. try: publisher = create_publisher() wsgi_app = quixote.get_wsgi_app() finally: sys.stdout = x # restore. twill.add_wsgi_intercept("localhost", 80, lambda: wsgi_app, "/qx_test")
def setup(self): wsgi_app = None x = sys.stdout # Quixote mangles sys.stdout; save. try: publisher = create_publisher() wsgi_app = quixote.get_wsgi_app() finally: sys.stdout = x # restore. twill.add_wsgi_intercept('localhost', 80, lambda: wsgi_app, '/qx_test')
def make_app(): global _the_app global _selected_app if _the_app is None: if _selected_app == 'image': imageapp.setup() p = imageapp.create_publisher() _the_app = quixote.get_wsgi_app() elif _selected_app == 'altdemo': p = create_publisher() _the_app = quixote.get_wsgi_app() elif _selected_app == 'myapp': _the_app = app.make_app() elif _selected_app == 'django': sys.path.append(os.path.join(os.path.dirname(__file__), 'imageappdjango')) os.environ.setdefault("DJANGO_SETTINGS_MODULE", "imageappdjango.imageappdjango.settings-prod") _the_app = get_wsgi_application() else: raise Exception("Invalid app selected") return _the_app
def make_app(app_name): global _the_app if _the_app is None: if app_name == 'altdemo': p = create_publisher() else: p = imageapp.create_publisher() _the_app = quixote.get_wsgi_app() return _the_app
def create_publisher(coordinator, pubsubhubbub_server=None): push_list = [] if pubsubhubbub_server: push_list.append(pubsubhubbub_server) qx_app = QuixoteWebApp(coordinator, push_list) # sets global Quixote publisher Publisher(qx_app, display_exceptions="plain") # return a WSGI wrapper for the Quixote Web app. return quixote.get_wsgi_app()
def create_publisher(coordinator, pubsubhubbub_server=None): push_list = [] if pubsubhubbub_server: push_list.append(pubsubhubbub_server) qx_app = QuixoteWebApp(coordinator, push_list) # sets global Quixote publisher Publisher(qx_app, display_exceptions='plain') # return a WSGI wrapper for the Quixote Web app. return quixote.get_wsgi_app()
def init_app(current_app): global _app_init_complete if(current_app == MY_APP): return app.make_app() elif (current_app == QUIXOTE_ALTDEMO_APP): if not _app_init_complete: p = create_publisher() _app_init_complete = True return quixote.get_wsgi_app() elif (current_app == IMAGE_APP): if not _app_init_complete: imageapp.setup() p = imageapp.create_publisher() _app_init_complete = True return quixote.get_wsgi_app() elif (current_app == CHAT_APP): return ChatApp('./chat/html') elif (current_app == QUOTES_APP): return QuotesApp('./quotes/quotes.txt', './quotes/html') elif (current_app == COOKIE_APP): return cookieapp.wsgi_app
def make_app(app_type): global _the_app if _the_app is None: imageapp.setup() p = None if app_type == "imageapp": p = imageapp.create_publisher() else: # app_type == "altdemoapp": p = quixote.demo.altdemo.create_publisher() p.is_thread_safe = True # hack.. _the_app = quixote.get_wsgi_app() return _the_app
# Accepts one of the above three strings def choose_app(app_name): global _setup_complete if(app_name == APP_MINE): return app.make_app() elif(app_name == APP_QUIXOTE_ALTDEMO): if not _setup_complete: p = create_publisher() _setup_complete = True return quixote.get_wsgi_app() elif(app_name == APP_QUIXOTE_IMAGEAPP): if not _setup_complete: imageapp.setup() p = imageapp.create_publisher() _setup_complete = True return quixote.get_wsgi_app() elif(app_name == APP_CHAT): chat_app = chat.make() return chat_app elif(app_name == APP_QUOTES): quotes_app = quotes.make()
def make_altdemo(): create_publisher() return quixote.get_wsgi_app()
def make_imageapp(): imageapp.setup() p = imageapp.create_publisher() return quixote.get_wsgi_app()
import socket import random ### here is the code needed to create a WSGI application interface to ### a Quixote app: import quixote import imageapp imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() ### now that we have a WSGI app, we can run it in the WSGI reference server: from wsgiref.simple_server import make_server host = socket.getfqdn() # Get local machine name #port = random.randint(8000, 9999) port = 8000 httpd = make_server('', port, wsgi_app) print "Serving at http://%s:%d/..." % (host, port,) try: httpd.serve_forever() finally: imageapp.teardown()
def handle_connection(conn,host,port): received = conn.recv(1) if not received: print 'Error, remote client closed connection without sending anything' return while received[-4:] != '\r\n\r\n': received += conn.recv(1) headersHTTP = map(lambda x: x.split(" "), received.split("\r\n")) headerDic = {} for header in headersHTTP: if header[0] != "" and len(header) >= 2: #Dont get body from post headerDic[header[0].upper().replace(":", "").replace("-", "_")] = " ".join(header[1:]) url = headersHTTP[0][1] path = urlparse(url)[2] query = urlparse(url)[4] mode = headersHTTP[0][0] environ = {} if mode == "POST": #Get POST body body = "" while len(body) < int(headerDic['CONTENT_LENGTH']): body += conn.recv(1) environ['REQUEST_METHOD'] = mode environ['PATH_INFO'] = path environ['QUERY_STRING'] = query environ['CONTENT_TYPE'] = headerDic['CONTENT_TYPE'] environ['CONTENT_LENGTH'] = headerDic['CONTENT_LENGTH'] environ['SCRIPT_NAME'] = '' environ['SERVER_NAME'] = host environ['SERVER_PORT'] = str(port) environ['wsgi.input'] = StringIO.StringIO(body) environ['wsgi.version'] = (1, 0) environ['wsgi.errors'] = sys.stderr environ['wsgi.multithread'] = False environ['wsgi.multiprocess'] = False environ['wsgi.run_once'] = False environ['wsgi.url_scheme'] = "http" environ['HTTP_COOKIE'] = headerDic['COOKIE'] if headerDic.get('COOKIE') else "" if mode == "GET": environ['REQUEST_METHOD'] = mode environ['PATH_INFO'] = path environ['QUERY_STRING'] = query environ['CONTENT_TYPE'] = '' environ['SCRIPT_NAME'] = '' environ['CONTENT_LENGTH'] = str(0) environ['SERVER_NAME'] = 'localhost' environ['SERVER_PORT'] = str(port) environ['wsgi.input'] = StringIO.StringIO("") environ['wsgi.version'] = (1, 0) environ['wsgi.errors'] = sys.stderr environ['wsgi.multithread'] = False environ['wsgi.multiprocess'] = False environ['wsgi.run_once'] = False environ['wsgi.url_scheme'] = "http" environ['HTTP_COOKIE'] = headerDic['COOKIE'] if headerDic.get('COOKIE') else "" #Select WSGI app if args.myapp or args.app[0] == "myapp": new_app = validator(make_app()) elif args.quixote or args.imageapp or args.app[0] == "quixote" or args.app[0] == "imageapp": new_app = quixote.get_wsgi_app() elif args.app[0] == "quotes": new_app = QuotesApp('./quotes/quotes.txt', './quotes/html') elif args.app[0] == "chat": new_app = ChatApp('./chat/html') elif args.app[0] == "cookie": new_app = wsgi_cookie def start_response(status, response_headers): conn.send('HTTP/1.0 ') conn.send(status) conn.send('\r\n') for pair in response_headers: key, header = pair conn.send(key + ': ' + header + '\r\n') conn.send('\r\n') result = new_app(environ, start_response) for data in result: conn.send(data) conn.close()
def main(): """Waits for a connection, then serves a WSGI app using handle_connection""" # Create a socket object sock = socket.socket() # Get local machine name (fully qualified domain name) host = socket.getfqdn() argParser = argparse.ArgumentParser(description='Set up WSGI server') argParser.add_argument('-A', metavar='App', type=str, default=['myapp'], choices=['myapp', 'imageapp', 'altdemo', 'chat', 'quotes'], help='Select which app to run', dest='app') argParser.add_argument('-p', metavar='Port', type=int, default=-1, help='Select a port to run on', dest='p') argVals = argParser.parse_args() app = argVals.app if app == 'altdemo': ## Quixote altdemo import quixote from quixote.demo.altdemo import create_publisher p = create_publisher() wsgi_app = quixote.get_wsgi_app() ## elif app == 'imageapp': ## Image app import quixote import imageapp from imageapp import create_publisher p = create_publisher() imageapp.setup() wsgi_app = quixote.get_wsgi_app() ## elif app == 'chat': ## Chat app from chat.apps import ChatApp as make_app wsgi_app = make_app('chat/html') ## elif app == 'quotes': ## Chat app from quotes.apps import QuotesApp as make_app wsgi_app = make_app('quotes/quotes.txt', 'quotes/html') else: ## My app.py from app import make_app ## ## My app.py wsgi_app = make_app() ## # Bind to a (random) port port = argVals.p if argVals.p != -1 else random.randint(8000,9999) sock.bind((host, port)) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) # Now wait for client connection. sock.listen(5) print 'Entering infinite loop; hit CTRL-C to exit' # Determine which web app to serve app = argVals.app[0] while True: # Establish connection with client. conn, (client_host, client_port) = sock.accept() print 'Got connection from', client_host, client_port handle_connection(conn, port, wsgi_app)
def handle_connection(conn, pargs): # Start connection and receive data through headers data = conn.recv(1) while data[-4:] != '\r\n\r\n': bit = conn.recv(1) if bit == '': return else: data += bit # Repurpose code used earlier to parse headers into a dict reqc = StringIO.StringIO(data) reqc.readline() headers = {} while (True): temp = reqc.readline() if temp == "\r\n": break temp = temp.split("\r\n")[0].split(":", 1) headers[temp[0].lower()] = temp[1] req = data.split(" ") # Extra content if the type is post content = '' if data.startswith('POST '): # Receive the content data, based off the content length header while len(content) < int(headers['content-length']): content += conn.recv(1) path = urlparse.urlparse(req[1]) # Create the environ dict for the app environ = {} environ['REQUEST_METHOD'] = req[0] environ['PATH_INFO'] = path.path environ['QUERY_STRING'] = path.query environ['SERVER_NAME'] = pargs['host'] environ['SERVER_PORT'] = str(pargs['p']) if 'content-type' in headers: environ['CONTENT_TYPE'] = headers['content-type'] if 'content-length' in headers: environ['CONTENT_LENGTH'] = headers['content-length'] environ['wsgi.input'] = StringIO.StringIO(content) environ['wsgi.errors'] = sys.stderr environ['wsgi.multithread'] = 0 environ['wsgi.multiprocess'] = 0 environ['wsgi.run_once'] = 0 environ['wsgi.url_scheme'] = 'http' environ['wsgi.version'] = (1,0) environ['SCRIPT_NAME'] = '' if 'cookie' in headers: environ['HTTP_COOKIE'] = headers['cookie'] else: environ['HTTP_COOKIE'] = '' print "%s %s" %(req[0], path.path) def start_response(status, response_headers): conn.send('HTTP/1.0 %s' % status) conn.send('\r\n') for head in response_headers: key, value = head conn.send('%s: %s' % (key, value)) conn.send('\r\n') conn.send('\r\n') if (pargs['A'] == 'altdemo'): _the_app = make_app() elif (pargs['A'] == 'quotes'): from quotes import apps _the_app = apps.QuotesApp('quotes/quotes.txt', './quotes/html') elif (pargs['A'] == 'chat'): from chat import apps _the_app = apps.ChatApp('./chat/html') elif (pargs['A'] == 'myapp'): _the_app = app.make_app() elif (pargs['A'] == 'cookie'): import cookieapp _the_app = cookieapp.wsgi_app else: _the_app = quixote.get_wsgi_app() #app1 = quixote.get_wsgi_app() result = _the_app(environ, start_response) for data in result: try: conn.send(data) except socket.error: break ##result.close() conn.close()
def handle_connection(conn, host, port, appname): environ = {} request = conn.recv(1) # This will get all the headers while request[-4:] != '\r\n\r\n': new = conn.recv(1) if new == '': return else: request += new request, data = request.split('\r\n',1) headers = {} for line in data.split('\r\n')[:-2]: key, val = line.split(': ', 1) headers[key.lower()] = val first_line_of_request_split = request.split('\r\n')[0].split(' ') # Path is the second element in the first line of the request # separated by whitespace. (Between GET and HTTP/1.1). GET/POST is first. http_method = first_line_of_request_split[0] environ['REQUEST_METHOD'] = first_line_of_request_split[0] try: parsed_url = urlparse.urlparse(first_line_of_request_split[1]) environ['PATH_INFO'] = parsed_url[2] env['QUERY_STRING'] = parsed_url[4] except: pass urlInfo = urlparse.urlparse(request.split(' ', 3)[1]) environ['REQUEST_METHOD'] = 'GET' environ['PATH_INFO'] = urlInfo[2] environ['QUERY_STRING'] = urlInfo[4] environ['CONTENT_TYPE'] = 'text/html' environ['CONTENT_LENGTH'] = str(0) environ['SCRIPT_NAME'] = '' environ['SERVER_NAME'] = socket.getfqdn() environ['SERVER_PORT'] = str(port) environ['wsgi.version'] = (1, 0) environ['wsgi.errors'] = sys.stderr environ['wsgi.multithread'] = False environ['wsgi.multiprocess'] = False environ['wsgi.run_once'] = False environ['wsgi.url_scheme'] = 'http' environ['HTTP_COOKIE'] = headers['cookie'] if 'cookie' in headers.keys() else '' def start_response(status, response_headers): conn.send('HTTP/1.0 ') conn.send(status) conn.send('\r\n') for pair in response_headers: key, header = pair conn.send(key + ': ' + header + '\r\n') conn.send('\r\n') content = '' if request.startswith('POST '): environ['REQUEST_METHOD'] = 'POST' environ['CONTENT_LENGTH'] = str(headers['content-length']) try: environ['CONTENT_TYPE'] = headers['content-type'] except: pass cLen = int(headers['content-length']) while len(content) < cLen: content += conn.recv(1) environ['wsgi.input'] = StringIO(content) # Create the appropriate wsgi app based on the command-line parameter if appname == "image": try: # Sometimes this gets called multiple times. Blergh. p = imageapp.create_publisher() imageapp.setup() except RuntimeError: pass wsgi_app = quixote.get_wsgi_app() elif appname == "myapp": wsgi_app = app.make_app() elif appname == "altdemo": try: p = quixote.demo.altdemo.create_publisher() except RuntimeError: pass wsgi_app = quixote.get_wsgi_app() elif appname == "quotes": # The quotes files are in the 'quotes' subdirectory directory_path = './quotes/' wsgi_app = quotes.create_quotes_app(directory_path + 'quotes.txt', directory_path + 'html') elif appname == "chat": # The chat files are in the 'quotes' subdirectory wsgi_app = chat.create_chat_app('./chat/html') elif appname == "cookie": wsgi_app = cookieapp.wsgi_app result = wsgi_app(environ, start_response) try: for response in result: conn.send(response) finally: if hasattr(result, 'close'): result.close() conn.close()
def handle_connection(conn, port, app): headers = {} headers_string = '' env={} while headers_string[-4:] != '\r\n\r\n': headers_string += conn.recv(1) initLine, headerData = headers_string.split('\r\n', 1) init_list = initLine.split(' ') requestType = init_list[0] url = urlparse(init_list[1]) path = url[2] query = url[4] headers_list = headers_string.split('\r\n')[1:] for line in headerData.split('\r\n')[:-2]: key, val = line.split(': ', 1) headers[key.lower()] = val env['REQUEST_METHOD'] = 'GET' env['PATH_INFO'] = path env['QUERY_STRING'] = query env['CONTENT_TYPE'] = 'text/html' env['CONTENT_LENGTH'] = str(0) env['SCRIPT_NAME'] = '' env['SERVER_NAME'] = socket.getfqdn() env['SERVER_PORT'] = str(port) env['wsgi.version'] = (1, 0) env['wsgi.errors'] = stderr env['wsgi.multithread'] = False env['wsgi.multiprocess'] = False env['wsgi.run_once'] = False env['wsgi.url_scheme'] = 'http' env['HTTP_COOKIE'] = headers['cookie'] if 'cookie' in headers.keys() else '' def start_response(status, headers_response): conn.send('HTTP/1.0 ') conn.send(status) conn.send('\r\n') for pair in headers_response: key, header = pair conn.send(key + ': ' + header + '\r\n') conn.send('\r\n') content='' if requestType == "POST": env['REQUEST_METHOD'] = 'POST' env['CONTENT_LENGTH'] = str(headers['content-length']) try: env['CONTENT_TYPE'] = headers['content-type'] except: pass print "CONTENTLENGTH!!!" print env['CONTENT_LENGTH'] content_length = int(headers['content-length']) # !!! On Arctic, this drops data # content = conn.recv(content_length) while len(content) < content_length: content += conn.recv(1) env['wsgi.input'] = StringIO(content) if app == 'altdemo': import quixote from quixote.demo.altdemo import create_publisher try: p = create_publisher() except RuntimeError: pass wsgi = quixote.get_wsgi_app() elif app == 'image': import quixote import imageapp from imageapp import create_publisher try: p = create_publisher() imageapp.setup() except RuntimeError: pass wsgi = quixote.get_wsgi_app() elif app == "quotes": import quotes wsgi = quotes.get_wsgi_app('./quotes/quotes.txt', './quotes/html') elif app == "chat": import chat wsgi = chat.get_wsgi_app('./chat/html') elif app == "cookie": import cookieapp wsgi = cookieapp.wsgi_app else: from app import make_app wsgi = make_app() wsgi = validator(wsgi) result = wsgi(env, start_response) for data in result: conn.send(data) result.close() conn.close()
def handle_connection(conn, port, wsgi_app): """Takes a socket connection, and serves a WSGI app over it. Connection is closed when app is served.""" # Start reading in data from the connection req = conn.recv(1) count = 0 env = {} while req[-4:] != '\r\n\r\n': new = conn.recv(1) if new == '': return else: req += new # Parse the headers we've received req, data = req.split('\r\n',1) headers = {} for line in data.split('\r\n')[:-2]: key, val = line.split(': ', 1) headers[key.lower()] = val # Parse the path and related env info urlInfo = urlparse(req.split(' ', 3)[1]) env['REQUEST_METHOD'] = 'GET' env['PATH_INFO'] = urlInfo[2] env['QUERY_STRING'] = urlInfo[4] env['CONTENT_TYPE'] = 'text/html' env['CONTENT_LENGTH'] = str(0) env['SCRIPT_NAME'] = '' env['SERVER_NAME'] = socket.getfqdn() env['SERVER_PORT'] = str(port) env['wsgi.version'] = (1, 0) env['wsgi.errors'] = stderr env['wsgi.multithread'] = False env['wsgi.multiprocess'] = False env['wsgi.run_once'] = False env['wsgi.url_scheme'] = 'http' env['HTTP_COOKIE'] = headers['cookie'] if 'cookie' in headers.keys() else '' # Start response function for WSGI interface def start_response(status, response_headers): """Send the initial HTTP header, with status code and any other provided headers""" # Send HTTP status conn.send('HTTP/1.0 ') conn.send(status) conn.send('\r\n') # Send the response headers for pair in response_headers: key, header = pair conn.send(key + ': ' + header + '\r\n') conn.send('\r\n') # If we received a POST request, collect the rest of the data content = '' if req.startswith('POST '): # Set up extra env variables env['REQUEST_METHOD'] = 'POST' env['CONTENT_LENGTH'] = str(headers['content-length']) env['CONTENT_TYPE'] = headers['content-type'] # Continue receiving content up to content-length cLen = int(headers['content-length']) while len(content) < cLen: content += conn.recv(1) env['wsgi.input'] = StringIO(content) if wsgi_app == "image": from imageapp import create_publisher imageapp.setup() try: p = imageapp.create_publisher() except RuntimeError: pass wsgi_app = quixote.get_wsgi_app() elif wsgi_app == "myapp": from app import make_app wsgi_app = make_app() elif wsgi_app == "altdemo": from quixote.demo.altdemo import create_publisher try: p = create_publisher() except RuntimeError: pass wsgi_app = quixote.get_wsgi_app() elif wsgi_app == "quotes": wsgi_app = quotes.create_quotes_app('./quotes/quotes.txt', './quotes/html') elif wsgi_app == "chat": wsgi_app = chat.create_chat_app('./chat/html') ## VALIDATION ## wsgi_app = validator(wsgi_app) result = wsgi_app(env, start_response) # Serve the processed data for data in result: conn.send(data) # Close the connection result.close() conn.close()
def handle_connection(conn, port, app): loader = jinja2.FileSystemLoader('./templates') env = jinja2.Environment(loader=loader) print 'New connection, you\'re so popular!' info = conn.recv(1) # info is headers while info[-4:] != '\r\n\r\n': info += conn.recv(1) # req is either POST or GET req = info.split('\r\n')[0].split(' ')[0] # reqType is the path extracted reqType = info.split('\r\n')[0].split(' ')[1] urlInfo = urlparse.urlparse(reqType) reqType = urlInfo.path query = urlInfo.query cookies = '' content = ''; contentLength = 0; contentType = ''; wsgi_input = ''; lineSplit = info.split('\r\n') if req == 'POST': for s in lineSplit: if 'Content-Type' in s: contentType = s.split(' ', 1)[1] if 'Content-Length' in s: contentLength = int (s.split()[1]) for i in range(contentLength): content += conn.recv(1) wsgi_input = content environ = {} environ['REQUEST_METHOD'] = req environ['PATH_INFO'] = reqType environ['QUERY_STRING'] = query environ['CONTENT_TYPE'] = contentType environ['CONTENT_LENGTH'] = str(contentLength) environ['wsgi.input'] = StringIO(wsgi_input) environ['SCRIPT_NAME'] = '' environ['SERVER_NAME'] = socket.getfqdn() environ['SERVER_PORT'] = str(port) environ['wsgi.errors'] = StringIO('blah') environ['wsgi.multithread'] = '' environ['wsgi.multiprocess'] = '' environ['wsgi.run_once'] = '' environ['wsgi.version'] = (2,0) environ['wsgi.url_scheme'] = 'http' # Splits headers on line and returns line with cookies. for line in lineSplit: if 'Cookie: ' in line: cookies = line.split(' ', 1)[1] environ['HTTP_COOKIE'] = cookies def start_response(status, response_headers): conn.send('HTTP/1.0 ') conn.send(status) conn.send('\r\n') for k, v in response_headers: conn.send("%s: %s\r\n" % (k, v)) conn.send('\r\n') if app == "image": wsgi_app = quixote.get_wsgi_app() elif app == "altdemo": p = quixote.demo.altdemo.create_publisher() wsgi_app = quixote.get_wsgi_app() elif app == "myapp": wsgi_app = make_app() elif app == "quotes": wsgi_app = quotes.setup() elif app == "chat": wsgi_app = chat.setup() elif app == "cookie": wsgi_app = cookieapp.wsgi_app else: print 'no such app' # wsgi_app = make_app() # validator_app = validator(wsgi_app) output = wsgi_app(environ, start_response) # output = validator_app(environ, start_response) for line in output: conn.send(line) #conn.send(output) """ ret = ["%s: %s\n" % (key, value) for key, value in environ.iteritems()] print ret """ conn.close()
def main(): """ Initializes the Server. Parses command line arguments (if present), then initializes the wsgi_app and starts up the server, then waits for connections """ apps = [ 'fires', 'hw6', 'imageapp', 'quixote_demo', 'quotes', 'chat', 'cookie' ] parser = argparse.ArgumentParser( description='A WSGI Server implemented for CSE491-001.', epilog='Please check the non-existent documentation for more info.', formatter_class=argparse.RawTextHelpFormatter ) # Add the '-?' alias for '--help', which I prefer to use: parser.add_argument('-?', action='help', help='Alias for --help') # Add the application argument: parser.add_argument('--app', nargs='?', dest='app', default='fires', choices=apps, help='\n'.join([ 'Which WSGI application to run.', '(default: "%(default)s" - my homework 6)', 'Alias: -A' ])) parser.add_argument('-A', nargs='?', dest='app', default='fires', choices=apps, help=argparse.SUPPRESS) # Add the port argument: parser.add_argument('--port', nargs='?', default=random.randint(8000, 9999), type=int, help='\n'.join([ 'Which port to start the server on.', '(default: random integer between 8000 and 9999)', 'Alias: -p' ])) # After that, parse the command-line arguments. args = parser.parse_args() # Create a socket object sock = socket.socket() # Get local machine name host = socket.getfqdn() if host in ('magrathea', 'Thoth'): # For testing, I don't want to have to change my url all the damn time. port = 8080 else: port = args.port # Bind to the port # TODO figure out how to immediately unbind when I'm done sock.bind((host, port)) print 'Starting server at http://%s:%d/' % (host, port) # Now wait for client connection. sock.listen(5) # get this from commandline app_to_run = args.app if app_to_run == 'quixote_demo': # quixote stuff for testing with that p = create_publisher() # p.is_thread_safe = True # hack... wsgi_app = quixote.get_wsgi_app() elif app_to_run == 'imageapp': imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() elif app_to_run == 'quotes': wsgi_app = QuotesApp('./quotes/quotes.txt', './quotes/html') elif app_to_run == 'chat': wsgi_app = ChatApp('./chat/html') elif app_to_run == 'cookie': wsgi_app = cookieapp.wsgi_app else: #if app_to_run == 'fires': # default wsgi_app = app.make_app() print 'Entering infinite loop; hit CTRL-C to exit' try: while True: # Establish connection with client. conn, (client_host, client_port) = sock.accept() print 'Got connection from', client_host, client_port handle_connection(conn, wsgi_app) finally: # teardown stuffs if app_to_run == 'imageapp': imageapp.teardown() sock.shutdown(2) sock.close()
def handle_connection(conn, host, port, appname): environ = {} request = conn.recv(1) # This will get all the headers while request[-4:] != "\r\n\r\n": new = conn.recv(1) if new == "": return else: request += new request, data = request.split("\r\n", 1) headers = {} for line in data.split("\r\n")[:-2]: key, val = line.split(": ", 1) headers[key.lower()] = val first_line_of_request_split = request.split("\r\n")[0].split(" ") # Path is the second element in the first line of the request # separated by whitespace. (Between GET and HTTP/1.1). GET/POST is first. http_method = first_line_of_request_split[0] environ["REQUEST_METHOD"] = first_line_of_request_split[0] try: parsed_url = urlparse.urlparse(first_line_of_request_split[1]) environ["PATH_INFO"] = parsed_url[2] env["QUERY_STRING"] = parsed_url[4] except: pass urlInfo = urlparse.urlparse(request.split(" ", 3)[1]) environ["REQUEST_METHOD"] = "GET" environ["PATH_INFO"] = urlInfo[2] environ["QUERY_STRING"] = urlInfo[4] environ["CONTENT_TYPE"] = "text/html" environ["CONTENT_LENGTH"] = str(0) environ["SCRIPT_NAME"] = "" environ["SERVER_NAME"] = socket.getfqdn() environ["SERVER_PORT"] = str(port) environ["wsgi.version"] = (1, 0) environ["wsgi.errors"] = sys.stderr environ["wsgi.multithread"] = False environ["wsgi.multiprocess"] = False environ["wsgi.run_once"] = False environ["wsgi.url_scheme"] = "http" environ["HTTP_COOKIE"] = headers["cookie"] if "cookie" in headers.keys() else "" def start_response(status, response_headers): conn.send("HTTP/1.0 ") conn.send(status) conn.send("\r\n") for pair in response_headers: key, header = pair conn.send(key + ": " + header + "\r\n") conn.send("\r\n") content = "" if request.startswith("POST "): environ["REQUEST_METHOD"] = "POST" environ["CONTENT_LENGTH"] = str(headers["content-length"]) try: environ["CONTENT_TYPE"] = headers["content-type"] except: pass cLen = int(headers["content-length"]) while len(content) < cLen: content += conn.recv(1) environ["wsgi.input"] = StringIO(content) # Create the appropriate wsgi app based on the command-line parameter if appname == "image": try: # Sometimes this gets called multiple times. Blergh. p = imageapp.create_publisher() imageapp.setup() except RuntimeError: pass wsgi_app = quixote.get_wsgi_app() elif appname == "myapp": wsgi_app = app.make_app() elif appname == "altdemo": try: p = quixote.demo.altdemo.create_publisher() except RuntimeError: pass wsgi_app = quixote.get_wsgi_app() elif appname == "quotes": # The quotes files are in the 'quotes' subdirectory directory_path = "./quotes/" wsgi_app = quotes.create_quotes_app(directory_path + "quotes.txt", directory_path + "html") elif appname == "chat": # The chat files are in the 'quotes' subdirectory wsgi_app = chat.create_chat_app("./chat/html") elif appname == "cookie": wsgi_app = cookieapp.wsgi_app result = wsgi_app(environ, start_response) try: for response in result: conn.send(response) finally: if hasattr(result, "close"): result.close() conn.close()
def main(socketmodule=None): if socketmodule is None: socketmodule = socket app, port = get_args() if app == 'myapp': s = socketmodule.socket() host = socketmodule.getfqdn() if port == 0: port = random.randint(8000, 9999) s.bind((host, port)) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) s.listen(5) print 'Entering infinite loop; hit CTRL-C to exit' while True: c, (client_host, client_port) = s.accept() print 'Got connection from', client_host, client_port handle_connection(c, client_port) elif app == 'image': imageapp.setup() p = imageapp.create_publisher() wsgi_app = quixote.get_wsgi_app() from wsgiref.simple_server import make_server host = socketmodule.getfqdn() if port == 0: port = random.randint(8000, 9999) httpd = make_server('', port, wsgi_app) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) try: httpd.serve_forever() finally: imageapp.teardown() elif app == 'altdemo': p = create_publisher() wsgi_app = quixote.get_wsgi_app() from wsgiref.simple_server import make_server host = socketmodule.getfqdn() if port == 0: port = random.randint(8000, 9999) p.is_thread_safe = True httpd = make_server('', port, wsgi_app) print 'Starting server on', host, port print 'The Web server URL for this would be http://%s:%d/' % (host, port) httpd.serve_forever() elif app == 'quotes': if port == 0: port = random.randint(8000, 9999) quotes_app = QuotesApp('quotes.txt', './quoteshtml') Server(port, quotes_app).serve_forever() elif app == 'chat': if port == 0: port = random.randint(8000, 9999) chat_app = ChatApp('./chathtml') Server(port, chat_app).serve_forever() elif app == 'cookie': if port == 0: port = random.randint(8000, 9999) import cookieapp from wsgiref.simple_server import make_server the_wsgi_app = cookieapp.wsgi_app host = socket.getfqdn() # Get local machine name httpd = make_server('', port, the_wsgi_app) print "Serving at http://%s:%d/..." % (host, port,) httpd.serve_forever()
def create_publisher(coordinator): # sets global Quixote publisher Publisher(QuixoteWebApp(coordinator), display_exceptions="plain") # return a WSGI wrapper for the Quixote Web app. return quixote.get_wsgi_app()
import quixote, qx_testserver from wsgiref.simple_server import make_server qx_testserver.create_publisher() wsgi_app = quixote.get_wsgi_app() httpd = make_server('', 8000, wsgi_app) httpd.serve_forever()