Schutt HW 2 work

assignments/src/MV3500Cohort2019JulySeptember/homework2/Schutt/SchuttClient.java

@@ -4,19 +4,15 @@ import java.io.*;
 import java.net.*;
 
 /**
- * Before, we always used telnet (netcat) to connect to the server. Here we are 
- * now writing our own program to do the connection.
+ * This is a client program that establishes a socket connection to a dispatch
+ * server, then it sends a simple math equation to be solved.
  *
- * As you will see, when we run this after we start the server we will see the
- * same string telnet printed, sent by the server. The output at the server will
- * show different socket pairs for each time the loop iterates.
- *
- * @author mcgredo
+ * @author Schutt
  */
 public class SchuttClient {
 
     // IPv6 String constant for localhost address, similarly IPv4 127.0.0.1
-    public final static String LOCALHOST = "0:0:0:0:0:0:0:1";
+    
 
     public static void main(String[] args) {
         
@@ -28,17 +24,24 @@ public class SchuttClient {
         OutputStream os;
         PrintStream ps;
         String serverMessage;
+        String[] equations = new String[4];
+        
+        equations[0] = "1 + 1";
+        equations[1] = "2 + 2";
+        equations[2] = "2 * 2";
+        equations[3] = "3 * 3";
+        int index = 1;
         
         try {
-            while (true) {
-                System.out.println("SchuttClient creating socket...");
+            for(String eq : equations) {
+                System.out.println("SchuttClient creating socket #" + index + "...");
 
                 // We request an IP to connect to ("localhost") and
                 // port number at that IP (2317). This establishes
                 // a connection to that IP in the form of a Socket
                 // object; the server uses a ServerSocket to wait for
                 // connections.
-                socket = new Socket(LOCALHOST, 2317); // locohost?
+                socket = new Socket("localhost", 2317); // locohost?
 
                 // Now hook everything up (i.e. set up the streams), Java style:
                 // ** Added an output stream to the client so it can send a message to the server
@@ -55,9 +58,13 @@ public class SchuttClient {
                 System.out.println("==================================================");
                 System.out.println("Now we're talking!");
                 System.out.println("The message the server sent was: '" + serverMessage + "'");
-                ps.println("Who's there?");  // Sends a message to the server
                 // socket gets closed, either automatically/silently by this code (or possibly by the server)
                 
+                ps.println(eq);
+                serverMessage = br.readLine();
+                System.out.println(serverMessage);
+                System.out.println("===================================================");
+                index++;
             } // end while(true)
         } catch (IOException e) {
             System.err.println("Problem with SchuttServerClient networking:"); // describe what is happening
@@ -70,7 +77,7 @@ public class SchuttClient {
         } finally {
         
             // program exit: tell somebody about that
-            System.out.println("\nclient exit");
+            
         }
     }
 }

assignments/src/MV3500Cohort2019JulySeptember/homework2/Schutt/SchuttServer.java

-package MV3500Cohort2019JulySeptember.homework2.Schutt;
-
-import java.io.*;
-import java.net.*;
-
-/**
- * Very slightly more complex than example1, further modifying example2. The
- * only thing this does differently is introduce a loop into the response, so
- * you don't have to restart the program after one response. Also, it prints out
- * the socket pair the server sees. Run the program via telnet several times and
- * compare the socket pairs.
- *
- * telnet (nc) localhost 2317
- *
- * If you're sophisticated you can contact the instructor's computer while
- * running this program.
- *
- * telnet (nc) [ipNumberOfServerLaptop] 2317
- *
- * and have the instructor display the socket pairs received.
- *
- * @author mcgredo
- */
-public class SchuttServer {
-
-    public static void main(String[] args) {
-        try {
-
-            // ServerSocket waits for a connection from a client. 
-            // Notice that it is outside the loop; ServerSocket
-            // needs to be made only once.
-            System.out.println("SchuttServer has started..."); // it helps debugging to put this on console first
-
-            ServerSocket serverSocket = new ServerSocket(2317);
-            OutputStream os;
-            PrintStream ps;
-            InputStream is;
-            InputStreamReader isr;
-            BufferedReader br;
-            String clientResponse;
-            InetAddress localAddress, remoteAddress;
-            int localPort, remotePort;
-
-            // Server is up and waiting (i.e. "blocked" or paused)
-            // Loop, infinitely, waiting for client connections.
-            // Stop the program somewhere else.
-            while (true) {
-
-                // block until connected to a client
-                try (Socket clientConnection = serverSocket.accept()) {
-
-                    // Now hook everything up (i.e. set up the streams), Java style:
-                    // Added an input stream to gather the message sent from the client
-                    os = clientConnection.getOutputStream();
-                    is = clientConnection.getInputStream();
-                    isr = new InputStreamReader(is);
-                    br = new BufferedReader(isr);
-                    ps = new PrintStream(os);
-                    
-                    ps.println("Knock Knock!"); // this gets sent back to client!
-                    
-                    // Assigns the client message to a string
-                    clientResponse = br.readLine();
-                    // Print some information locally about the Socket connection.
-                    // This includes the port and IP numbers on both sides (the socket pair).
-                    localAddress = clientConnection.getLocalAddress();
-                    remoteAddress = clientConnection.getInetAddress();
-                    localPort = clientConnection.getLocalPort();
-                    remotePort = clientConnection.getPort();
-
-                    // My socket pair connection looks like this, to localhost:
-                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54876 ))
-                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
-                    // Why is the first IP/port the same, while the second set has different ports?
-                    System.out.println("SchuttServer socket pair: (( " + localAddress.toString() + ", " + localPort + " ), ( "
-                            + remoteAddress.toString() + ", " + remotePort + " ))");
-                    // Prints the message sent from the client
-                    System.out.println("++++++++++++++++++++++++++++++++++++");
-                    System.out.println("Client Response: " + clientResponse);
-                    System.out.println("====================================");
-
-                    // Notice the use of flush() and try w/ resources. Without
-                    // the try w/ resources the Socket object may stay open for
-                    // a while after the client has stopped needing this
-                    // connection. try w/ resources explicitly ends the connection.
-                    ps.flush();
-                    // like it or not, you're outta here!
-                }
-            }
-        } catch (IOException e) {
-            System.err.println("Problem with SchuttServer networking: " + e);
-
-            // Provide more helpful information to user if exception occurs due to running twice at one time
-            if (e instanceof java.net.BindException) {
-                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
-            }
-        }
-    }
-}

assignments/src/MV3500Cohort2019JulySeptember/homework2/Schutt/SchuttServerDispatcher.java

+package MV3500Cohort2019JulySeptember.homework2.Schutt;
+
+import java.net.*;
+
+/**
+ * Very slightly more complex than example1, further modifying example2. The
+ * only thing this does differently is introduce a loop into the response, so
+ * you don't have to restart the program after one response. Also, it prints out
+ * the socket pair the server sees. Run the program via telnet several times and
+ * compare the socket pairs.
+ *
+ * telnet (nc) localhost 2317
+ *
+ * If you're sophisticated you can contact the instructor's computer while
+ * running this program.
+ *
+ * telnet (nc) [ipNumberOfServerLaptop] 2317
+ *
+ * and have the instructor display the socket pairs received.
+ *
+ * @author Schutt
+ */
+public class SchuttServerDispatcher {
+
+    public static void main(String[] args) // execution starts here
+    {
+        try{
+            ServerSocket serverSocket = new ServerSocket(2317);
+            int connectionCount = 0;
+            
+            System.out.println("SchuttServerDispatcher ready to accept socket connections...");
+            
+            while(true){
+                Socket clientConnection = serverSocket.accept();
+                connectionCount++;
+                System.out.println("========================================================");
+                System.out.println("SchuttServerDispatcher.handlerThread invocation for connection #" + connectionCount + "...");
+                SchuttThreadHandler handlerThread = new SchuttThreadHandler(clientConnection);
+                
+            }
+        }
+        System.out.println("=============================================================");
+    }
+}

assignments/src/MV3500Cohort2019JulySeptember/homework2/Schutt/SchuttThreadHandler.java

+package MV3500Cohort2019JulySeptember.homework2.Schutt;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * A program that handles all logic associated with one socket connection
+ * by running in a thread of its own. This is the server
+ * portion as well, so we artificially invent what happens
+ * if the server can't respond to a connection for several seconds.
+ * Warning: do not run this class!  It is created automatically by TcpExample4DispatchServer.
+ * 
+ * @author Schutt
+ */
+
+public class SchuttThreadHandler extends Thread
+{
+    /** The socket connection to a client */
+    Socket socket;
+    
+    /** The thread constructor creates the socket from
+     * a ServerSocket, and passes one to the thread
+     * responsible for handling the connection.
+     * 
+     * @param socket The socket connection handled by this thread
+     */
+    public SchuttThreadHandler(Socket socket)
+    {
+        this.socket = socket;
+    }
+    
+    /** Handles one connection. We add an artificial slowness
+     * to handling the connection with a sleep(). This means
+     * the client won't see a server connection response for ten seconds (default).
+     */
+	// @overriding run() method in Java Thread class is deliberate
+	@Override 
+    public void run()
+    {
+        try
+        {
+            System.out.println("TcpExample4HandlerThread starting to handle a thread...");
+            // get the connection output stream, then wait a period of time. 
+             OutputStream os = socket.getOutputStream();
+              PrintStream ps = new PrintStream(os);
+
+			 final long TIMEOUT = 2000; // 2000 milliseconds = 2 seconds, 10000 milliseconds = 10 seconds
+			 System.out.println("TcpExample4HandlerThread pausing for TIMEOUT=" + TIMEOUT + "ms"); // debug
+             Thread.sleep(TIMEOUT);
+                
+            // ps is the PrintStream is the Java way to use System.print() to pass data along the socket.
+            ps.println("This message was written by the server TcpExample4HandlerThread");
+            ps.flush();     // make sure that it indeed escapes current process and reaches the client
+            socket.close(); // all clear, no longer need socket
+            System.out.println("TcpExample4HandlerThread finished handling a thread, now exit.");
+        }
+        catch(IOException | InterruptedException e) // either a networking or a threading problem
+        {
+            System.out.println("Problem with TcpExample4HandlerThread networking:"); // describe what is happening
+            System.out.println("Error: " + e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            if (e instanceof java.net.BindException)
+                System.out.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}