Clarify assignment.

JASchilz · JASchilz · commit 447896b5caa0 · 2018-06-12T01:56:39.000-07:00
diff --git a/http_server.py b/http_server.py
@@ -1,5 +1,6 @@
 import socket
 import sys
+import traceback
 
 def response_ok(body=b"This is a minimal response", mimetype=b"text/plain"):
     """
@@ -17,63 +18,74 @@ def response_ok(body=b"This is a minimal response", mimetype=b"text/plain"):
         <html><h1>Welcome:</h1></html>\r\n
         '''
     """
-    pass
+
+    # TODO: Implement response_ok
+    return b""
+
+def response_method_not_allowed():
+    """Returns a 405 Method Not Allowed response"""
+
+    # TODO: Implement response_method_not_allowed
+    return b""
+
+
+def response_not_found():
+    """Returns a 404 Not Found response"""
+
+    # TODO: Implement response_not_found
+    return b""
 
 
 def parse_request(request):
     """
-    Given the content of an HTTP request, returns the uri of that request.
+    Given the content of an HTTP request, returns the path of that request.
 
     This server only handles GET requests, so this method shall raise a
     NotImplementedError if the method of the request is not GET.
     """
-    pass
-
-
-def response_method_not_allowed():
-    """Returns a 405 Method Not Allowed response"""
-    pass
 
+    # TODO: implement parse_request
+    return ""
 
-def response_not_found():
-    """Returns a 404 Not Found response"""
-    pass
-    
-
-def resolve_uri(uri):
+def response_path(path):
     """
     This method should return appropriate content and a mime type.
 
-    If the requested URI is a directory, then the content should be a
+    If the requested path is a directory, then the content should be a
     plain-text listing of the contents with mimetype `text/plain`.
 
-    If the URI is a file, it should return the contents of that file
+    If the path is a file, it should return the contents of that file
     and its correct mimetype.
 
-    If the URI does not map to a real location, it should raise an
+    If the path does not map to a real location, it should raise an
     exception that the server can catch to return a 404 response.
 
     Ex:
-        resolve_uri('/a_web_page.html') -> (b"<html><h1>North Carolina...",
+        response_path('/a_web_page.html') -> (b"<html><h1>North Carolina...",
                                             b"text/html")
 
-        resolve_uri('/images/sample_1.png')
+        response_path('/images/sample_1.png')
                         -> (b"A12BCF...",  # contents of sample_1.png
                             b"image/png")
 
-        resolve_uri('/') -> (b"images/, a_web_page.html, make_type.py,...",
+        response_path('/') -> (b"images/, a_web_page.html, make_type.py,...",
                              b"text/plain")
 
-        resolve_uri('/a_page_that_doesnt_exist.html') -> Raises a NameError
+        response_path('/a_page_that_doesnt_exist.html') -> Raises a NameError
 
     """
 
     # TODO: Raise a NameError if the requested content is not present
     # under webroot.
 
-    # TODO: Fill in the appropriate content and mime_type give the URI.
+    # TODO: Fill in the appropriate content and mime_type give the path.
     # See the assignment guidelines for help on "mapping mime-types", though
     # you might need to create a special case for handling make_time.py
+    #
+    # If the path is "make_time.py", then you may OPTIONALLY return the
+    # result of executing `make_time.py`. But you need only return the
+    # CONTENTS of `make_time.py`.
+    
     content = b"not implemented"
     mime_type = b"not implemented"
 
@@ -94,22 +106,44 @@ def server(log_buffer=sys.stderr):
             conn, addr = sock.accept()  # blocking
             try:
                 print('connection - {0}:{1}'.format(*addr), file=log_buffer)
+
+                request = ''
                 while True:
-                    data = conn.recv(16)
-                    print('received "{0}"'.format(data), file=log_buffer)
-                    if data:
-                        print('sending data back to client', file=log_buffer)
-                        conn.sendall(data)
-                    else:
-                        msg = 'no more data from {0}:{1}'.format(*addr)
-                        print(msg, log_buffer)
+                    data = conn.recv(1024)
+                    request += data.decode('utf8')
+
+                    if b'\r\n\r\n' in data:
                         break
+		
+
+                print("Request received:\n{}\n\n".format(request))
+
+                # TODO: Use parse_request to retrieve the path from the request.
+
+                # TODO: Use response_path to retrieve the content and the mimetype,
+                # based on the request path.
+
+                # TODO; If parse_request raised a NotImplementedError, then let
+                # response be a method_not_allowed response. If response_path raised
+                # a NameError, then let response be a not_found response. Else,
+                # use the content and mimetype from response_path to build a 
+                # response_ok.
+                response = response_ok(
+                    content=b"Welcome to my web server",
+                    mimetype=b"text/plain"
+                )
+
+                conn.sendall(response)
+            except:
+                traceback.print_exc()
             finally:
-                conn.close()
+                conn.close() 
 
     except KeyboardInterrupt:
         sock.close()
         return
+    except:
+        traceback.print_exc()
 
 
 if __name__ == '__main__':
