Merge origin/master

assignments/src/MV3500Cohort2024JulySeptember/homework2/Yu/YuHW2Client.java

+package MV3500Cohort2024JulySeptember.homework2.Yu;
+
+import java.io.*;
+import java.net.*;
+//import java.time.LocalTime; // conversion?
+
+/**
+ * @author Jin Hong Yu
+ */
+public class YuHW2Client {
+
+    /**
+     * Default constructor
+     */
+    public YuHW2Client() {
+        // default constructor
+    }
+    static String DESTINATION_HOST = "localhost";
+    static int MAX_LOOP_COUNT = 4;
+
+    /**
+     * Program invocation, execution starts here
+     *
+     * @param args command-line arguments
+     */
+    public static void main(String[] args) {
+        try {
+            System.out.println(YuHW2Client.class.getName() + " start, loop " + MAX_LOOP_COUNT + " times");
+            System.out.println("=======================================================");
+            for (int loopCount = 1; loopCount <= MAX_LOOP_COUNT; loopCount++) {
+                System.out.println(YuHW2Client.class.getName() + " creating new socket #" + loopCount + "...");
+
+                long startTime = System.currentTimeMillis();
+
+                Socket socket = new Socket(DESTINATION_HOST, 2317);
+
+                PrintStream ps = new PrintStream(socket.getOutputStream());
+                BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+
+                // Knock Knock joke sequence
+                ps.println("Knock Knock");
+                ps.flush();
+                System.out.println("Client: Knock Knock");
+
+                String serverResponse = br.readLine(); // blocks
+                System.out.println("Server: " + serverResponse);
+
+                if ("Who's there?".equals(serverResponse)) {
+                    ps.println("Hatch");
+                    ps.flush();
+                    System.out.println("Client: Hatch");
+                }
+
+                serverResponse = br.readLine();
+                System.out.println("Server: " + serverResponse);
+
+                if ("Hatch who?".equals(serverResponse)) {
+                    ps.println("God Bless You!");
+                    ps.flush();
+                    System.out.println("Client: God Bless You!");
+                }
+
+                long readTime = System.currentTimeMillis();
+                long timeLength = readTime - startTime;
+
+                System.out.println(YuHW2Client.class.getName() + ": time msec required for sequence=" + timeLength);
+                System.out.println("=======================================================");
+                socket.close();
+            }
+            System.out.println(YuHW2Client.class.getName() + " complete");
+        } catch (IOException e) {
+            System.out.println("Problem with " + YuHW2Client.class.getName() + " networking:");
+            System.out.println("Error: " + e);
+            if (e instanceof java.net.BindException) {
+                System.out.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        }
+    }
+}

assignments/src/MV3500Cohort2024JulySeptember/homework2/Yu/YuHW2HandlerThread.java

+package MV3500Cohort2024JulySeptember.homework2.Yu;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * @author Jin Hong Yu
+ */
+public class YuHW2HandlerThread extends Thread
+{
+    /** The socket connection to a client */
+    Socket socket;
+    
+    /** 
+     * The thread constructor creates the socket from a ServerSocket, waiting for the client to connect,
+     * and passes that socket when constructing the thread responsible for handling the connection.
+     * 
+     * @param socket The socket connection handled by this thread
+     */
+    YuHW2HandlerThread(Socket socket)
+    {
+        this.socket = socket;
+    }
+    /**
+     * Program invocation and execution starts here - but is illegal and unwanted, so warn the unsuspecting user!
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        System.out.println ("*** YuHW2HandlerThread is not a standalone executable progam.");
+        System.out.println ("*** Please run TcpExample4DispatchServer instead... now exiting.");
+    }
+    
+    /** 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(YuHW2HandlerThread.class.getName() + " starting to handle a thread...");
+
+        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
+        PrintStream ps = new PrintStream(socket.getOutputStream());
+
+        // Sequence of the Knock Knock joke
+        String clientMessage = in.readLine();
+        System.out.println("Client: " + clientMessage);
+
+        if ("Knock Knock".equals(clientMessage)) {
+            ps.println("Who's there?");
+            ps.flush();
+        }
+
+        clientMessage = in.readLine();
+        System.out.println("Client: " + clientMessage);
+
+        if ("Hatch".equals(clientMessage)) {
+            ps.println("Hatch who?");
+            ps.flush();
+        }
+
+        clientMessage = in.readLine();
+        System.out.println("Client: " + clientMessage);
+
+        if ("God Bless You!".equals(clientMessage)) {
+            System.out.println("Joke sequence complete.");
+        }
+
+        socket.close(); // all clear, no longer need socket
+        System.out.println(YuHW2HandlerThread.class.getName() + " finished handling a thread, now exit.");
+    } catch(IOException e) {
+        System.out.println("Problem with " + YuHW2HandlerThread.class.getName() + " networking:");
+        System.out.println("Error: " + e);
+        if (e instanceof java.net.BindException) {
+            System.out.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+      }
+    }
+}

assignments/src/MV3500Cohort2024JulySeptember/homework2/Yu/YuHW2Server.java

+package MV3500Cohort2024JulySeptember.homework2.Yu;
+
+import java.io.IOException;
+import java.net.*;
+
+/**
+ * @author Jin Hong Yu
+ */
+public class YuHW2Server
+{
+    /** Default constructor */
+    public YuHW2Server()
+    {
+        // default constructor
+    }
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try {
+            ServerSocket             serverSocket = new ServerSocket(2317);
+            Socket                   clientConnectionSocket;
+            YuHW2HandlerThread handlerThread;
+
+            int connectionCount = 0; // state variable
+
+            //System.out.println(TcpExample4DispatchServer.class.getName() + " ready to accept socket connections...");
+            while (true) // infinite loop
+            {
+                clientConnectionSocket = serverSocket.accept(); // block! until connected
+
+                connectionCount++; // unblocked, got another connection
+                
+                
+                System.out.println("=============================================================");
+                //System.out.println(TcpExample4DispatchServer.class.getName() + ".handlerThread created for connection #" + connectionCount + "...");
+                
+                // hand off this aready-created and connected socket to constructor
+                handlerThread = new YuHW2HandlerThread(clientConnectionSocket); 
+                handlerThread.start();// invokes the run() method in that object
+                //System.out.println(TcpExample4DispatchServer.class.getName() + ".handlerThread is now dispatched and running, using most recent connection...");
+                
+                // while(true) continue looping, serverSocket is still waiting for another customer client
+            }
+        } 
+        catch (IOException e) {
+            //System.out.println("Problem with " + TcpExample4DispatchServer.class.getName() + " 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!");
+            }
+        }
+        System.out.println("============================================================="); // execution complete
+    }
+}

examples/nbproject/configs/1g.TcpSentryServer.properties

+main.class=TcpExamples.TcpSentryScenarioDispatchServer

examples/nbproject/configs/1h.TcpSentryClient.properties

+main.class=TcpExamples.TcpSentryScenarioClient

examples/src/TcpExamples/TcpExample3Client.java

@@ -97,6 +97,10 @@ public class TcpExample3Client
             if (e instanceof java.net.BindException) {
                 System.err.println("*** Be sure to stop any other running instances of programs using this port!");
             }
+            else if (e instanceof java.net.ConnectException) 
+            {
+                System.out.println("*** Be sure to start the server before starting the client!");
+            }
         }
         finally // occurs after any other activity when shutting down
         {

examples/src/TcpExamples/TcpExample4Client.java

@@ -79,6 +79,10 @@ public class TcpExample4Client
             if (e instanceof java.net.BindException) {
                 System.out.println("*** Be sure to stop any other running instances of programs using this port!");
             }
+            else if (e instanceof java.net.ConnectException) 
+            {
+                System.out.println("*** Be sure to start the server before starting the client!");
+            }
         }
     }
 }

examples/src/TcpExamples/TcpSentryScenarioClient.java

@@ -112,12 +112,17 @@ public class TcpSentryScenarioClient
             System.out.println(prefix + " complete");
             // main method now exits
         } catch (IOException e) {
-            System.out.println("Problem with " + prefix + " networking:networking:"); // describe what is happening
-            System.out.println("Error: " + e);
+            System.out.println("*** Problem with " + prefix + "networking:"); // describe what is happening
+            System.out.println("    " + e);
             // Provide more helpful information to user if exception occurs due to running twice at one time
-            if (e instanceof java.net.BindException) {
+            if (e instanceof java.net.BindException) 
+            {
                 System.out.println("*** Be sure to stop any other running instances of programs using this port!");
             }
+            else if (e instanceof java.net.ConnectException) 
+            {
+                System.out.println("*** Be sure to start the server before starting the client!");
+            }
         }
     }
 }

examples/src/TcpExamples/TcpSentryScenarioDispatchServer.java

@@ -8,10 +8,13 @@ import java.net.*;
  * new thread to handle multiple incoming socket connections, one after another, all running in parallel.
  * This advanced technique is often used in high=performance high=capacity server programs.
  * 
+ * @see TcpSentryScenarioClient
+ * @see TcpSentryScenarioHandlerThread
  * @see TcpExample4Client
+ * @see TcpExample4DispatchServer
  * @see TcpExample4HandlerThread
  *
- * @see <a href="../../../src/TcpExamples/TcpExample4TerminalLog.txt" target="blank">TcpExample4TerminalLog.txt</a>
+ * @see <a href="../../../src/TcpExamples/TcpSentryScenarioTerminalLog.txt" target="blank">TcpSentryScenarioTerminalLog.txt</a>
  * @see <a href="../../../src/TcpExamples/TcpExample4SequenceDiagram.png" target="blank">TcpExample4SequenceDiagram.png</a>
  * @see <a href="../../../src/TcpExamples/TcpExample4SequenceSketch.png" target="blank">TcpExample4SequenceSketch.png</a>
  *
@@ -21,6 +24,8 @@ import java.net.*;
  */
 public class TcpSentryScenarioDispatchServer
 {
+    static String prefix = "[" + TcpSentryScenarioDispatchServer.class.getName() + "] ";
+            
     /** Default constructor */
     public TcpSentryScenarioDispatchServer()
     {
@@ -33,14 +38,15 @@ public class TcpSentryScenarioDispatchServer
     public static void main(String[] args)
     {
         try {
-            ServerSocket             serverSocket = new ServerSocket(2317);
-            Socket                   clientConnectionSocket;
-            TcpExample4HandlerThread handlerThread;
+            ServerSocket                   serverSocket = new ServerSocket(2317);
+            Socket                         clientConnectionSocket;
+            TcpSentryScenarioHandlerThread handlerThread;
 
             int connectionCount = 0; // state variable
 
-            System.out.println(TcpSentryScenarioDispatchServer.class.getName() + " ready to accept socket connections...");
-            while (true) // infinite loop
+            System.out.println(prefix + "waiting and ready to accept socket connection from client...");
+            
+            while (true) // infinite loop, handling client connections and dispatching another handler thread
             {
                 clientConnectionSocket = serverSocket.accept(); // block! until connected
 
@@ -49,26 +55,27 @@ public class TcpSentryScenarioDispatchServer
                 // TODO option for the student, provide initial message *to the client*
                 // that we are handing off to a dispatch thread... because that is polite behavior.
                 // Plenty of code in Example3, we instead let our proxy thread
-                // TcpExample4HandlerThread introduce itself to the client.
+                // TcpSentryScenarioHandlerThread introduce itself to the client.
                 
                 System.out.println("=============================================================");
-                System.out.println(TcpSentryScenarioDispatchServer.class.getName() + ".handlerThread created for connection #" + connectionCount + "...");
+                System.out.println(prefix + ".handlerThread created for connection #" + connectionCount + "...");
                 
                 // hand off this aready-created and connected socket to constructor
-                handlerThread = new TcpExample4HandlerThread(clientConnectionSocket); 
+                handlerThread = new TcpSentryScenarioHandlerThread(clientConnectionSocket); 
                 handlerThread.start();// invokes the run() method in that object
-                System.out.println(TcpSentryScenarioDispatchServer.class.getName() + ".handlerThread is now dispatched and running, using most recent connection...");
+                System.out.println(prefix + ".handlerThread is now dispatched and running, using most recent connection...");
                 
                 // while(true) continue looping, serverSocket is still waiting for another customer client
             }
         } 
         catch (IOException e) {
-            System.out.println("Problem with " + TcpSentryScenarioDispatchServer.class.getName() + " networking:"); // describe what is happening
+            System.out.println("Problem with " + prefix + " 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!");
             }
+            System.exit(-1);
         }
         System.out.println("============================================================="); // execution complete
     }

examples/src/TcpExamples/TcpSentryScenarioHandlerThread.java

@@ -2,17 +2,19 @@ package TcpExamples;
 
 import java.io.*;
 import java.net.*;
+import java.util.Arrays;
+import java.util.List;
 
 /**
  * <p>
- * This utility class supports the {@link TcpExample4DispatchServer} program,
+ * This utility class supports the {@link TcpSentryScenarioDispatchServer} program,
  * handling all programming logic needed for a new socket connection
  * to run 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.
  * </p>
  * <p>
- * Warning: do not run this class!  It is created and used automatically by {@link TcpExample4DispatchServer} at run time.
+ * Warning: do not run this class!  It is created and used automatically by {@link TcpSentryScenarioDispatchServer} at run time.
  * </p>
  * 
  * @see TcpSentryScenarioClient
@@ -21,7 +23,7 @@ import java.net.*;
  * @see TcpExample4DispatchServer
  * @see TcpExample4HandlerThread
  *
- * @see <a href="../../../src/TcpExamples/TcpExample4TerminalLog.txt" target="blank">TcpExample4TerminalLog.txt</a>
+ * @see <a href="../../../src/TcpExamples/TcpSentryScenarioTerminalLog.txt" target="blank">TcpSentryScenarioTerminalLog.txt</a>
  * @see <a href="../../../src/TcpExamples/TcpExample4SequenceDiagram.png" target="blank">TcpExample4SequenceDiagram.png</a>
  * @see <a href="../../../src/TcpExamples/TcpExample4SequenceSketch.png" target="blank">TcpExample4SequenceSketch.png</a>
  * 
@@ -31,6 +33,18 @@ import java.net.*;
  */
 public class TcpSentryScenarioHandlerThread extends Thread
 {
+    /** Sentry Scenario access list
+     * See {@linktourl https://stackoverflow.com/questions/1005073/initialization-of-an-arraylist-in-one-line }
+     */
+    public static List<String> allowedNamesList = 
+           Arrays.asList("Tim", "Stephen", "Mark", "Rene", "Simon", "James", "Ethan", "Jin Hong");
+    
+    public static final String HALT_WHO_GOES_THERE = "Halt who goes there?";
+    public static final String YOU_MAY_PASS        = "You may pass, have a great NPS MOVES day!";
+    public static final String HOLD_IT_RIGHT_THERE = "You may not pass, leave immediately or else";
+    
+    private static final String prefix = "[" + TcpSentryScenarioHandlerThread.class.getName() + "] ";
+    
     /** The socket connection to a client */
     Socket socket;
     
@@ -50,8 +64,8 @@ public class TcpSentryScenarioHandlerThread extends Thread
      */
     public static void main(String[] args)
     {
-        System.out.println ("*** TcpExample4HandlerThread is not a standalone executable progam.");
-        System.out.println ("*** Please run TcpExample4DispatchServer instead... now exiting.");
+        System.out.println ("*** TcpSentryScenarioHandlerThread is not a standalone executable progam.");
+        System.out.println ("*** Please run TcpSentryScenarioDispatchServer instead... now exiting.");
     }
     
     /** Handles one connection. We add an artificial slowness
@@ -64,26 +78,50 @@ public class TcpSentryScenarioHandlerThread extends Thread
     {
         try
         {
-            System.out.println(TcpSentryScenarioHandlerThread.class.getName() + " starting to handle a thread...");
+            System.out.println(prefix + "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);
+            // input stream and output stream 
+            InputStream    inputStream       = socket.getInputStream();
+            Reader         inputStreamReader = new InputStreamReader(inputStream);
+            BufferedReader bufferedReader    = new BufferedReader(inputStreamReader);
 
-            final long TIMEOUT = 2000; // 2000 milliseconds = 2 seconds, 10000 milliseconds = 10 seconds
-            System.out.println(TcpSentryScenarioHandlerThread.class.getName() + " pausing for TIMEOUT=" + TIMEOUT + "ms" + 
-                               " to emulate computation and avoid server-side overload"); 
+            OutputStream outputStream = socket.getOutputStream();
+            PrintStream  printStream  = new PrintStream(outputStream);
+            
+            final long TIMEOUT = 100; // 2000 milliseconds = 2 seconds, 10000 milliseconds = 10 seconds
+//            System.out.println(prefix + " pausing for TIMEOUT=" + TIMEOUT + "ms" + 
+//                               " to emulate computation and avoid server-side overload"); 
             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 " + TcpSentryScenarioHandlerThread.class.getName()); // TODO insert socket count here!
-            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(TcpSentryScenarioHandlerThread.class.getName() + " finished handling a thread, now exit.");
+            printStream.println(prefix + "This message was written by the server "); // TODO insert socket count here!
+            printStream.flush();     // make sure that it indeed escapes current process and reaches the client
+            
+////////////////////////////////////////////////////////////////////////////////////////////
+// Assignment code
+            
+            printStream.println(HALT_WHO_GOES_THERE);
+            System.out.println ("socket send:   " + HALT_WHO_GOES_THERE);
+            
+            String clientResponse = bufferedReader.readLine();
+            System.out.println ("clientResponse: " + clientResponse);
+            
+            if (clientResponse.equalsIgnoreCase("quit") || clientResponse.equalsIgnoreCase("exit"))
+            {
+                printStream.flush();
+                socket.close();
+            }
+            System.out.println ("Hello, " + clientResponse);
+            
+////////////////////////////////////////////////////////////////////////////////////////////
+            
+////            socket.close(); // all clear, no longer need socket
+            System.out.println(prefix + "finished handling a thread, now exit.");
+            System.out.println("============================================================="); // execution complete
         }
         catch(IOException | InterruptedException e) // either a networking or a threading problem
         {
-            System.out.println("Problem with " + TcpSentryScenarioHandlerThread.class.getName() + " networking:"); // describe what is happening
+            System.out.println("Problem with " + prefix + " 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