Added awesome comments!

Author: Sandy W

client/Client.java

@@ -19,7 +19,7 @@ public class Client {
 	// multiple threads. Here it is used for benchmarking, to store the sum
 	// of the command completion times for all threads
 	private static AtomicLong totalTime = new AtomicLong(0);
-	
+
 	// this AtomicLong is used to keep track of the current # of running threads
 	private static AtomicLong runningThreads = new AtomicLong(0);
 
@@ -77,7 +77,8 @@ else while (menuSelection != 8) {
 					e.printStackTrace();
 				}
 			}
-
+			// while runningThreads is not 0, there are still clients waiting for the server
+			// to send a response, so keep looping (waiting) until they are finished
 			while (runningThreads.get() != 0) {}
 
 			System.out.println("Average response time: " + (totalTime.get() / numProcesses) + " ms\n");
@@ -86,22 +87,32 @@ else while (menuSelection != 8) {
 
 	}
 	//----------------------------------------------------------------------------
+	/**
+	* Function to prompt the user for a command to run
+	* @return command number 1-8
+	*/
 	public static int mainMenu() {
 		int menuSelection = 0;
+		// loop (and prompt again) until the user's input is an integer between 1 and 8
 		while ((menuSelection <= 0) || (menuSelection > 8)) {
 			System.out.println("The menu provides the following choices to the user: ");
 			System.out.println("1. Host current Date and Time \n2. Host uptime\n"
 					+ "3. Host memory use \n4. Host Netstat \n5. Host current users "
-					+ "\n6. Host running processes \n7. Benchmark\n8. Quit ");
+					+ "\n6. Host running processes \n7. Benchmark (measure mean response time)\n8. Quit ");
 			System.out.print("Please provide number corresponding to the action you want to be performed: ");
 			Scanner sc = new Scanner(System.in);
 			if (sc.hasNextInt()) menuSelection = sc.nextInt();
 		}
 		return menuSelection;
 	}
 
+	/**
+	* Function to prompt the user for a benchmark command to run
+	* @return command number 1-6
+	*/
 	public static int benchmarkMenu() {
 		int menuSelection = 0;
+		// loop (and prompt again) until the user's input is an integer between 1 and 6
 		while ((menuSelection <= 0) || (menuSelection > 6)) {
 			System.out.println("Which command would you like to benchmark? ");
 			System.out.println("1. Host current Date and Time \n2. Host uptime\n"
@@ -114,8 +125,13 @@ public static int benchmarkMenu() {
 		return menuSelection;
 	}   
 
+	/**
+	* Function to prompt the user for how many connections to make (for measuring the mean response time)
+	* @return number 1-100
+	*/
 	public static int numProcessesMenu() {
 		int menuSelection = 0;
+		// loop (and prompt again) until the user's input is an integer between 1 and 100
 		while ((menuSelection <= 0) || (menuSelection > 100)) {
 			System.out.print("How many connections to the server would you like to open? [1-100]: ");
 			Scanner sc = new Scanner(System.in);

client/ClientThread.java

@@ -8,13 +8,30 @@
 
 
 public class ClientThread extends Thread {
+	// every clientThread is passed which command to send to the server
 	int menuSelection;
+	// every clientThread is passed the hostname of the server to connect to
 	String hostName;
-	Socket socket = null;
+	Socket socket = null; 
+	
+	// totalTime is used to keep the sum of response times for all threads. after all threads
+	// have completed it is divided by the total number of threads to get an 
+	// average response time
 	AtomicLong totalTime;
+
+	// runningThreads is the total number of running threads. it is set to numThreads (the number
+	// of threads that are started) before any threads are started by the Client class. Every time
+	// a ClientThread finishes it will decrement runningThreads by one, so runningThreads == 0 when
+	// all threads have finished
 	AtomicLong runningThreads;
+
+	// each class is passed false for printOutput if the number of threads started is > 1. When running more
+	// than one client thread the clientThreads should not print output, in order to not clutter the screen
 	boolean printOutput;
 
+	// startTime and endTime are used to keep track of the current time when the thread conects to the 
+	// server and when the thread gets a response from the server. The difference between the two
+	// (endTime - startTime) is the response time
 	long startTime;
 	long endTime;
 
@@ -30,6 +47,7 @@ public void run() {
 		PrintWriter out = null;
 		BufferedReader in = null;
 		try {
+			// get the current time (before connecting to the server)
 			startTime = System.currentTimeMillis();
 
 			//creates a new Socket object and names it socket.
@@ -54,7 +72,9 @@ public void run() {
 				if (printOutput) System.out.println(outputString);
 			}
 
+			// get the current time (after connecting to the server)
 			endTime = System.currentTimeMillis();
+			// endTime - startTime = the time it took to get the response from the sever
 			totalTime.addAndGet(endTime - startTime);
 
 		}
@@ -65,6 +85,7 @@ public void run() {
 		catch (IOException e) {
 			e.printStackTrace();
 		}
+		// finally, close the socket and decrement runningThreads
 		finally {
 			if (printOutput) System.out.println("closing");
 			try {

server/CommandExecutor.java

@@ -8,78 +8,83 @@
  * then executing it and returning the results.
  */
 public class CommandExecutor {
-	
+
 	/**
 	 * Runs the shell command after first using parseCommand() to determine which
 	 * command to run.
 	 * 
 	 * @param commandString		A string containing a single digit, 1-6;
-	 * @return					A string containing the results of the shell command.
+	 * @return			A string containing the results of the shell command.
 	 */
 	static String run(String commandString) {
 		String result = "";
 		String line;
 		try {
-		    Process child = Runtime.getRuntime().exec(parseCommand(commandString));
+			// start the shell command running as a child processes
+			Process child = Runtime.getRuntime().exec(parseCommand(commandString));
+
+			// open a BufferedReader to read the output of the child process
+			BufferedReader output = new BufferedReader(new InputStreamReader(child.getInputStream()));
+			// while the child process is still outputting, add the output to the result string
+			while ((line = output.readLine()) != null) {
+				result = result.concat(line);
+				result = result.concat("\n");
+			}
 
-		    BufferedReader output = new BufferedReader(new InputStreamReader(child.getInputStream()));
-		    while ((line = output.readLine()) != null) {
-		    	result = result.concat(line);
 			result = result.concat("\n");
-		    }
-		    
-		result = result.concat("\n");
-		result = result.concat("END_MESSAGE");
-		    output.close();
-		    
+			// add "END_MESSAGE" to the result string. When the client sees END_MESSAGE it
+			// will know that the server is done sending
+			result = result.concat("END_MESSAGE");
+			output.close();
+
 		} catch (IOException e) {
 			e.printStackTrace();
 		}
-		
+
 		return result;
 	}
-	
+
 	/**
 	 * Converts the digit string into its respective shell command.
 	 * 
 	 * @param inputString		A string containing a single digit, 1-6;
-	 * @return					
+	 * @return			A string containing the shell command to run		
 	 */
 	static String parseCommand(String inputString) {
 		int inputInt = Integer.parseInt(inputString);
 		String commandString = "";
 		switch (inputInt) {
-		// Date
-		case 1:
-			commandString = "date";
-			break;
-			
-		// Uptime
-		case 2:
-			commandString = "uptime";
-			break;
-		
-		// Memory use
-		case 3:
-			commandString = "free";
-			break;
-			
-		// netstat
-		case 4:
-			commandString = "netstat";
-			break;
-			
-		// current users
-		case 5:
-			commandString = "who";
-			break;
-			
-		// running processes
-		case 6:
-			commandString = "ps -e";
-			break;
+			// Date
+			case 1:
+				commandString = "date";
+				break;
+
+				// Uptime
+			case 2:
+				commandString = "uptime";
+				break;
+
+				// Memory use
+			case 3:
+				commandString = "free";
+				break;
+
+				// netstat
+			case 4:
+				commandString = "netstat";
+				break;
+
+				// current users
+			case 5:
+				commandString = "who";
+				break;
+
+				// running processes
+			case 6:
+				commandString = "ps -e";
+				break;
 		}
-		
+
 		return commandString;
 	}
 }

server/Server.java

@@ -4,7 +4,11 @@
 import java.util.ArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
 
-
+/* 
+ * Main server class. This class includes main(), and is the class that listens
+ * for incoming connections and starts ServerThreads to handle those connections
+ *
+ */
 public class Server {
 
 	/**
@@ -16,11 +20,16 @@ public static void main(String[] args) {
 		ArrayList<Thread> list = new ArrayList<Thread>();
 
 		try {
+			// listen for incoming connections on port 4000
 			ServerSocket socket = new ServerSocket(4000);
 			System.out.println("Server listening on port 4000");
 
+			// loop (forever) until program is stopped
 			while(true) {
+				// accept a new connection
 				Socket client = socket.accept();
+				// start a new ServerThread to handle the connection and send
+				// output to the client
 				Thread thrd = new Thread(new ServerThread(client));
 				list.add(thrd);
 				thrd.start();
@@ -33,4 +42,4 @@ public static void main(String[] args) {
 			ioe.printStackTrace();
 		}
 	}
-}
+}

server/ServerThread.java

@@ -5,7 +5,11 @@
 import java.net.Socket;
 import java.util.concurrent.atomic.AtomicInteger;
 
-
+/*
+ * Individual ServerThread listens for the client to tell it what command to run, then
+ * runs that command and sends the output of that command to the client
+ *
+ */
 public class ServerThread extends Thread {
 	Socket client = null;
 
@@ -17,22 +21,27 @@ public void run() {
 		System.out.print("Accepted connection. ");
 
 		try {
+			// open a new PrintWriter and BufferedReader on the socket
 			PrintWriter out = new PrintWriter(client.getOutputStream(), true);
 			BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
 			System.out.print("Reader and writer created. ");
 
 			String inString;
+			// read the command from the client
 		        while  ((inString = in.readLine()) == null);
 			System.out.println("Read command " + inString);
 
+			// run the command using CommandExecutor and get its output
 			String outString = CommandExecutor.run(inString);
 			System.out.println("Server sending: " + outString);
+			// send the result of the command to the client
 			out.print(outString);
 		}
 		catch (IOException e) {
 			e.printStackTrace();
 		} 
 		finally {
+			// close the connection to the client
 			out.close();
 			in.close();
 			client.close();