Commit HW 1 Sloan

assignments/nbproject/project.properties

@@ -70,8 +70,8 @@ javac.modulepath=
 javac.processormodulepath=
 javac.processorpath=\
     ${javac.classpath}
-javac.source=17
-javac.target=17
+javac.source=11
+javac.target=11
 javac.test.classpath=\
     ${javac.classpath}:\
     ${build.classes.dir}

assignments/src/MV3500Cohort2023MarchJune/homework1/Sloan/SloanExample1Telnet.java

+package MV3500Cohort2023MarchJune.homework1.Sloan;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * The simplest possible TCP network program. It listens for
+ * a connection, from telnet (telnet localhost 2317) or a program
+ * you write, which we will do later. Right now the TcpExample simply
+ * writes a string in response to a connection.
+ * 
+ * Modifying this program is the basis for Assignment 1.
+ * 
+ * Testing the running server program from telnet looks like this:
+ * 
+ * it154916:projects mcgredo$ telnet localhost 2317
+ * Trying ::1...
+ * Connected to localhost.
+ * Escape character is '^]'.
+ * This was written by the server
+ * Connection closed by foreign host.
+ * 
+ * Notice that "This was written by the server" matches 
+ * what is written by the code below, over the output stream.
+ * 
+ * After this first connection the program below drops out
+ * the bottom of the program, and does not repeat itself.
+ * The program exits.
+ * 
+ * @author mcgredo
+ * @author brutzman@nps.edu
+ */
+public class SloanExample1Telnet 
+{
+    /** Default constructor */
+    public SloanExample1Telnet()
+    {
+        // default constructor
+    }
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println(SloanExample1Telnet.class.getName() + " has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  enter (telnet localhost 2317)" );
+            System.out.println("Now we'll check if your telnet connections are correct" );
+			
+            // The ServerSocket waits for a connection from a client.
+            // It returns a Socket object when the connection occurs.
+            ServerSocket serverSocket = new ServerSocket(2317);
+            
+            // Use Java io classes to write text (as opposed to
+            // unknown bytes of some sort) to the client
+            
+            // The Socket object represents the connection between
+            // the server and client, including a full duplex connection
+            try (Socket clientConnection = serverSocket.accept()) // wait here for a client to connect
+            {
+                // OK we got something, time to respond!
+                // Use Java io classes to write text (as opposed to
+                // unknown bytes of some sort) to the client
+                OutputStream os = clientConnection.getOutputStream();
+                PrintStream  ps = new PrintStream(os);
+                
+                        ps.println("This client response was written by server " + SloanExample1Telnet.class.getName()); // to remote client
+                System.out.println("This server response was written by server " + SloanExample1Telnet.class.getName()); // to server console
+
+                // "flush()" in important in that it forces a write
+                // across what is in fact a slow connection
+                ps.flush();
+            }
+            System.out.println(SloanExample1Telnet.class.getName() + " completed successfully.");
+            System.out.println(SloanExample1Telnet.class.getName() + " has the correct telnet build on the machine.");
+        }
+        catch(IOException e)
+        {
+            System.err.println("Exception with " + SloanExample1Telnet.class.getName() + " networking:"); // describe what is happening
+            System.err.println(e);
+            // Provide more helpful information to user if exception occurs due to running twice at one time
+            
+            // brute force exception checking, can be brittle if exception message changes
+            // if (e.getMessage().equals("Address already in use: NET_Bind")) 
+            if (e instanceof java.net.BindException)
+                System.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2023MarchJune/homework1/Sloan/SloanExample2ConnectionCounting.java

+package MV3500Cohort2023MarchJune.homework1.Sloan;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * Very slightly more complex than example1. 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.
+ * 
+ * <code>telnet localhost 2317</code>
+ * 
+ * If you're sophisticated you can contact the instructor's computer
+ * while running this program.
+ * 
+ * <code>telnet ipOfServersLaptop 2317</code>
+ * 
+ * And have that machine display the socket pairs received.
+ * @author mcgredo
+ * @author brutzman@nps.edu
+ */
+public class SloanExample2ConnectionCounting 
+{
+    /** Default constructor */
+    public SloanExample2ConnectionCounting()
+    {
+        // default constructor
+    }
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {
+        try
+        {
+            System.out.println("SloanExample2ConnectionCounting has started and is waiting for a connection.");
+            System.out.println("  help: https://savage.nps.edu/Savage/developers.html#telnet");
+            System.out.println("  Windows enter (telnet localhost 2317) for loopback operation" );
+            System.out.println("SloanExample2ConnectionCounting server standing by..." );
+			
+            // ServerSocket waits for a connection from a client. 
+            // Notice that it is outside the loop; ServerSocket needs to be made only once.
+			
+            int connectionCount = 0; // state variable
+            
+            ServerSocket serverSocket = new ServerSocket(2317); // server decides here what port to listen on.
+			// of interest: often client doesn't care what port it uses locally when connecting to that server port.
+            
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while(true)
+            {
+                // serverSocket.accept() blocks! then proceeds once a connection is "accept"ed
+                try (Socket clientConnection = serverSocket.accept()) { //the accept method blocks until a client connects
+                    connectionCount++; // got another client connected one!
+                    
+                    OutputStream os = clientConnection.getOutputStream();
+                    PrintStream ps = new PrintStream(os);
+                    
+                    if (connectionCount == 1) // first time through, report connection
+                    {
+                        // Where are we?  In other words, what is our host number? Advertise it.
+                        // Note that we use the serverSocket to get address, since host may have multiple network connections.
+                        // https://stackoverflow.com/questions/9481865/getting-the-ip-address-of-the-current-machine-using-java
+                        String localHostAddress = clientConnection.getInetAddress().getHostAddress();
+                        System.out.println("Local host address is " + localHostAddress);
+                        if (localHostAddress.contains("/"))
+                            localHostAddress = localHostAddress.substring(localHostAddress.indexOf("/")+1);
+                        // show localhost IP number to facilitate connections over local area network (LAN, WAN)
+                        System.out.println("  enter (telnet localhost   2317) for local operation" );
+                        System.out.println("  enter (telnet " + localHostAddress + " 2317)..." );
+                    }
+                    
+                    ps.println("This client response was written by server " + SloanExample2ConnectionCounting.class.getName()); // to remote client
+                    System.out.println("This server response was written by server " + SloanExample2ConnectionCounting.class.getName()); // to server console
+                    
+                            ps.println("You were connection #" + connectionCount + ", by my count");
+                    
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair.)
+                    
+                    InetAddress  localAddress = clientConnection.getLocalAddress();
+                    InetAddress remoteAddress = clientConnection.getInetAddress();
+                    
+                    int  localPort = clientConnection.getLocalPort();
+                    int remotePort = clientConnection.getPort();       // remember the prior question, why are 2 ports different?
+                    
+                    // 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 )) note IPv6
+                    // Socket pair: (( /0:0:0:0:0:0:0:1, 2317 ), ( /0:0:0:0:0:0:0:1, 54881 ))
+                    //
+                    // Why is first IP/port the same, while the second set has different ports?
+                    
+                    System.out.println("Socket pair (server, client): (( " + localAddress.toString() + ", " + localPort + " ), ( " +
+                            remoteAddress.toString() + ", " + remotePort + " ))");
+                    
+                    System.out.println("got another connection, #" + connectionCount); // report progress
+                    
+                    // Notice the use of flush() and close(). Without
+                    // the close() to Socket object may stay open for
+                    // a while after the client has stopped needing this
+                    // connection. Close() explicitly ends the connection.
+                    ps.flush();
+                }
+            }
+       }
+        catch(IOException e)
+        {
+            System.err.println("Problem with  " + SloanExample2ConnectionCounting.class.getName() + " networking:"); // describe what is happening
+            System.err.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.err.println("*** Be sure to stop any other running instances of programs using this port!");
+        }
+    }
+}

assignments/src/MV3500Cohort2023MarchJune/homework1/Sloan/SloanExample3Client.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package MV3500Cohort2023MarchJune.homework1.Sloan;
+
+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.
+ *
+ * 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 brutzman@nps.edu
+ */
+public class SloanExample3Client {
+   /** Default constructor */
+    public SloanExample3Client()
+    {
+        // default constructor
+    }
+
+    /** IPv6 String constant for localhost address, similarly IPv4 127.0.0.1
+     * @see <a href="https://en.wikipedia.org/wiki/localhost">https://en.wikipedia.org/wiki/localhost</a>
+     * @see <a href="https://en.wikipedia.org/wiki/IPv6_address">https://en.wikipedia.org/wiki/IPv6_address</a> 
+     */
+    public final static String LOCALHOST = "0:0:0:0:0:0:0:1"; //Local host
+
+    /**
+     * Program invocation, execution starts here
+     * @param args command-line arguments
+     */
+    public static void main(String[] args)
+    {        
+        // Local variables/fields
+        Socket socket = null;
+        InputStream is;
+        Reader isr;
+        BufferedReader br;
+        String serverMessage;
+        int clientLoopCount = 0;
+        
+        try {
+            while (clientLoopCount <= 9)
+            {
+                clientLoopCount++; // increment at beginning of loop for reliability
+                System.out.println(SloanExample3Client.class.getName() + " creating socket...");
+
+                // 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? 
+
+                // Now hook everything up (i.e. set up the streams), Java style:
+                is  = socket.getInputStream();
+                isr = new InputStreamReader(is);
+                br  = new BufferedReader(isr);
+
+                // Read a single line written by the server. We'd
+                // do things a bit differently if there were many lines to be read
+                // from the server instead of one only.
+                serverMessage = br.readLine();
+                System.out.println("==================================================");
+                       
+                System.out.print  ("Client loop " + clientLoopCount + ": ");
+                System.out.println("now we're talking!");
+                System.out.println("The message the server sent was: '" + serverMessage + "'");
+                // socket gets closed, either automatically/silently by this code (or possibly by the server)
+                
+                Thread.sleep(500l); // slow things down, for example 500l (long) = 500 msec (1/2 second)
+                
+            } // end while(true) // infinite loops are dangerous, be sure to kill this process!
+        } 
+        catch (IOException | InterruptedException e )
+        {
+            System.err.println("Problem with " + SloanExample3Client.class.getName() + " networking:"); // describe what is happening
+            System.err.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.err.println("*** Be sure to stop any other running instances of programs using this port!");
+            }
+        }
+        finally // occurs after any other activity when shutting down
+        {
+            try {
+                if (socket != null)
+                    socket.close();
+            } catch (IOException e) {}
+            
+            // program exit: tell somebody about that happening.  Likely cause: server drops connection.
+            System.out.println();
+            System.out.println(SloanExample3Client.class.getName() + " exit");
+        }
+    }
+} 

assignments/src/MV3500Cohort2023MarchJune/homework1/Sloan/SloanExample3Server.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
+ */
+package MV3500Cohort2023MarchJune.homework1.Sloan;
+
+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
+ * @author brutzman@nps.edu
+ */
+public class SloanExample3Server {
+
+    /**
+     * Default constructor
+     */
+    public SloanExample3Server() {
+        // default constructor
+    }
+
+    /**
+     * Program invocation, execution starts here If already compiled, can run
+     * using console in directory ../../build/classes/ by invoking \ java
+     * -classpath . TcpExamples.TcpExample3Server
+     *
+     * @param args command-line arguments
+     */
+    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(SloanExample3Server.class.getName() + " has started..."); // it helps debugging to put this on console first
+
+            ServerSocket serverSocket = new ServerSocket(2317);
+            OutputStream os;
+            PrintStream ps;
+            InetAddress localAddress, remoteAddress;
+            int localPort, remotePort;
+            int serverLoopCount = 0;
+
+            // Server is up and waiting (i.e. "blocked" or paused)
+            // Loop, infinitely, waiting for client connections.
+            // Stop the program somewhere else.
+            while (serverLoopCount <=9) {
+
+                // block until connected to a client
+                try (Socket clientConnectionSocket = serverSocket.accept()) {
+                    serverLoopCount++; // increment at beginning of loop for reliability
+
+                    // Now hook everything up (i.e. set up the streams), Java style:
+                    os = clientConnectionSocket.getOutputStream();
+                    ps = new PrintStream(os);
+                    ps.println("This is response " + serverLoopCount + " produced by the server."); // this gets sent back to client!
+
+                    // Print some information locally about the Socket connection.
+                    // This includes the port and IP numbers on both sides (the socket pair).
+                    localAddress = clientConnectionSocket.getLocalAddress();
+                    remoteAddress = clientConnectionSocket.getInetAddress();
+                    localPort = clientConnectionSocket.getLocalPort();
+                    remotePort = clientConnectionSocket.getPort();
+
+                    System.out.print("Server loop " + serverLoopCount + ": ");
+
+                    // 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(SloanExample3Server.class.getName() + " socket pair showing host name, address, port:");
+                    System.out.println("  (( "
+                            + localAddress.getHostName() + "=" + localAddress.getHostAddress() + ", " + localPort + " ), ( "
+                            + remoteAddress.getHostName() + "=" + remoteAddress.getHostAddress() + ", " + remotePort + " ))");
+
+                    if (localAddress.getHostName().equals(localAddress.getHostAddress())
+                            || remoteAddress.getHostName().equals(remoteAddress.getHostAddress())) {
+                        System.out.println("  note HostName matches address if host has no DNS name");
+                    }
+                    // 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 " + SloanExample3Server.class.getName() + " 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!");
+            }
+        }
+    }
+}