diff --git a/examples/src/TcpExamples/TcpSentryScenarioDispatchServer.java b/examples/src/TcpExamples/TcpSentryScenarioDispatchServer.java
index 134c6487496d16bec08974dd86c9837bd6b9b014..fa03640ded17192979ca8d94318aa6cddaac029a 100644
--- a/examples/src/TcpExamples/TcpSentryScenarioDispatchServer.java
+++ b/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
}
diff --git a/examples/src/TcpExamples/TcpSentryScenarioHandlerThread.java b/examples/src/TcpExamples/TcpSentryScenarioHandlerThread.java
index 968f057bbe808ce2c95d977514e325dd122d713c..37fe6051db9fe176cd42f0c52466d7d6e0449096 100644
--- a/examples/src/TcpExamples/TcpSentryScenarioHandlerThread.java
+++ b/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