moving four basic sessions to front of the course

Author: cewing

resources/session01/echo_client.py

@@ -0,0 +1,48 @@
+import socket
+import sys
+
+
+def client(msg, log_buffer=sys.stderr):
+    server_address = ('localhost', 10000)
+    # TODO: Replace the following line with your code which will instantiate
+    #       a TCP socket with IPv4 Addressing, call the socket you make 'sock'
+    sock = None
+    print('connecting to {0} port {1}'.format(*server_address), file=log_buffer)
+    # TODO: connect your socket to the server here.
+
+    # you can use this as a place to accumulate the entire message echoed back
+    # from the server
+    received_message = ''
+
+    # this try/finally block exists purely to allow us to close the socket
+    # when we are finished with it
+    try:
+        print('sending "{0}"'.format(msg), file=log_buffer)
+        # TODO: send your message to the server here.
+
+        # TODO: the server should be sending you back your message as a series
+        #       of 16-byte chunks. Accumulate the chunks you get to build the
+        #       entire reply from the server. Make sure that you have received
+        #       the entire message and then you can break the loop.
+        #
+        #       Log each chunk you receive.  Use the print statement below to
+        #       do it. This will help in debugging problems
+        chunk = ''
+        print('received "{0}"'.format(chunk.decode('utf8')), file=log_buffer)
+    finally:
+        # TODO: after you break out of the loop receiving echoed chunks from
+        #       the server you will want to close your client socket.
+        print('closing socket', file=log_buffer)
+
+        # TODO: when all is said and done, you should return the reply you got
+        # from the server as the value of this function.
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        usage = '\nusage: python echo_client.py "this is my message"\n'
+        print(usage, file=sys.stderr)
+        sys.exit(1)
+
+    msg = sys.argv[1]
+    client(msg)

resources/session01/echo_server.py

@@ -0,0 +1,76 @@
+import socket
+import sys
+
+
+def server(log_buffer=sys.stderr):
+    # set an address for our server
+    address = ('127.0.0.1', 10000)
+    # TODO: Replace the following line with your code which will instantiate
+    #       a TCP socket with IPv4 Addressing, call the socket you make 'sock'
+    sock = None
+    # TODO: You may find that if you repeatedly run the server script it fails,
+    #       claiming that the port is already used.  You can set an option on
+    #       your socket that will fix this problem. We DID NOT talk about this
+    #       in class. Find the correct option by reading the very end of the
+    #       socket library documentation:
+    #       http://docs.python.org/3/library/socket.html#example
+
+    # log that we are building a server
+    print("making a server on {0}:{1}".format(*address), file=log_buffer)
+
+    # TODO: bind your new sock 'sock' to the address above and begin to listen
+    #       for incoming connections
+
+    try:
+        # the outer loop controls the creation of new connection sockets. The
+        # server will handle each incoming connection one at a time.
+        while True:
+            print('waiting for a connection', file=log_buffer)
+
+            # TODO: make a new socket when a client connects, call it 'conn',
+            #       at the same time you should be able to get the address of
+            #       the client so we can report it below.  Replace the
+            #       following line with your code. It is only here to prevent
+            #       syntax errors
+            addr = ('bar', 'baz')
+            try:
+                print('connection - {0}:{1}'.format(*addr), file=log_buffer)
+
+                # the inner loop will receive messages sent by the client in
+                # buffers.  When a complete message has been received, the
+                # loop will exit
+                while True:
+                    # TODO: receive 16 bytes of data from the client. Store
+                    #       the data you receive as 'data'.  Replace the
+                    #       following line with your code.  It's only here as
+                    #       a placeholder to prevent an error in string
+                    #       formatting
+                    data = b''
+                    print('received "{0}"'.format(data.decode('utf8')))
+                    # TODO: Send the data you received back to the client, log
+                    # the fact using the print statement here.  It will help in
+                    # debugging problems.
+                    print('sent "{0}"'.format(data.decode('utf8')))
+                    # TODO: Check here to see if the message you've received is
+                    # complete.  If it is, break out of this inner loop.
+
+            finally:
+                # TODO: When the inner loop exits, this 'finally' clause will
+                #       be hit. Use that opportunity to close the socket you
+                #       created above when a client connected.
+                print(
+                    'echo complete, client connection closed', file=log_buffer
+                )
+
+    except KeyboardInterrupt:
+        # TODO: Use the python KeyboardInterrupt exception as a signal to
+        #       close the server socket and exit from the server function.
+        #       Replace the call to `pass` below, which is only there to
+        #       prevent syntax problems
+        pass
+        print('quitting echo server', file=log_buffer)
+
+
+if __name__ == '__main__':
+    server()
+    sys.exit(0)

resources/session01/socket_tools.py

@@ -0,0 +1,21 @@
+import socket
+
+
+def get_constants(prefix):
+    return {getattr(socket, n): n for n in dir(socket) if n.startswith(prefix)}
+
+
+families = get_constants('AF_')
+types = get_constants('SOCK_')
+protocols = get_constants('IPPROTO_')
+
+
+def get_address_info(host, port):
+    for response in socket.getaddrinfo(host, port):
+        fam, typ, pro, nam, add = response
+        print('family: {}'.format(families[fam]))
+        print('type: {}'.format(types[typ]))
+        print('protocol: {}'.format(protocols[pro]))
+        print('canonical name: {}'.format(nam))
+        print('socket address: {}'.format(add))
+        print

resources/session01/tasks.txt

@@ -0,0 +1,53 @@
+Session 4 Homework
+==================
+
+Required Tasks:
+---------------
+
+* Complete the code in ``echo_server.py`` to create a server that sends back
+  whatever messages it receives from a client
+
+* Complete the code in ``echo_client.py`` to create a client function that
+  can send a message and receive a reply.
+
+* Ensure that the tests in ``tests.py`` pass.
+
+To run the tests:
+
+* Open one terminal while in this folder and execute this command:
+
+    $ python echo_server.py
+
+* Open a second terminal in this same folder and execute this command:
+
+    $ python tests.py
+
+
+
+
+Optional Tasks:
+---------------
+
+Simple:
+
+* Write a python function that lists the services provided by a given range of
+  ports.
+
+  * accept the lower and upper bounds as arguments
+  * provide sensible defaults
+  * Ensure that it only accepts valid port numbers (0-65535)
+
+Challenging:
+
+* The echo server as outlined will only process a connection from one client
+  at a time. If a second client were to attempt a connection, it would have to
+  wait until the first message was fully echoed before it could be dealt with.
+
+  Python provides a module called `select` that allows waiting for I/O events
+  in order to control flow. The `select.select` method can be used to allow
+  our echo server to handle more than one incoming connection in "parallel".
+
+  Read the documentation about the `select` module
+  (http://docs.python.org/2/library/select.html) and attempt to write a second
+  version of the echo server that can handle multiple client connections in
+  "parallel".  You do not need to invoke threading of any kind to do this.

resources/session01/tests.py

@@ -0,0 +1,46 @@
+from echo_client import client
+import socket
+import unittest
+
+
+class EchoTestCase(unittest.TestCase):
+    """tests for the echo server and client"""
+
+    def send_message(self, message):
+        """Attempt to send a message using the client
+
+        In case of a socket error, fail and report the problem
+        """
+        try:
+            reply = client(message)
+        except socket.error as e:
+            if e.errno == 61:
+                msg = "Error: {0}, is the server running?"
+                self.fail(msg.format(e.strerror))
+            else:
+                self.fail("Unexpected Error: {0}".format(str(e)))
+        return reply
+
+    def test_short_message_echo(self):
+        """test that a message short than 16 bytes echoes cleanly"""
+        expected = "short message"
+        actual = self.send_message(expected)
+        self.assertEqual(
+            expected,
+            actual,
+            "expected {0}, got {1}".format(expected, actual)
+        )
+
+    def test_long_message_echo(self):
+        """test that a message longer than 16 bytes echoes in 16-byte chunks"""
+        expected = "Four score and seven years ago our fathers did stuff"
+        actual = self.send_message(expected)
+        self.assertEqual(
+            expected,
+            actual,
+            "expected {0}, got {1}".format(expected, actual)
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()