From 29cfb05460c0beb39cffd579322b0e29a93b9e66 Mon Sep 17 00:00:00 2001
From: ielmie <65829854+ielmie@users.noreply.github.com>
Date: Fri, 29 May 2020 01:06:25 -0400
Subject: [PATCH 1/6] Changes made for question 5
---
code/simplechat1/ClientConsole.java | 17 +-
code/simplechat1/EchoServer.java | 35 ++
code/simplechat1/client/ChatClient.java | 22 +
.../ocsf/client/AbstractClient.java | 333 +++++++++++++
.../ocsf/client/AdaptableClient.java | 82 ++++
.../ocsf/client/ObservableClient.java | 181 +++++++
code/simplechat1/ocsf/index.html | 22 +
.../ocsf/server/AbstractServer.java | 459 ++++++++++++++++++
.../ocsf/server/AdaptableServer.java | 129 +++++
.../ocsf/server/ConnectionToClient.java | 270 +++++++++++
.../server/ObservableOriginatorServer.java | 165 +++++++
.../ocsf/server/ObservableServer.java | 309 ++++++++++++
.../ocsf/server/OriginatorMessage.java | 61 +++
13 files changed, 2083 insertions(+), 2 deletions(-)
create mode 100644 code/simplechat1/ocsf/client/AbstractClient.java
create mode 100644 code/simplechat1/ocsf/client/AdaptableClient.java
create mode 100644 code/simplechat1/ocsf/client/ObservableClient.java
create mode 100644 code/simplechat1/ocsf/index.html
create mode 100644 code/simplechat1/ocsf/server/AbstractServer.java
create mode 100644 code/simplechat1/ocsf/server/AdaptableServer.java
create mode 100644 code/simplechat1/ocsf/server/ConnectionToClient.java
create mode 100644 code/simplechat1/ocsf/server/ObservableOriginatorServer.java
create mode 100644 code/simplechat1/ocsf/server/ObservableServer.java
create mode 100644 code/simplechat1/ocsf/server/OriginatorMessage.java
diff --git a/code/simplechat1/ClientConsole.java b/code/simplechat1/ClientConsole.java
index c9bb4e9..2706d7f 100644
--- a/code/simplechat1/ClientConsole.java
+++ b/code/simplechat1/ClientConsole.java
@@ -111,11 +111,24 @@ public static void main(String[] args)
{
host = args[0];
}
- catch(ArrayIndexOutOfBoundsException e)
+ catch(ArrayIndexOutOfBoundsException e1)
{
host = "localhost";
}
- ClientConsole chat= new ClientConsole(host, DEFAULT_PORT);
+
+ //Q5b This try loop checks to see if there is a second argument
+ //If that's the case, it will assign it as the port number
+ try
+ {
+ port = Integer.valueOf(args[1]);
+ }
+ //If there's no 2nd argument, it will use the DEFAULT_PORT
+ catch(ArrayIndexOutOfBoundsException e2)
+ {
+ port = DEFAULT_PORT;
+ }
+ //will use the port variable defined above instead of DEFAULT_PORT
+ ClientConsole chat= new ClientConsole(host, port);
chat.accept(); //Wait for console data
}
}
diff --git a/code/simplechat1/EchoServer.java b/code/simplechat1/EchoServer.java
index d4f3a1a..b734e31 100644
--- a/code/simplechat1/EchoServer.java
+++ b/code/simplechat1/EchoServer.java
@@ -39,6 +39,41 @@ public EchoServer(int port)
//Instance methods ************************************************
+ /**
+ * Hook method called each time an exception is thrown in a
+ * ConnectionToClient thread.
+ * The method may be overridden by subclasses but should remains
+ * synchronized.
+ *
+ * @param client the client that raised the exception.
+ * @param Throwable the exception thrown.
+ */
+ synchronized protected void clientException(
+ ConnectionToClient client, Throwable exception) {
+ clientDisconnected(client);
+ }
+
+ /**
+ * Hook method called each time a new client connection is
+ * accepted. The default implementation does nothing.
+ * @param client the connection connected to the client.
+ */
+ protected void clientConnected(ConnectionToClient client) {
+ System.out.println("Client has logged on");
+ }
+
+ /**
+ * Hook method called each time a client disconnects.
+ * The default implementation does nothing. The method
+ * may be overridden by subclasses but should remains synchronized.
+ *
+ * @param client the connection with the client.
+ */
+ synchronized protected void clientDisconnected(ConnectionToClient client) {
+ System.out.println("Client has logged off");
+ }
+
+
/**
* This method handles any messages received from the client.
*
diff --git a/code/simplechat1/client/ChatClient.java b/code/simplechat1/client/ChatClient.java
index fe1401e..fa2ee50 100644
--- a/code/simplechat1/client/ChatClient.java
+++ b/code/simplechat1/client/ChatClient.java
@@ -59,6 +59,28 @@ public void handleMessageFromServer(Object msg)
clientUI.display(msg.toString());
}
+ /**
+ * Hook method called after the connection has been closed. The default
+ * implementation does nothing. The method may be overriden by subclasses to
+ * perform special processing such as cleaning up and terminating, or
+ * attempting to reconnect.
+ */
+ protected void connectionClosed() {
+ System.out.println("The connection to the server is closed");
+ }
+
+ /**
+ * Hook method called each time an exception is thrown by the client's
+ * thread that is waiting for messages from the server. The method may be
+ * overridden by subclasses.
+ *
+ * @param exception
+ * the exception raised.
+ */
+ protected void connectionException(Exception exception) {
+ quit();
+ }
+
/**
* This method handles all data coming from the UI
*
diff --git a/code/simplechat1/ocsf/client/AbstractClient.java b/code/simplechat1/ocsf/client/AbstractClient.java
new file mode 100644
index 0000000..e905636
--- /dev/null
+++ b/code/simplechat1/ocsf/client/AbstractClient.java
@@ -0,0 +1,333 @@
+// This file contains material supporting section 3.7 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.client;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * The AbstractClient contains all the methods necessary to set
+ * up the client side of a client-server architecture. When a client is thus
+ * connected to the server, the two programs can then exchange
+ * Object instances.
+ *
+ * Method handleMessageFromServer must be defined by a concrete
+ * subclass. Several other hook methods may also be overriden.
+ *
+ * Several public service methods are provided to application that use this
+ * framework.
+ *
+ * Project Name: OCSF (Object Client-Server Framework)
+ *
+ *
+ * @author Dr. Robert Laganière
+ * @author Dr. Timothy C. Lethbridge
+ * @author François Bél;langer
+ * @author Paul Holden
+ * @version February 2001 (2.12)
+ */
+public abstract class AbstractClient implements Runnable {
+
+ // INSTANCE VARIABLES ***********************************************
+
+ /**
+ * Sockets are used in the operating system as channels of communication
+ * between two processes.
+ *
+ * @see java.net.Socket
+ */
+ private Socket clientSocket;
+
+ /**
+ * The stream to handle data going to the server.
+ */
+ private ObjectOutputStream output;
+
+ /**
+ * The stream to handle data from the server.
+ */
+ private ObjectInputStream input;
+
+ /**
+ * The thread created to read data from the server.
+ */
+ private Thread clientReader;
+
+ /**
+ * Indicates if the thread is ready to stop. Needed so that the loop in the
+ * run method knows when to stop waiting for incoming messages.
+ */
+ private boolean readyToStop = false;
+
+ /**
+ * The server's host name.
+ */
+ private String host;
+
+ /**
+ * The port number.
+ */
+ private int port;
+
+ // CONSTRUCTORS *****************************************************
+
+ /**
+ * Constructs the client.
+ *
+ * @param host
+ * the server's host name.
+ * @param port
+ * the port number.
+ */
+ public AbstractClient(String host, int port) {
+ // Initialize variables
+ this.host = host;
+ this.port = port;
+ }
+
+ // INSTANCE METHODS *************************************************
+
+ /**
+ * Opens the connection with the server. If the connection is already
+ * opened, this call has no effect.
+ *
+ * @exception IOException
+ * if an I/O error occurs when opening.
+ */
+ final public void openConnection() throws IOException {
+ // Do not do anything if the connection is already open
+ if (isConnected())
+ return;
+
+ // Create the sockets and the data streams
+ try {
+ clientSocket = new Socket(host, port);
+ output = new ObjectOutputStream(clientSocket.getOutputStream());
+ input = new ObjectInputStream(clientSocket.getInputStream());
+ } catch (IOException ex)
+ // All three of the above must be closed when there is a failure
+ // to create any of them
+ {
+ try {
+ closeAll();
+ } catch (Exception exc) {
+ }
+
+ throw ex; // Rethrow the exception.
+ }
+
+ clientReader = new Thread(this); // Create the data reader thread
+ readyToStop = false;
+ clientReader.start(); // Start the thread
+ }
+
+ /**
+ * Sends an object to the server. This is the only way that methods should
+ * communicate with the server.
+ *
+ * @param msg
+ * The message to be sent.
+ * @exception IOException
+ * if an I/O error occurs when sending
+ */
+ final public void sendToServer(Object msg) throws IOException {
+ if (clientSocket == null || output == null)
+ throw new SocketException("socket does not exist");
+
+ output.writeObject(msg);
+ }
+
+ /**
+ * Reset the object output stream so we can use the same
+ * buffer repeatedly. This would not normally be used, but is necessary
+ * in some circumstances when Java refuses to send data that it thinks has been sent.
+ */
+ final public void forceResetAfterSend() throws IOException {
+ output.reset();
+ }
+
+ /**
+ * Closes the connection to the server.
+ *
+ * @exception IOException
+ * if an I/O error occurs when closing.
+ */
+ final public void closeConnection() throws IOException {
+ // Prevent the thread from looping any more
+ readyToStop = true;
+
+ try {
+ closeAll();
+ } finally {
+ // Call the hook method
+ connectionClosed();
+ }
+ }
+
+ // ACCESSING METHODS ------------------------------------------------
+
+ /**
+ * @return true if the client is connnected.
+ */
+ final public boolean isConnected() {
+ return clientReader != null && clientReader.isAlive();
+ }
+
+ /**
+ * @return the port number.
+ */
+ final public int getPort() {
+ return port;
+ }
+
+ /**
+ * Sets the server port number for the next connection. The change in port
+ * only takes effect at the time of the next call to openConnection().
+ *
+ * @param port
+ * the port number.
+ */
+ final public void setPort(int port) {
+ this.port = port;
+ }
+
+ /**
+ * @return the host name.
+ */
+ final public String getHost() {
+ return host;
+ }
+
+ /**
+ * Sets the server host for the next connection. The change in host only
+ * takes effect at the time of the next call to openConnection().
+ *
+ * @param host
+ * the host name.
+ */
+ final public void setHost(String host) {
+ this.host = host;
+ }
+
+ /**
+ * returns the client's description.
+ *
+ * @return the client's Inet address.
+ */
+ final public InetAddress getInetAddress() {
+ return clientSocket.getInetAddress();
+ }
+
+ // RUN METHOD -------------------------------------------------------
+
+ /**
+ * Waits for messages from the server. When each arrives, a call is made to
+ * handleMessageFromServer(). Not to be explicitly called.
+ */
+ final public void run() {
+ connectionEstablished();
+
+ // The message from the server
+ Object msg;
+
+ // Loop waiting for data
+
+ try {
+ while (!readyToStop) {
+ // Get data from Server and send it to the handler
+ // The thread waits indefinitely at the following
+ // statement until something is received from the server
+ msg = input.readObject();
+
+ // Concrete subclasses do what they want with the
+ // msg by implementing the following method
+ handleMessageFromServer(msg);
+ }
+ } catch (Exception exception) {
+ if (!readyToStop) {
+ try {
+ closeAll();
+ } catch (Exception ex) {
+ }
+
+ connectionException(exception);
+ }
+ } finally {
+ clientReader = null;
+ }
+ }
+
+ // METHODS DESIGNED TO BE OVERRIDDEN BY CONCRETE SUBCLASSES ---------
+
+ /**
+ * Hook method called after the connection has been closed. The default
+ * implementation does nothing. The method may be overriden by subclasses to
+ * perform special processing such as cleaning up and terminating, or
+ * attempting to reconnect.
+ */
+ protected void connectionClosed() {
+ }
+
+ /**
+ * Hook method called each time an exception is thrown by the client's
+ * thread that is waiting for messages from the server. The method may be
+ * overridden by subclasses.
+ *
+ * @param exception
+ * the exception raised.
+ */
+ protected void connectionException(Exception exception) {
+ }
+
+ /**
+ * Hook method called after a connection has been established. The default
+ * implementation does nothing. It may be overridden by subclasses to do
+ * anything they wish.
+ */
+ protected void connectionEstablished() {
+ }
+
+ /**
+ * Handles a message sent from the server to this client. This MUST be
+ * implemented by subclasses, who should respond to messages.
+ *
+ * @param msg
+ * the message sent.
+ */
+ protected abstract void handleMessageFromServer(Object msg);
+
+ // METHODS TO BE USED FROM WITHIN THE FRAMEWORK ONLY ----------------
+
+ /**
+ * Closes all aspects of the connection to the server.
+ *
+ * @exception IOException
+ * if an I/O error occurs when closing.
+ */
+ private void closeAll() throws IOException {
+ try {
+ // Close the socket
+ if (clientSocket != null)
+ clientSocket.close();
+
+ // Close the output stream
+ if (output != null)
+ output.close();
+
+ // Close the input stream
+ if (input != null)
+ input.close();
+ } finally {
+ // Set the streams and the sockets to NULL no matter what
+ // Doing so allows, but does not require, any finalizers
+ // of these objects to reclaim system resources if and
+ // when they are garbage collected.
+ output = null;
+ input = null;
+ clientSocket = null;
+ }
+ }
+}
+// end of AbstractClient class
\ No newline at end of file
diff --git a/code/simplechat1/ocsf/client/AdaptableClient.java b/code/simplechat1/ocsf/client/AdaptableClient.java
new file mode 100644
index 0000000..143592e
--- /dev/null
+++ b/code/simplechat1/ocsf/client/AdaptableClient.java
@@ -0,0 +1,82 @@
+// This file contains material supporting section 6.13 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.client;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+/**
+* The AdaptableClient is a class
+* that extends the AbstractClient in place of
+* the ObservableClient .
+*
+* Project Name: OCSF (Object Client-Server Framework)
+*
+* @author Dr. Robert Laganière
+* @version Febuary 2001
+*/
+class AdaptableClient extends AbstractClient
+{
+ //Instance variables **********************************************
+
+ /**
+ * The proxy used to simulate multiple class inheritance.
+ */
+ private ObservableClient client;
+
+// CONSTRUCTORS *****************************************************
+
+ /**
+ * Constructs the client adapter.
+ *
+ * @param host the server's host name.
+ * @param port the port number.
+ */
+ public AdaptableClient(String host, int port, ObservableClient client)
+ {
+ super(host, port);
+ this.client = client;
+ }
+
+// OVERRIDDEN METHODS *************************************************
+
+ /**
+ * Hook method called after the connection has been closed.
+ */
+ final protected void connectionClosed()
+ {
+ client.connectionClosed();
+ }
+
+ /**
+ * Hook method called after an exception
+ * is raised by the client listening thread.
+ *
+ * @param exception the exception raised.
+ */
+ final protected void connectionException(Exception exception)
+ {
+ client.connectionException(exception);
+ }
+
+ /**
+ * Hook method called after a connection has been established.
+ */
+ final protected void connectionEstablished()
+ {
+ client.connectionEstablished();
+ }
+
+ /**
+ * Handles a message sent from the server to this client.
+ *
+ * @param msg the message sent.
+ */
+ final protected void handleMessageFromServer(Object msg)
+ {
+ client.handleMessageFromServer(msg);
+ }
+}
diff --git a/code/simplechat1/ocsf/client/ObservableClient.java b/code/simplechat1/ocsf/client/ObservableClient.java
new file mode 100644
index 0000000..a816488
--- /dev/null
+++ b/code/simplechat1/ocsf/client/ObservableClient.java
@@ -0,0 +1,181 @@
+// This file contains material supporting section 6.13 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.client;
+
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+/**
+ * This class acts as a subclass of AbstractClient
+ * and is also an Observable class.
+ * Each time a new message is received, observers are notified.
+ *
+ * @author Dr Robert Laganière
+ * @author Dr Timothy C. Lethbridge
+ * @author François Bélange
+ * @version Febuary 2001
+ */
+public class ObservableClient extends Observable
+{
+ // Class variables ***************************************************
+
+ /**
+ * Indicates occurence of a connection exception.
+ */
+ public static final String CONNECTION_EXCEPTION = "#OC:Connection error.";
+
+ /**
+ * Indicates a close of the connection to server.
+ */
+ public static final String CONNECTION_CLOSED = "#OC:Connection closed.";
+
+ /**
+ * Indicates establishment of a connection to server.
+ */
+ public static final String CONNECTION_ESTABLISHED = "#OC:Connection established.";
+
+ //Instance variables **********************************************
+
+ /**
+ * The service instance used to simulate multiple class inheritance.
+ */
+ private AdaptableClient service;
+
+ //Constructor *****************************************************
+
+ public ObservableClient(String host, int port)
+ {
+ service = new AdaptableClient(host, port, this);
+ }
+
+ //Instance methods ************************************************
+
+ /**
+ * Opens the connections with the server.
+ */
+ final public void openConnection() throws IOException
+ {
+ service.openConnection();
+ }
+
+ /**
+ * Closes the connection to the server.
+ */
+ final public void closeConnection() throws IOException
+ {
+ service.closeConnection();
+ }
+
+ /**
+ * Sends an object to the server. This is the only way that
+ * methods should communicate with the server.
+ *
+ * @param msg The message to be sent.
+ */
+ final public void sendToServer(Object msg) throws IOException
+ {
+ service.sendToServer(msg);
+ }
+
+// ACCESSING METHODS ------------------------------------------------
+
+ /**
+ * @used to find out if the client is connnected.
+ */
+ final public boolean isConnected()
+ {
+ return service.isConnected();
+ }
+
+ /**
+ * @return the port number.
+ */
+ final public int getPort()
+ {
+ return service.getPort();
+ }
+
+ /**
+ * Sets the server port number for the next connection.
+ * Only has effect if the client is not currently connected.
+ *
+ * @param port the port number.
+ */
+ final public void setPort(int port)
+ {
+ service.setPort(port);
+ }
+
+ /**
+ * @return the host name.
+ */
+ final public String getHost()
+ {
+ return service.getHost();
+ }
+
+ /**
+ * Sets the server host for the next connection.
+ * Only has effect if the client is not currently connected.
+ *
+ * @param host the host name.
+ */
+ final public void setHost(String host)
+ {
+ service.setHost(host);
+ }
+
+ /**
+ * @return the client's Inet address.
+ */
+ final public InetAddress getInetAddress()
+ {
+ return service.getInetAddress();
+ }
+
+
+ /**
+ * This method is used to handle messages from the server. This method
+ * can be overriden but should always call notifyObservers().
+ *
+ * @param message The message received from the client.
+ */
+ protected void handleMessageFromServer(Object message)
+ {
+ setChanged();
+ notifyObservers(message);
+ }
+
+ /**
+ * Hook method called after the connection has been closed.
+ */
+ protected void connectionClosed()
+ {
+ setChanged();
+ notifyObservers(CONNECTION_CLOSED);
+ }
+
+ /**
+ * Hook method called each time an exception
+ * is raised by the client listening thread.
+ *
+ * @param exception the exception raised.
+ */
+ protected void connectionException(Exception exception)
+ {
+ setChanged();
+ notifyObservers(CONNECTION_EXCEPTION);
+ }
+
+ /**
+ * Hook method called after a connection has been established.
+ */
+ protected void connectionEstablished()
+ {
+ setChanged();
+ notifyObservers(CONNECTION_ESTABLISHED);
+ }
+}
diff --git a/code/simplechat1/ocsf/index.html b/code/simplechat1/ocsf/index.html
new file mode 100644
index 0000000..13025a0
--- /dev/null
+++ b/code/simplechat1/ocsf/index.html
@@ -0,0 +1,22 @@
+
+
+Installing and Running OCSF
+
+
+
+To install OCSF, simply compile all the .java files in the client and
+server directories.
+
+OCSF is a Framework, so this directory contains no main program. To
+learn how it works, consult the book
+"Object-Oriented Software Engineering: Practical Software Development
+using UML and Java" by Lethbridge and Laganière.
+
+To use OCSF, import the "ocsf.client" or "ocsf.server" package in your
+application code. Make sure that the ocsf directory is in your classpath
+when you compile your application.
+
+Back to the source code page.
+
+
+
diff --git a/code/simplechat1/ocsf/server/AbstractServer.java b/code/simplechat1/ocsf/server/AbstractServer.java
new file mode 100644
index 0000000..0134b22
--- /dev/null
+++ b/code/simplechat1/ocsf/server/AbstractServer.java
@@ -0,0 +1,459 @@
+// This file contains material supporting section 3.8 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.server;
+
+import java.net.*;
+import java.util.*;
+import java.io.*;
+
+/**
+* The AbstractServer class maintains a thread that waits
+* for connection attempts from clients. When a connection attempt occurs
+* it creates a new ConnectionToClient instance which
+* runs as a thread. When a client is thus connected to the
+* server, the two programs can then exchange Object
+* instances.
+*
+* Method handleMessageFromClient must be defined by
+* a concrete subclass. Several other hook methods may also be
+* overriden.
+*
+* Several public service methods are provided to applications that use
+* this framework, and several hook methods are also available
+*
+* Project Name: OCSF (Object Client-Server Framework)
+*
+* @author Dr Robert Laganière
+* @author Dr Timothy C. Lethbridge
+* @author François Bélanger
+* @author Paul Holden
+* @version February 2001 (2.12)
+* @see ocsf.server.ConnectionToClient
+*/
+public abstract class AbstractServer implements Runnable
+{
+ // INSTANCE VARIABLES *********************************************
+
+ /**
+ * The server socket: listens for clients who want to connect.
+ */
+ private ServerSocket serverSocket = null;
+
+ /**
+ * The connection listener thread.
+ */
+ private Thread connectionListener;
+
+ /**
+ * The port number
+ */
+ private int port;
+
+ /**
+ * The server timeout while for accepting connections.
+ * After timing out, the server will check to see if a command to
+ * stop the server has been issued; it not it will resume accepting
+ * connections.
+ * Set to half a second by default.
+ */
+ private int timeout = 500;
+
+ /**
+ * The maximum queue length; i.e. the maximum number of clients that
+ * can be waiting to connect.
+ * Set to 10 by default.
+ */
+ private int backlog = 10;
+
+ /**
+ * The thread group associated with client threads. Each member of the
+ * thread group is a ConnectionToClient .
+ */
+ private ThreadGroup clientThreadGroup;
+
+ /**
+ * Indicates if the listening thread is ready to stop. Set to
+ * false by default.
+ */
+ private boolean readyToStop = false;
+
+
+// CONSTRUCTOR ******************************************************
+
+ /**
+ * Constructs a new server.
+ *
+ * @param port the port number on which to listen.
+ */
+ public AbstractServer(int port)
+ {
+ this.port = port;
+
+ this.clientThreadGroup =
+ new ThreadGroup("ConnectionToClient threads")
+ {
+ // All uncaught exceptions in connection threads will
+ // be sent to the clientException callback method.
+ public void uncaughtException(
+ Thread thread, Throwable exception)
+ {
+ clientException((ConnectionToClient)thread, exception);
+ }
+ };
+ }
+
+
+// INSTANCE METHODS *************************************************
+
+ /**
+ * Begins the thread that waits for new clients.
+ * If the server is already in listening mode, this
+ * call has no effect.
+ *
+ * @exception IOException if an I/O error occurs
+ * when creating the server socket.
+ */
+ final public void listen() throws IOException
+ {
+ if (!isListening())
+ {
+ if (serverSocket == null)
+ {
+ serverSocket = new ServerSocket(getPort(), backlog);
+ }
+
+ serverSocket.setSoTimeout(timeout);
+ readyToStop = false;
+ connectionListener = new Thread(this);
+ connectionListener.start();
+ }
+ }
+
+ /**
+ * Causes the server to stop accepting new connections.
+ */
+ final public void stopListening()
+ {
+ readyToStop = true;
+ }
+
+ /**
+ * Closes the server socket and the connections with all clients.
+ * Any exception thrown while closing a client is ignored.
+ * If one wishes to catch these exceptions, then clients
+ * should be individually closed before calling this method.
+ * The method also stops listening if this thread is running.
+ * If the server is already closed, this
+ * call has no effect.
+ *
+ * @exception IOException if an I/O error occurs while
+ * closing the server socket.
+ */
+ final synchronized public void close() throws IOException
+ {
+ if (serverSocket == null)
+ return;
+ stopListening();
+ try
+ {
+ serverSocket.close();
+ }
+ finally
+ {
+ // Close the client sockets of the already connected clients
+ Thread[] clientThreadList = getClientConnections();
+ for (int i=0; iThread containing
+ * ConnectionToClient instances.
+ */
+ synchronized final public Thread[] getClientConnections()
+ {
+ Thread[] clientThreadList = new
+ Thread[clientThreadGroup.activeCount()];
+
+ clientThreadGroup.enumerate(clientThreadList);
+
+ return clientThreadList;
+ }
+
+ /**
+ * Counts the number of clients currently connected.
+ *
+ * @return the number of clients currently connected.
+ */
+ final public int getNumberOfClients()
+ {
+ return clientThreadGroup.activeCount();
+ }
+
+ /**
+ * Returns the port number.
+ *
+ * @return the port number.
+ */
+ final public int getPort()
+ {
+ return port;
+ }
+
+ /**
+ * Sets the port number for the next connection.
+ * The server must be closed and restarted for the port
+ * change to be in effect.
+ *
+ * @param port the port number.
+ */
+ final public void setPort(int port)
+ {
+ this.port = port;
+ }
+
+ /**
+ * Sets the timeout time when accepting connections.
+ * The default is half a second. This means that stopping the
+ * server may take up to timeout duration to actually stop.
+ * The server must be stopped and restarted for the timeout
+ * change to be effective.
+ *
+ * @param timeout the timeout time in ms.
+ */
+ final public void setTimeout(int timeout)
+ {
+ this.timeout = timeout;
+ }
+
+ /**
+ * Sets the maximum number of waiting connections accepted by the
+ * operating system. The default is 20.
+ * The server must be closed and restarted for the backlog
+ * change to be in effect.
+ *
+ * @param backlog the maximum number of connections.
+ */
+ final public void setBacklog(int backlog)
+ {
+ this.backlog = backlog;
+ }
+
+// RUN METHOD -------------------------------------------------------
+
+ /**
+ * Runs the listening thread that allows clients to connect.
+ * Not to be called.
+ */
+ final public void run()
+ {
+ // call the hook method to notify that the server is starting
+ serverStarted();
+
+ try
+ {
+ // Repeatedly waits for a new client connection, accepts it, and
+ // starts a new thread to handle data exchange.
+ while(!readyToStop)
+ {
+ try
+ {
+ // Wait here for new connection attempts, or a timeout
+ Socket clientSocket = serverSocket.accept();
+
+ // When a client is accepted, create a thread to handle
+ // the data exchange, then add it to thread group
+
+ synchronized(this)
+ {
+ ConnectionToClient c = new ConnectionToClient(
+ this.clientThreadGroup, clientSocket, this);
+ }
+ }
+ catch (InterruptedIOException exception)
+ {
+ // This will be thrown when a timeout occurs.
+ // The server will continue to listen if not ready to stop.
+ }
+ }
+
+ // call the hook method to notify that the server has stopped
+ serverStopped();
+ }
+ catch (IOException exception)
+ {
+ if (!readyToStop)
+ {
+ // Closing the socket must have thrown a SocketException
+ listeningException(exception);
+ }
+ else
+ {
+ serverStopped();
+ }
+ }
+ finally
+ {
+ readyToStop = true;
+ connectionListener = null;
+ }
+ }
+
+
+// METHODS DESIGNED TO BE OVERRIDDEN BY CONCRETE SUBCLASSES ---------
+
+ /**
+ * Hook method called each time a new client connection is
+ * accepted. The default implementation does nothing.
+ * @param client the connection connected to the client.
+ */
+ protected void clientConnected(ConnectionToClient client) {}
+
+ /**
+ * Hook method called each time a client disconnects.
+ * The default implementation does nothing. The method
+ * may be overridden by subclasses but should remains synchronized.
+ *
+ * @param client the connection with the client.
+ */
+ synchronized protected void clientDisconnected(
+ ConnectionToClient client) {}
+
+ /**
+ * Hook method called each time an exception is thrown in a
+ * ConnectionToClient thread.
+ * The method may be overridden by subclasses but should remains
+ * synchronized.
+ *
+ * @param client the client that raised the exception.
+ * @param Throwable the exception thrown.
+ */
+ synchronized protected void clientException(
+ ConnectionToClient client, Throwable exception) {}
+
+ /**
+ * Hook method called when the server stops accepting
+ * connections because an exception has been raised.
+ * The default implementation does nothing.
+ * This method may be overriden by subclasses.
+ *
+ * @param exception the exception raised.
+ */
+ protected void listeningException(Throwable exception) {}
+
+ /**
+ * Hook method called when the server starts listening for
+ * connections. The default implementation does nothing.
+ * The method may be overridden by subclasses.
+ */
+ protected void serverStarted() {}
+
+ /**
+ * Hook method called when the server stops accepting
+ * connections. The default implementation
+ * does nothing. This method may be overriden by subclasses.
+ */
+ protected void serverStopped() {}
+
+ /**
+ * Hook method called when the server is clased.
+ * The default implementation does nothing. This method may be
+ * overriden by subclasses. When the server is closed while still
+ * listening, serverStopped() will also be called.
+ */
+ protected void serverClosed() {}
+
+ /**
+ * Handles a command sent from one client to the server.
+ * This MUST be implemented by subclasses, who should respond to
+ * messages.
+ * This method is called by a synchronized method so it is also
+ * implcitly synchronized.
+ *
+ * @param msg the message sent.
+ * @param client the connection connected to the client that
+ * sent the message.
+ */
+ protected abstract void handleMessageFromClient(
+ Object msg, ConnectionToClient client);
+
+
+// METHODS TO BE USED FROM WITHIN THE FRAMEWORK ONLY ----------------
+
+ /**
+ * Receives a command sent from the client to the server.
+ * Called by the run method of ConnectionToClient
+ * instances that are watching for messages coming from the server
+ * This method is synchronized to ensure that whatever effects it has
+ * do not conflict with work being done by other threads. The method
+ * simply calls the handleMessageFromClient slot method.
+ *
+ * @param msg the message sent.
+ * @param client the connection connected to the client that
+ * sent the message.
+ */
+ final synchronized void receiveMessageFromClient(
+ Object msg, ConnectionToClient client)
+ {
+ this.handleMessageFromClient(msg, client);
+ }
+}
+// End of AbstractServer Class
diff --git a/code/simplechat1/ocsf/server/AdaptableServer.java b/code/simplechat1/ocsf/server/AdaptableServer.java
new file mode 100644
index 0000000..24462d4
--- /dev/null
+++ b/code/simplechat1/ocsf/server/AdaptableServer.java
@@ -0,0 +1,129 @@
+// This file contains material supporting section 6.13 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.server;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+
+/**
+* The AdaptableServer is an adapter class
+* that extends the AbstractServer class in place of
+* the AbstractObservableServer .
+*
+* Project Name: OCSF (Object Client-Server Framework)
+*
+* @author Dr. Robert Laganière
+* @version Febuary 2001
+*/
+class AdaptableServer extends AbstractServer
+{
+ //Instance variables **********************************************
+
+ /**
+ * The adapter used to simulate multiple class inheritance.
+ */
+ private ObservableServer server;
+
+// CONSTRUCTORS *****************************************************
+
+ /**
+ * Constructs the server adapter.
+ *
+ * @param host the server's host name.
+ * @param port the port number.
+ */
+ public AdaptableServer(int port, ObservableServer server)
+ {
+ super(port);
+ this.server = server;
+ }
+
+// OVERRIDDEN METHODS ---------
+
+ /**
+ * Hook method called each time a new client connection is
+ * accepted.
+ *
+ * @param client the connection connected to the client.
+ */
+ final protected void clientConnected(ConnectionToClient client)
+ {
+ server.clientConnected(client);
+ }
+
+ /**
+ * Hook method called each time a client disconnects.
+ *
+ * @param client the connection with the client.
+ */
+ final protected void clientDisconnected(ConnectionToClient client)
+ {
+ server.clientDisconnected(client);
+ }
+
+ /**
+ * Hook method called each time an exception
+ * is raised in a client thread.
+ *
+ * @param client the client that raised the exception.
+ * @param exception the exception raised.
+ */
+ final protected void clientException(ConnectionToClient client,
+ Throwable exception)
+ {
+ server.clientException(client, exception);
+ }
+
+ /**
+ * Hook method called when the server stops accepting
+ * connections because an exception has been raised.
+ *
+ * @param exception the exception raised.
+ */
+ final protected void listeningException(Throwable exception)
+ {
+ server.listeningException(exception);
+ }
+
+ /**
+ * Hook method called when the server stops accepting
+ * connections.
+ */
+ final protected void serverStopped()
+ {
+ server.serverStopped();
+ }
+
+ /**
+ * Hook method called when the server starts listening for
+ * connections.
+ */
+ final protected void serverStarted()
+ {
+ server.serverStarted();
+ }
+
+ /**
+ * Hook method called when the server is closed.
+ */
+ final protected void serverClosed()
+ {
+ server.serverClosed();
+ }
+
+ /**
+ * Handles a command sent from the client to the server.
+ *
+ * @param msg the message sent.
+ * @param client the connection connected to the client that
+ * sent the message.
+ */
+ final protected void handleMessageFromClient(Object msg,
+ ConnectionToClient client)
+ {
+ server.handleMessageFromClient(msg, client);
+ }
+}
diff --git a/code/simplechat1/ocsf/server/ConnectionToClient.java b/code/simplechat1/ocsf/server/ConnectionToClient.java
new file mode 100644
index 0000000..4394b37
--- /dev/null
+++ b/code/simplechat1/ocsf/server/ConnectionToClient.java
@@ -0,0 +1,270 @@
+// This file contains material supporting section 3.8 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.server;
+
+import java.io.*;
+import java.net.*;
+import java.util.HashMap;
+
+/**
+ * An instance of this class is created by the server when a client connects. It
+ * accepts messages coming from the client and is responsible for sending data
+ * to the client since the socket is private to this class. The AbstractServer
+ * contains a set of instances of this class and is responsible for adding and
+ * deleting them.
+ *
+ * Project Name: OCSF (Object Client-Server Framework)
+ *
+ *
+ * @author Dr Robert Laganière
+ * @author Dr Timothy C. Lethbridge
+ * @author François Bélanger
+ * @author Paul Holden
+ * @version February 2001 (2.12)
+ */
+public class ConnectionToClient extends Thread {
+ // INSTANCE VARIABLES ***********************************************
+
+ /**
+ * A reference to the Server that created this instance.
+ */
+ private AbstractServer server;
+
+ /**
+ * Sockets are used in the operating system as channels of communication
+ * between two processes.
+ *
+ * @see java.net.Socket
+ */
+ private Socket clientSocket;
+
+ /**
+ * Stream used to read from the client.
+ */
+ private ObjectInputStream input;
+
+ /**
+ * Stream used to write to the client.
+ */
+ private ObjectOutputStream output;
+
+ /**
+ * Indicates if the thread is ready to stop. Set to true when closing of the
+ * connection is initiated.
+ */
+ private boolean readyToStop;
+
+ /**
+ * Map to save information about the client such as its login ID. The
+ * initial size of the map is small since it is not expected that concrete
+ * servers will want to store many different types of information about each
+ * client. Used by the setInfo and getInfo methods.
+ */
+ private HashMap savedInfo = new HashMap(10);
+
+ // CONSTRUCTORS *****************************************************
+
+ /**
+ * Constructs a new connection to a client.
+ *
+ * @param group
+ * the thread groupSystem.out.println("Client at "+ client +
+ * "connected"); that contains the connections.
+ * @param clientSocket
+ * contains the client's socket.
+ * @param server
+ * a reference to the server that created this instance
+ * @exception IOException
+ * if an I/O error occur when creating the connection.
+ */
+ ConnectionToClient(ThreadGroup group, Socket clientSocket, AbstractServer server) throws IOException {
+ super(group, (Runnable) null);
+ // Initialize variables
+ this.clientSocket = clientSocket;
+ this.server = server;
+
+ clientSocket.setSoTimeout(0); // make sure timeout is infinite
+
+ // Initialize the objects streams
+ try {
+ input = new ObjectInputStream(clientSocket.getInputStream());
+ output = new ObjectOutputStream(clientSocket.getOutputStream());
+ } catch (IOException ex) {
+ try {
+ closeAll();
+ } catch (Exception exc) {
+ }
+
+ throw ex; // Rethrow the exception.
+ }
+
+ readyToStop = false;
+ start(); // Start the thread waits for data from the socket
+ }
+
+ // INSTANCE METHODS *************************************************
+
+ /**
+ * Sends an object to the client.
+ *
+ * @param msg
+ * the message to be sent.
+ * @exception IOException
+ * if an I/O error occur when sending the message.
+ */
+ final public void sendToClient(Object msg) throws IOException {
+ if (clientSocket == null || output == null)
+ throw new SocketException("socket does not exist");
+
+ output.writeObject(msg);
+ }
+
+ /**
+ * Reset the output stream so we can use the same
+ * buffer repeatedly. This would not normally be used, but is necessary
+ * in some circumstances when Java refuses to send data that it thinks has been sent.
+ */
+ final public void forceResetAfterSend() throws IOException {
+ output.reset();
+ }
+
+ /**
+ * Closes the client. If the connection is already closed, this call has no
+ * effect.
+ *
+ * @exception IOException
+ * if an error occurs when closing the socket.
+ */
+ final public void close() throws IOException {
+ readyToStop = true; // Set the flag that tells the thread to stop
+
+ try {
+ closeAll();
+ } finally {
+ server.clientDisconnected(this);
+ }
+ }
+
+ // ACCESSING METHODS ------------------------------------------------
+
+ /**
+ * Returns the address of the client.
+ *
+ * @return the client's Internet address.
+ */
+ final public InetAddress getInetAddress() {
+ return clientSocket == null ? null : clientSocket.getInetAddress();
+ }
+
+ /**
+ * Returns a string representation of the client.
+ *
+ * @return the client's description.
+ */
+ public String toString() {
+ return clientSocket == null ? null : clientSocket.getInetAddress().getHostName() + " ("
+ + clientSocket.getInetAddress().getHostAddress() + ")";
+ }
+
+ /**
+ * Saves arbitrary information about this client. Designed to be used by
+ * concrete subclasses of AbstractServer. Based on a hash map.
+ *
+ * @param infoType
+ * identifies the type of information
+ * @param info
+ * the information itself.
+ */
+ public void setInfo(String infoType, Object info) {
+ savedInfo.put(infoType, info);
+ }
+
+ /**
+ * Returns information about the client saved using setInfo. Based on a hash
+ * map.
+ *
+ * @param infoType
+ * identifies the type of information
+ */
+ public Object getInfo(String infoType) {
+ return savedInfo.get(infoType);
+ }
+
+ // RUN METHOD -------------------------------------------------------
+
+ /**
+ * Constantly reads the client's input stream. Sends all objects that are
+ * read to the server. Not to be called.
+ */
+ final public void run() {
+ server.clientConnected(this);
+
+ // This loop reads the input stream and responds to messages
+ // from clients
+ try {
+ // The message from the client
+ Object msg;
+
+ while (!readyToStop) {
+ // This block waits until it reads a message from the client
+ // and then sends it for handling by the server
+ msg = input.readObject();
+ server.receiveMessageFromClient(msg, this);
+ }
+ } catch (Exception exception) {
+ if (!readyToStop) {
+ try {
+ closeAll();
+ } catch (Exception ex) {
+ }
+
+ server.clientException(this, exception);
+ }
+ }
+ }
+
+ // METHODS TO BE USED FROM WITHIN THE FRAMEWORK ONLY ----------------
+
+ /**
+ * Closes all connection to the server.
+ *
+ * @exception IOException
+ * if an I/O error occur when closing the connection.
+ */
+ private void closeAll() throws IOException {
+ try {
+ // Close the socket
+ if (clientSocket != null)
+ clientSocket.close();
+
+ // Close the output stream
+ if (output != null)
+ output.close();
+
+ // Close the input stream
+ if (input != null)
+ input.close();
+ } finally {
+ // Set the streams and the sockets to NULL no matter what
+ // Doing so allows, but does not require, any finalizers
+ // of these objects to reclaim system resources if and
+ // when they are garbage collected.
+ output = null;
+ input = null;
+ clientSocket = null;
+ }
+ }
+
+ /**
+ * This method is called by garbage collection.
+ */
+ protected void finalize() {
+ try {
+ closeAll();
+ } catch (IOException e) {
+ }
+ }
+}
+// End of ConnectionToClient class
\ No newline at end of file
diff --git a/code/simplechat1/ocsf/server/ObservableOriginatorServer.java b/code/simplechat1/ocsf/server/ObservableOriginatorServer.java
new file mode 100644
index 0000000..4333694
--- /dev/null
+++ b/code/simplechat1/ocsf/server/ObservableOriginatorServer.java
@@ -0,0 +1,165 @@
+// This file contains material supporting the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.server;
+
+/**
+* The ObservableOriginatorServer is a subclass
+* of ObservableServer that sends
+* OriginatorMessage instances to its observers.
+* This class should be used when the observers need to know
+* the orginator of the messages received. The originator
+* is null when the message sent concerns the server.
+*
+* Project Name: OCSF (Object Client-Server Framework)
+*
+* @author Dr Robert Laganière
+* @author Dr Timothy C. Lethbridge
+* @author François Bélanger
+* @author Paul Holden
+* @version February 2001 (2.12)
+* @see ocsf.server.OriginatorMessage
+*/
+public class ObservableOriginatorServer extends ObservableServer
+{
+ // Constructor ******************************************************
+
+ /**
+ * Constructs a new server.
+ *
+ * @param port the port on which to listen.
+ */
+ public ObservableOriginatorServer(int port)
+ {
+ super(port);
+ }
+
+ // Instance methods ************************************************
+
+ /**
+ * This method is used to handle messages coming from the client.
+ * Observers are notfied by receiveing an instance of OriginatorMessage
+ * that contains both the message received and a reference to the
+ * client who sent the message.
+ *
+ * @param message The message received from the client.
+ * @param client The connection to the client.
+ */
+ protected synchronized void handleMessageFromClient
+ (Object message, ConnectionToClient client)
+ {
+ setChanged();
+ notifyObservers(new OriginatorMessage(client, message));
+ }
+
+ /**
+ * Method called each time a new client connection is
+ * accepted. It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing a reference to that client and
+ * the message defined by the static variable CLIENT_CONNECTED.
+ *
+ * @param client the connection connected to the client.
+ */
+ protected synchronized void clientConnected(ConnectionToClient client)
+ {
+ setChanged();
+ notifyObservers(new OriginatorMessage(client, CLIENT_CONNECTED));
+ }
+
+ /**
+ * Method called each time a client connection is
+ * disconnected. It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing a reference to that client and
+ * the message defined by the static variable CLIENT_DISCONNECTED.
+ *
+ * @param client the connection connected to the client.
+ */
+ synchronized protected void clientDisconnected(ConnectionToClient client)
+ {
+ setChanged();
+ notifyObservers(new OriginatorMessage(client, CLIENT_DISCONNECTED));
+ }
+
+
+ /**
+ * Method called each time an exception is raised
+ * by a client connection.
+ * It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing a reference to that client and
+ * the message defined by the static variable CLIENT_EXCEPTION
+ * to which is appended the exception message.
+ *
+ * @param client the client that raised the exception.
+ * @param Throwable the exception thrown.
+ */
+ synchronized protected void clientException(
+ ConnectionToClient client, Throwable exception)
+ {
+ setChanged();
+ notifyObservers(
+ new OriginatorMessage(client,
+ CLIENT_EXCEPTION + exception.getMessage()));
+ }
+
+ /**
+ * Method called each time an exception is raised
+ * while listening.
+ * It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing the message defined by the static variable LISTENING_EXCEPTION
+ * to which is appended the exception message.
+ * The originator is set to null.
+ *
+ * @param exception the exception raised.
+ */
+ protected synchronized void listeningException(Throwable exception)
+ {
+ setChanged();
+ notifyObservers(
+ new OriginatorMessage(null,
+ LISTENING_EXCEPTION + exception.getMessage()));
+ }
+
+ /**
+ * Method called each time the server is started.
+ * It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing the message defined by the static variable SERVER_STARTED.
+ * The originator is set to null.
+ */
+ protected synchronized void serverStarted()
+ {
+ setChanged();
+ notifyObservers(new OriginatorMessage(null, SERVER_STARTED));
+ }
+
+ /**
+ * Method called each time the server is stopped.
+ * It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing the message defined by the static variable SERVER_STOPPED.
+ * The originator is set to null.
+ */
+ synchronized protected void serverStopped()
+ {
+ setChanged();
+ notifyObservers(new OriginatorMessage(null, SERVER_STOPPED));
+ }
+
+ /**
+ * Method called each time the server is closed.
+ * It notifies observers by sending an
+ * OriginatorMessage instance
+ * containing the message defined by the static variable SERVER_CLOSED.
+ * The originator is set to null.
+ */
+ synchronized protected void serverClosed()
+ {
+ setChanged();
+ notifyObservers(new OriginatorMessage(null, SERVER_CLOSED));
+ }
+}
diff --git a/code/simplechat1/ocsf/server/ObservableServer.java b/code/simplechat1/ocsf/server/ObservableServer.java
new file mode 100644
index 0000000..5b16752
--- /dev/null
+++ b/code/simplechat1/ocsf/server/ObservableServer.java
@@ -0,0 +1,309 @@
+// This file contains material supporting section 6.13 of the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.server;
+
+import java.util.*;
+import java.io.*;
+import java.net.*;
+
+/**
+ * This class acts as a subclass of AbstractServer
+ * and is also an Observable class.
+ * This means that when a message is received, all observers
+ * are notified.
+ *
+ * @author François Bélange
+ * @author Dr Timothy C. Lethbridge
+ * @author Dr Robert Laganière
+ * @version August 2000
+ */
+
+public class ObservableServer extends Observable
+{
+ // Class variables ************************************************
+
+ /**
+ * The string sent to the observers when a client has connected.
+ */
+ public static final String CLIENT_CONNECTED= "#OS:Client connected.";
+
+ /**
+ * The string sent to the observers when a client has disconnected.
+ */
+ public static final String CLIENT_DISCONNECTED= "#OS:Client disconnected.";
+
+ /**
+ * The string sent to the observers when an exception occurred with a client.
+ * The error message of that exception will be appended to this string.
+ */
+ public static final String CLIENT_EXCEPTION= "#OS:Client exception.";
+
+ /**
+ * The string sent to the observers when a listening exception occurred.
+ * The error message of that exception will be appended to this string.
+ */
+ public static final String LISTENING_EXCEPTION= "#OS:Listening exception.";
+
+ /**
+ * The string sent to the observers when the server has closed.
+ */
+ public static final String SERVER_CLOSED= "#OS:Server closed.";
+
+ /**
+ * The string sent to the observers when the server has started.
+ */
+ public static final String SERVER_STARTED= "#OS:Server started.";
+
+ /**
+ * The string sent to the observers when the server has stopped.
+ */
+ public static final String SERVER_STOPPED= "#OS:Server stopped.";
+
+
+ //Instance variables **********************************************
+
+ /**
+ * The service used to simulate multiple class inheritance.
+ */
+ private AdaptableServer service;
+
+
+ //Constructor *****************************************************
+
+ /**
+ * Constructs a new server.
+ *
+ * @param port the port on which to listen.
+ */
+ public ObservableServer(int port)
+ {
+ service = new AdaptableServer(port, this);
+ }
+
+ //Instance methods ************************************************
+
+ /**
+ * Begins the thread that waits for new clients
+ */
+ final public void listen() throws IOException
+ {
+ service.listen();
+ }
+
+ /**
+ * Causes the server to stop accepting new connections.
+ */
+ final public void stopListening()
+ {
+ service.stopListening();
+ }
+
+ /**
+ * Closes the server's connections with all clients.
+ */
+ final public void close() throws IOException
+ {
+ service.close();
+ }
+
+ /**
+ * Sends a message to every client connected to the server.
+ *
+ * @param msg The message to be sent
+ */
+ public void sendToAllClients(Object msg)
+ {
+ service.sendToAllClients(msg);
+ }
+
+// ACCESSING METHODS ------------------------------------------------
+
+ /**
+ * Used to find out if the server is accepting new clients.
+ */
+ final public boolean isListening()
+ {
+ return service.isListening();
+ }
+
+ /**
+ * Returns an array of containing the existing
+ * client connections. This can be used by
+ * concrete subclasses to implement messages that do something with
+ * each connection (e.g. kill it, send a message to it etc.)
+ *
+ * @return an array of Thread containing
+ * ConnectionToClient instances.
+ */
+ final public Thread[] getClientConnections()
+ {
+ return service.getClientConnections();
+ }
+
+ /**
+ * @return the number of clients currently connected.
+ */
+ final public int getNumberOfClients()
+ {
+ return service.getNumberOfClients();
+ }
+
+ /**
+ * @return the port number.
+ */
+ final public int getPort()
+ {
+ return service.getPort();
+ }
+
+ /**
+ * Sets the port number for the next connection.
+ * Only has effect if the server is not currently listening.
+ *
+ * @param port the port number.
+ */
+ final public void setPort(int port)
+ {
+ service.setPort(port);
+ }
+
+ /**
+ * Sets the timeout time when accepting connection.
+ * The default is half a second.
+ * The server must be stopped and restarted for the timeout
+ * change be in effect.
+ *
+ * @param timeout the timeout time in ms.
+ */
+ final public void setTimeout(int timeout)
+ {
+ service.setTimeout(timeout);
+ }
+
+ /**
+ * Sets the maximum number of
+ * waiting connections accepted by the operating system.
+ * The default is 20.
+ * The server must be closed and restart for the backlog
+ * change be in effect.
+ *
+ * @param backlog the maximum number of connections.
+ */
+ final public void setBacklog(int backlog)
+ {
+ service.setBacklog(backlog);
+ }
+
+ /**
+ * Hook method called each time a new client connection is
+ * accepted. The method may be overridden by subclasses.
+ *
+ * @param client the connection connected to the client.
+ */
+ protected synchronized void clientConnected(ConnectionToClient client)
+ {
+ setChanged();
+ notifyObservers(CLIENT_CONNECTED);
+ }
+
+ /**
+ * Hook method called each time a client disconnects.
+ * The method may be overridden by subclasses.
+ *
+ * @param client the connection with the client.
+ */
+ protected synchronized void clientDisconnected(ConnectionToClient client)
+ {
+ setChanged();
+ notifyObservers(CLIENT_DISCONNECTED);
+ }
+
+ /**
+ * Hook method called each time an exception
+ * is raised in a client thread.
+ * This implementation simply closes the
+ * client connection, ignoring any exception.
+ * The method may be overridden by subclasses.
+ *
+ * @param client the client that raised the exception.
+ * @param exception the exception raised.
+ */
+ protected synchronized void clientException(ConnectionToClient client,
+ Throwable exception)
+ {
+ setChanged();
+ notifyObservers(CLIENT_EXCEPTION);
+ try
+ {
+ client.close();
+ }
+ catch (Exception e) {}
+ }
+
+ /**
+ * This method is called when the server stops accepting
+ * connections because an exception has been raised.
+ * This implementation
+ * simply calls stopListening.
+ * This method may be overriden by subclasses.
+ *
+ * @param exception the exception raised.
+ */
+ protected synchronized void listeningException(Throwable exception)
+ {
+ setChanged();
+ notifyObservers(LISTENING_EXCEPTION);
+ stopListening();
+ }
+
+ /**
+ * This method is called when the server stops accepting
+ * connections for any reason. This method may be overriden by
+ * subclasses.
+ */
+ synchronized protected void serverStopped()
+ {
+ setChanged();
+ notifyObservers(SERVER_STOPPED);
+ }
+
+ /**
+ * This method is called when the server is closed.
+ * This method may be overriden by subclasses.
+ */
+ synchronized protected void serverClosed()
+ {
+ setChanged();
+ notifyObservers(SERVER_CLOSED);
+ }
+
+ /**
+ * This method is called when the server starts listening for
+ * connections. The method may be overridden by subclasses.
+ */
+ protected synchronized void serverStarted()
+ {
+ setChanged();
+ notifyObservers(SERVER_STARTED);
+ }
+
+ /**
+ * This method is used to handle messages coming from the client.
+ * Observers are notfied by receiveing the transmitted message.
+ * Note that, in this implementation, the information concerning
+ * the client that sent the message is lost.
+ * It can be overriden, but is still expected to call notifyObservers().
+ *
+ * @param message The message received from the client.
+ * @param client The connection to the client.
+ * @see ocsf.server.ObservableOriginatorServer
+ */
+ protected synchronized void handleMessageFromClient
+ (Object message, ConnectionToClient client)
+ {
+ setChanged();
+ notifyObservers(message);
+ }
+}
diff --git a/code/simplechat1/ocsf/server/OriginatorMessage.java b/code/simplechat1/ocsf/server/OriginatorMessage.java
new file mode 100644
index 0000000..a25d2b4
--- /dev/null
+++ b/code/simplechat1/ocsf/server/OriginatorMessage.java
@@ -0,0 +1,61 @@
+// This file contains material supporting the textbook:
+// "Object Oriented Software Engineering" and is issued under the open-source
+// license found at www.lloseng.com
+
+package ocsf.server;
+
+/**
+ * A message class used by the Observable layer of the OCSF in order to conserve
+ * information about the originator of a message.
+ *
+ * @author Dr. Robert Laganière
+ * @version July 2001
+ */
+public class OriginatorMessage
+{
+ /**
+ * The connection that originated the message
+ */
+ private ConnectionToClient originator;
+
+ /**
+ * The message.
+ */
+ private Object message;
+
+// Constructor ***************************************************************
+
+ /**
+ * Constructs an instance of an OriginatorMessage
+ *
+ * @param originator The client who created this message
+ * @param message The contents of the message
+ */
+ public OriginatorMessage(ConnectionToClient originator, Object message)
+ {
+ this.originator = originator;
+ this.message = message;
+ }
+
+// Accessor methods *********************************************************
+
+ /**
+ * Returns the originating connection.
+ *
+ * @return The connection from which the message originated.
+ */
+ public ConnectionToClient getOriginator()
+ {
+ return originator;
+ }
+
+ /**
+ * Returns the message's contents.
+ *
+ * @return The content of the message.
+ */
+ public Object getMessage()
+ {
+ return message;
+ }
+}
From 8efdd8a201e36ac2ed90f3da102a47815dfc13f2 Mon Sep 17 00:00:00 2001
From: ielmie <65829854+ielmie@users.noreply.github.com>
Date: Fri, 29 May 2020 16:48:11 -0400
Subject: [PATCH 2/6] Question 6 changes
Added the command functionnalities to ChatClient and EchoServer and created ServerConsole.java
---
code/simplechat1/ClientConsole.java | 13 ++-
code/simplechat1/EchoServer.java | 118 ++++++++++++++++++++++-
code/simplechat1/ServerConsole.java | 114 ++++++++++++++++++++++
code/simplechat1/client/ChatClient.java | 122 +++++++++++++++++++++---
4 files changed, 353 insertions(+), 14 deletions(-)
create mode 100644 code/simplechat1/ServerConsole.java
diff --git a/code/simplechat1/ClientConsole.java b/code/simplechat1/ClientConsole.java
index 2706d7f..069a018 100644
--- a/code/simplechat1/ClientConsole.java
+++ b/code/simplechat1/ClientConsole.java
@@ -91,7 +91,18 @@ public void accept()
*/
public void display(String message)
{
- System.out.println("> " + message);
+ //For a message coming from the server to not have a > prepended
+ try{
+ if (message.charAt(10)=='>'){
+ System.out.println(message);
+ }
+ else{
+ System.out.println("> " + message);
+ }
+ }
+ catch(IndexOutOfBoundsException e){
+ System.out.println("> " + message);
+ }
}
diff --git a/code/simplechat1/EchoServer.java b/code/simplechat1/EchoServer.java
index b734e31..bc28c52 100644
--- a/code/simplechat1/EchoServer.java
+++ b/code/simplechat1/EchoServer.java
@@ -2,6 +2,7 @@
// "Object Oriented Software Engineering" and is issued under the open-source
// license found at www.lloseng.com
+import common.*;
import java.io.*;
import ocsf.server.*;
@@ -24,6 +25,7 @@ public class EchoServer extends AbstractServer
*/
final public static int DEFAULT_PORT = 5555;
+
//Constructors ****************************************************
/**
@@ -34,6 +36,7 @@ public class EchoServer extends AbstractServer
public EchoServer(int port)
{
super(port);
+
}
@@ -48,6 +51,8 @@ public EchoServer(int port)
* @param client the client that raised the exception.
* @param Throwable the exception thrown.
*/
+
+ //when an exception is thrown, it calls the clientDisconnected hook method to print the appropriate message.
synchronized protected void clientException(
ConnectionToClient client, Throwable exception) {
clientDisconnected(client);
@@ -58,6 +63,8 @@ synchronized protected void clientException(
* accepted. The default implementation does nothing.
* @param client the connection connected to the client.
*/
+
+ //prints a message when the client logs on.
protected void clientConnected(ConnectionToClient client) {
System.out.println("Client has logged on");
}
@@ -69,6 +76,8 @@ protected void clientConnected(ConnectionToClient client) {
*
* @param client the connection with the client.
*/
+
+ //prints a message when the client logs off
synchronized protected void clientDisconnected(ConnectionToClient client) {
System.out.println("Client has logged off");
}
@@ -104,7 +113,114 @@ protected void serverStarted()
protected void serverStopped()
{
System.out.println
- ("Server has stopped listening for connections.");
+ ("Server has stopped listening for new connections.");
+ }
+
+ /**
+ * Hook method called when the server stops accepting
+ * connections because an exception has been raised.
+ * The default implementation does nothing.
+ * This method may be overriden by subclasses.
+ *
+ * @param exception the exception raised.
+ */
+ protected void listeningException(Throwable exception) {
+ }
+
+
+ /**
+ * Hook method called when the server is clased.
+ * The default implementation does nothing. This method may be
+ * overriden by subclasses. When the server is closed while still
+ * listening, serverStopped() will also be called.
+ */
+ protected void serverClosed(){
+ System.out.println
+ ("Server has closed all connections."); }
+
+ public void commandHelperMethod(String message){
+
+ //seperates the command from the arguments (if pertinent - for #sethost and #setport)
+ String[] argumentsArray = message.split(" ");
+
+ switch(argumentsArray[0]){
+
+ case "#quit": //calls the quit method to logoff without having to use ctrl+c
+ try{
+ close();
+ }
+ catch(IOException e){
+
+ }
+ System.out.print("Shutting down server");
+ System.exit(0);
+ break;
+
+ case "#stop":
+ stopListening();
+ break;
+
+ case "#close":
+ try{
+ close();
+ }
+ catch(IOException e){
+
+ }
+ break;
+
+ case "#setport": //allows the user to change the port (only available when not connected to a server)
+ if(!isListening()&&getNumberOfClients()==0){
+ try{
+ setPort(Integer.parseInt(argumentsArray[1]));
+ }
+ catch(ArrayIndexOutOfBoundsException e){
+ System.out.println("Port number not specified. Please use the following format: #setport ");
+ }
+ }
+ else{
+ System.out.println("The server is currently open. You must first close the server using #close");
+ }
+ break;
+
+ case "#start":
+ try{
+ listen();
+ }
+ catch(IOException e){
+
+ }
+ break;
+
+ case "#getport": // prints the port number
+ System.out.println("The port number is: "+Integer.toString(getPort()));
+ break;
+
+ default: //if someone typed the wrong command they would get an error message and a list of accepted commands
+ System.out.println("This is not a recognised command");
+ System.out.println("Please use one of the following:");
+ System.out.println("#quit, #stop, #close, #setport, #start or #getport");
+ break;
+ }
+
+ }
+
+ /**
+ * This method handles all data coming from the UI
+ *
+ * @param message The message from the UI.
+ */
+ public void handleMessageFromServerUI(String message)
+ {
+ //Checks if the message is a command and redirects it to the helper method
+ if(message.charAt(0)=='#'){
+ commandHelperMethod(message);
+ }
+ else{
+ sendToAllClients("SERVER MSG> "+message);
+ //makes the messages comming from the server begin with 'SERVER MSG>'
+ System.out.println("SERVER MSG> " + message);
+ }
}
//Class methods ***************************************************
diff --git a/code/simplechat1/ServerConsole.java b/code/simplechat1/ServerConsole.java
new file mode 100644
index 0000000..5987aa5
--- /dev/null
+++ b/code/simplechat1/ServerConsole.java
@@ -0,0 +1,114 @@
+import java.io.*;
+import common.*;
+
+/**
+ * This class constructs the UI for a server. It implements the
+ * chat interface in order to activate the display() method.
+*/
+
+public class ServerConsole implements ChatIF
+{
+ //Class variables *************************************************
+
+ /**
+ * The default port to connect on.
+ */
+ final public static int DEFAULT_PORT = 5555;
+
+ //Instance variables **********************************************
+
+ /**
+ * The instance of the Server that created this ConsoleChat.
+ */
+ EchoServer server;
+
+
+ //Constructors ****************************************************
+
+ /**
+ * Constructs an instance of the ServerConsole UI.
+ *
+ * @param host The host to connect to.
+ * @param port The port to connect on.
+ */
+ public ServerConsole(int port)
+ {
+ server= new EchoServer(port);
+ try
+ {
+ server.listen(); //Start listening for connections
+ }
+ catch (Exception ex)
+ {
+ System.out.println("ERROR - Could not listen for clients!");
+ }
+
+ }
+
+
+ //Instance methods ************************************************
+
+ /**
+ * This method waits for input from the console. Once it is
+ * received, it sends it to the client's message handler.
+ */
+ public void accept()
+ {
+ try
+ {
+ BufferedReader fromConsole =
+ new BufferedReader(new InputStreamReader(System.in));
+ String message;
+
+ while (true)
+ {
+ message = fromConsole.readLine();
+ server.handleMessageFromServerUI(message);
+ }
+ }
+ catch (Exception ex)
+ {
+ System.out.println
+ ("Unexpected error while reading from console!");
+ }
+ }
+
+ /**
+ * This method overrides the method in the ChatIF interface. It
+ * displays a message onto the screen.
+ *
+ * @param message The string to be displayed.
+ */
+ public void display(String message)
+ {
+ //makes the messages comming from the server begin with 'SERVER MSG>'
+ System.out.println("SERVER MSG> " + message);
+ }
+
+
+ //Class methods ***************************************************
+
+ /**
+ * This method is responsible for the creation of the Server UI.
+ *
+ * @param args[0] The host to connect to.
+ */
+ public static void main(String[] args)
+ {
+ String host = "";
+ int port = 0; //The port number
+
+ try
+ {
+ port = Integer.valueOf(args[0]);
+ }
+ //If there's no 1st argument, it will use the DEFAULT_PORT
+ catch(ArrayIndexOutOfBoundsException e)
+ {
+ port = DEFAULT_PORT;
+ }
+ ServerConsole chat= new ServerConsole(port); //will use the port variable instead of DEFAULT_PORT
+ chat.accept(); //Wait for console data
+ }
+}
+//End of ConsoleChat class
diff --git a/code/simplechat1/client/ChatClient.java b/code/simplechat1/client/ChatClient.java
index fa2ee50..d46551b 100644
--- a/code/simplechat1/client/ChatClient.java
+++ b/code/simplechat1/client/ChatClient.java
@@ -65,8 +65,11 @@ public void handleMessageFromServer(Object msg)
* perform special processing such as cleaning up and terminating, or
* attempting to reconnect.
*/
+
+ //cleanup method called whenever the user disconnects from the server.
+ //It prints a message telling the user so
protected void connectionClosed() {
- System.out.println("The connection to the server is closed");
+ System.out.println("You have logged off from the server.");
}
/**
@@ -77,10 +80,99 @@ protected void connectionClosed() {
* @param exception
* the exception raised.
*/
+
+ //When an exception is raised, it tells the user that they are no longer connected to the server
+ //then it closes the connection to the server formally
+ //without quitting (so that the user could log back on if they so chose
protected void connectionException(Exception exception) {
- quit();
+ System.out.println("Connection to server terminated");
+ try{closeConnection(); }
+ catch(IOException e) {}
+ }
+
+
+ /**
+ *
+ *This method handles the case when a user enters a string starting with a #
+ *It parses the message to see what command it was then it executes said command
+ *
+ * @param message The message from the UI.
+ */
+
+ public void commandHelperMethod(String message){
+
+ //seperates the command from the arguments (if pertinent - for #sethost and #setport)
+ String[] argumentsArray = message.split(" ");
+
+ switch(argumentsArray[0]){
+
+ case "#quit": //calls the quit method to logoff without having to use ctrl+c
+ quit();
+ break;
+
+ case "#logoff": //allows the user to logoff from the server without exiting completely
+ try{closeConnection(); }
+ catch(IOException e) {}
+ break;
+
+ case "#sethost": //allows the user to change the host (only available when not connected to a server)
+ if(!isConnected()){
+ try{
+ setHost(argumentsArray[1]);
+ }
+ catch(ArrayIndexOutOfBoundsException e){
+ System.out.println("Host name not specified. Please use the following format: #sethost ");
+ }
+ }
+ else{
+ System.out.println("You are currently connected to a server. You must first #logoff to change hosts");
+ }
+ break;
+
+ case "#setport": //allows the user to change the port (only available when not connected to a server)
+ if(!isConnected()){
+ try{
+ setPort(Integer.parseInt(argumentsArray[1]));
+ }
+ catch(ArrayIndexOutOfBoundsException e){
+ System.out.println("Port number not specified. Please use the following format: #setport ");
+ }
+ }
+ else{
+ System.out.println("You are currently connected to a server. You must first #logoff to change ports");
+ }
+ break;
+
+ case "#login": //allows the user to log into a server (cannot be used when already connected)
+ if(!isConnected()){
+ try{openConnection(); }
+ catch(IOException e) {}
+
+ }
+ else{
+ System.out.println("You are already connected to a server.");
+ }
+ break;
+
+ case "#gethost": //prints the host name
+ System.out.println("The host name is: "+getHost());
+ break;
+
+ case "#getport": // prints the port number
+ System.out.println("The port number is: "+Integer.toString(getPort()));
+ break;
+
+ default: //if someone typed the wrong command they would get an error message and a list of accepted commands
+ System.out.println("This is not a recognised command");
+ System.out.println("Please use one of the following:");
+ System.out.println("#quit, #logoff, #sethost, #setport, #login, #gethost or #getport");
+ break;
+ }
+
}
+
+
/**
* This method handles all data coming from the UI
*
@@ -88,16 +180,22 @@ protected void connectionException(Exception exception) {
*/
public void handleMessageFromClientUI(String message)
{
- try
- {
- sendToServer(message);
- }
- catch(IOException e)
- {
- clientUI.display
- ("Could not send message to server. Terminating client.");
- quit();
- }
+ //Checks if the message is a command and redirects it to the helper method
+ if(message.charAt(0)=='#'){
+ commandHelperMethod(message);
+ }
+ else{
+ try
+ {
+ sendToServer(message);
+ }
+ catch(IOException e)
+ {
+ clientUI.display
+ ("Could not send message to server. Terminating client.");
+ quit();
+ }
+ }
}
/**
From a5dee50f252be1f5b76b517b5fc3731466f43f7d Mon Sep 17 00:00:00 2001
From: ielmie <65829854+ielmie@users.noreply.github.com>
Date: Sat, 30 May 2020 22:15:57 -0400
Subject: [PATCH 3/6] Final Version
The Changes made were to ChatClient.java, ClientConsole.java and EchoServer.java.
ServerConsole.java was written by modifying ClientConsole.java to allow the server to interact with the command line.
All changes made to these files were made in order to add the functionnalities depicted in the layout for SEG2105 - assignment 1.
---
code/simplechat1/ClientConsole.java | 33 +++++--
code/simplechat1/EchoServer.java | 113 ++++++++++++++++++------
code/simplechat1/ServerConsole.java | 8 +-
code/simplechat1/client/ChatClient.java | 60 ++++++++++---
4 files changed, 169 insertions(+), 45 deletions(-)
diff --git a/code/simplechat1/ClientConsole.java b/code/simplechat1/ClientConsole.java
index 069a018..d62d95e 100644
--- a/code/simplechat1/ClientConsole.java
+++ b/code/simplechat1/ClientConsole.java
@@ -41,11 +41,11 @@ public class ClientConsole implements ChatIF
* @param host The host to connect to.
* @param port The port to connect on.
*/
- public ClientConsole(String host, int port)
+ public ClientConsole(String clientId, String host, int port)
{
try
{
- client= new ChatClient(host, port, this);
+ client= new ChatClient(clientId, host, port, this);
}
catch(IOException exception)
{
@@ -117,21 +117,39 @@ public static void main(String[] args)
{
String host = "";
int port = 0; //The port number
-
+ String clientId = ""; //The user's loginId
+
+
+ //Question 7a
+ //Assigns the first argument as the loginId
+ try {
+ clientId=args[0];
+ }
+ //If no loginId is provided an error message is printed and the user is disconnected
+ catch(ArrayIndexOutOfBoundsException e0){
+ System.out.println("Cannot connect to server without login Id.");
+ System.exit(0);
+ }
+
try
{
- host = args[0];
+ //Question 7 a
+ //changed to second arg since adding clientId
+ host = args[1];
}
catch(ArrayIndexOutOfBoundsException e1)
{
host = "localhost";
}
- //Q5b This try loop checks to see if there is a second argument
+ //Question 5b
+ //This try loop checks to see if there is a second argument
//If that's the case, it will assign it as the port number
try
{
- port = Integer.valueOf(args[1]);
+ //Question 7 a
+ //changed to third arg since adding clientId
+ port = Integer.valueOf(args[2]);
}
//If there's no 2nd argument, it will use the DEFAULT_PORT
catch(ArrayIndexOutOfBoundsException e2)
@@ -139,7 +157,8 @@ public static void main(String[] args)
port = DEFAULT_PORT;
}
//will use the port variable defined above instead of DEFAULT_PORT
- ClientConsole chat= new ClientConsole(host, port);
+ //added the loginId to the constructor (Question 7a)
+ ClientConsole chat= new ClientConsole(clientId, host, port);
chat.accept(); //Wait for console data
}
}
diff --git a/code/simplechat1/EchoServer.java b/code/simplechat1/EchoServer.java
index bc28c52..0e11b6f 100644
--- a/code/simplechat1/EchoServer.java
+++ b/code/simplechat1/EchoServer.java
@@ -25,6 +25,7 @@ public class EchoServer extends AbstractServer
*/
final public static int DEFAULT_PORT = 5555;
+
//Constructors ****************************************************
@@ -52,6 +53,7 @@ public EchoServer(int port)
* @param Throwable the exception thrown.
*/
+ //Question 5c
//when an exception is thrown, it calls the clientDisconnected hook method to print the appropriate message.
synchronized protected void clientException(
ConnectionToClient client, Throwable exception) {
@@ -64,9 +66,11 @@ synchronized protected void clientException(
* @param client the connection connected to the client.
*/
+ //Question 5c
//prints a message when the client logs on.
protected void clientConnected(ConnectionToClient client) {
System.out.println("Client has logged on");
+
}
/**
@@ -77,9 +81,11 @@ protected void clientConnected(ConnectionToClient client) {
* @param client the connection with the client.
*/
+ //Question 5c
//prints a message when the client logs off
synchronized protected void clientDisconnected(ConnectionToClient client) {
System.out.println("Client has logged off");
+
}
@@ -92,8 +98,59 @@ synchronized protected void clientDisconnected(ConnectionToClient client) {
public void handleMessageFromClient
(Object msg, ConnectionToClient client)
{
- System.out.println("Message received: " + msg + " from " + client);
- this.sendToAllClients(msg);
+ //converts the message Object into a string
+ String message = msg.toString();
+ //splits the string into words
+ String[] idArray = message.split(" ");
+
+ //Question 7 c i
+ //This if statement recognizes the #login command
+ if(idArray[0].equals("#login")){
+ try{
+ //Question 7 iv
+ //Tries to get loginId, if there is none, then (#login ) is the first message
+ // it would then jump to the catch Exception e
+ String test = client.getInfo("loginId").toString();
+ try{
+ //An error message would be printed if the loginId already exists
+ client.sendToClient("Error: you have already given us a login Id");
+ }
+ catch(IOException e){}
+ }
+ catch(Exception f){
+ //Question 7ii
+ //identifies the client by adding the loginId to the user info hashmap.
+ client.setInfo("loginId", idArray[1]);
+
+ }
+ }
+ else{
+ try{
+ //Tries to get loginId, if there is none, then the first message (#login ) was not recieved
+ // it would then jump to the catch Exception g
+ String test = client.getInfo("loginId").toString();
+ //Question 7 c iii
+ //Prints message in server and sends the message out to all users with the loginId prepended.
+ System.out.println("Message received: " + msg + " from " + client);
+ this.sendToAllClients(client.getInfo("loginId").toString() + " " + msg);
+ }
+ catch(Exception g){
+ //Question 7 c v
+ //If the loginId has not already been recieved as 1st message it prints and error message
+ //and closes the connection to that client.
+ try{
+ client.sendToClient("Error: no login Id provided by the system");
+ }
+ catch(IOException h){}
+ finally{
+ try{
+ client.close();
+ }
+ catch(IOException i){}
+ }
+ }
+ }
+
}
/**
@@ -115,17 +172,6 @@ protected void serverStopped()
System.out.println
("Server has stopped listening for new connections.");
}
-
- /**
- * Hook method called when the server stops accepting
- * connections because an exception has been raised.
- * The default implementation does nothing.
- * This method may be overriden by subclasses.
- *
- * @param exception the exception raised.
- */
- protected void listeningException(Throwable exception) {
- }
/**
@@ -138,14 +184,26 @@ protected void serverClosed(){
System.out.println
("Server has closed all connections."); }
+
+ /**
+ *
+ *This method handles the case when a user enters a string starting with a #
+ *It parses the message to see what command it was then it executes said command
+ *
+ * @param message The message from the UI.
+ */
+
+ //Question 6 c
+ //Method that recieves a message that begins with # (a command)
+ //and parses which command was issued and what to do
public void commandHelperMethod(String message){
- //seperates the command from the arguments (if pertinent - for #sethost and #setport)
+ //seperates the command from the arguments (if pertinent - for #setport)
String[] argumentsArray = message.split(" ");
switch(argumentsArray[0]){
-
- case "#quit": //calls the quit method to logoff without having to use ctrl+c
+ //Question 6 c i
+ case "#quit": //closes the server then quits the system
try{
close();
}
@@ -155,12 +213,12 @@ public void commandHelperMethod(String message){
System.out.print("Shutting down server");
System.exit(0);
break;
-
- case "#stop":
+ //Question 6 c ii
+ case "#stop": //stops listening for new clients
stopListening();
break;
-
- case "#close":
+ //Question 6 c iii
+ case "#close": //closes the server (stops listening + kicks the current users off)
try{
close();
}
@@ -168,7 +226,7 @@ public void commandHelperMethod(String message){
}
break;
-
+ //Question 6 c iv
case "#setport": //allows the user to change the port (only available when not connected to a server)
if(!isListening()&&getNumberOfClients()==0){
try{
@@ -182,8 +240,8 @@ public void commandHelperMethod(String message){
System.out.println("The server is currently open. You must first close the server using #close");
}
break;
-
- case "#start":
+ //Question 6 c v
+ case "#start": //opens the server
try{
listen();
}
@@ -191,7 +249,7 @@ public void commandHelperMethod(String message){
}
break;
-
+ //Question 6 c vi
case "#getport": // prints the port number
System.out.println("The port number is: "+Integer.toString(getPort()));
break;
@@ -210,6 +268,8 @@ public void commandHelperMethod(String message){
*
* @param message The message from the UI.
*/
+
+
public void handleMessageFromServerUI(String message)
{
//Checks if the message is a command and redirects it to the helper method
@@ -217,8 +277,11 @@ public void handleMessageFromServerUI(String message)
commandHelperMethod(message);
}
else{
+ //Question 6b ii
+ //makes the messages comming from the server begin with 'SERVER MSG>'
+
sendToAllClients("SERVER MSG> "+message);
- //makes the messages comming from the server begin with 'SERVER MSG>'
+
System.out.println("SERVER MSG> " + message);
}
}
diff --git a/code/simplechat1/ServerConsole.java b/code/simplechat1/ServerConsole.java
index 5987aa5..226e3e2 100644
--- a/code/simplechat1/ServerConsole.java
+++ b/code/simplechat1/ServerConsole.java
@@ -1,3 +1,8 @@
+//Code written for Question 6b. Creates a ServerConsole which implements EchoServer
+//And allows it to communicate with the other users
+
+
+
import java.io.*;
import common.*;
@@ -81,7 +86,8 @@ public void accept()
*/
public void display(String message)
{
- //makes the messages comming from the server begin with 'SERVER MSG>'
+ //I don't actually need to call this method in EchoServer but it is implemented for future use
+ //makes the messages comming from the server begin with 'SERVER MSG>'
System.out.println("SERVER MSG> " + message);
}
diff --git a/code/simplechat1/client/ChatClient.java b/code/simplechat1/client/ChatClient.java
index d46551b..ee5cc65 100644
--- a/code/simplechat1/client/ChatClient.java
+++ b/code/simplechat1/client/ChatClient.java
@@ -26,6 +26,9 @@ public class ChatClient extends AbstractClient
* the display method in the client.
*/
ChatIF clientUI;
+ //Question 7a
+ //Created a loginId variable to store the user's loginId
+ String loginId;
//Constructors ****************************************************
@@ -38,11 +41,15 @@ public class ChatClient extends AbstractClient
* @param clientUI The interface type variable.
*/
- public ChatClient(String host, int port, ChatIF clientUI)
+ //Question 7 a
+ //the login Id is added as a parameter to the constructor
+
+ public ChatClient(String loginId, String host, int port, ChatIF clientUI)
throws IOException
{
- super(host, port); //Call the superclass constructor
+ super(host, port); //Call the superclass constructor
this.clientUI = clientUI;
+ this.loginId = loginId;
openConnection();
}
@@ -57,7 +64,26 @@ public ChatClient(String host, int port, ChatIF clientUI)
public void handleMessageFromServer(Object msg)
{
clientUI.display(msg.toString());
- }
+ }
+
+ /**
+ * Hook method called after a connection has been established. The default
+ * implementation does nothing. It may be overridden by subclasses to do
+ * anything they wish.
+ */
+
+ //Question 7 b
+ //sends message to server with login Id
+
+ protected void connectionEstablished() {
+
+ try{
+ sendToServer("#login "+ loginId);
+ }
+ catch(IOException e){
+
+ }
+ }
/**
* Hook method called after the connection has been closed. The default
@@ -66,6 +92,7 @@ public void handleMessageFromServer(Object msg)
* attempting to reconnect.
*/
+ //Question 5 a
//cleanup method called whenever the user disconnects from the server.
//It prints a message telling the user so
protected void connectionClosed() {
@@ -81,12 +108,13 @@ protected void connectionClosed() {
* the exception raised.
*/
+ //Question 5a
//When an exception is raised, it tells the user that they are no longer connected to the server
//then it closes the connection to the server formally
//without quitting (so that the user could log back on if they so chose
protected void connectionException(Exception exception) {
System.out.println("Connection to server terminated");
- try{closeConnection(); }
+ try{closeConnection();}
catch(IOException e) {}
}
@@ -98,7 +126,11 @@ protected void connectionException(Exception exception) {
*
* @param message The message from the UI.
*/
-
+
+ //Question 6 a
+ //Method that recieves a message that begins with # (a command)
+ //and parses which command was issued and what to do
+
public void commandHelperMethod(String message){
//seperates the command from the arguments (if pertinent - for #sethost and #setport)
@@ -106,15 +138,16 @@ public void commandHelperMethod(String message){
switch(argumentsArray[0]){
+ //Question 6a i
case "#quit": //calls the quit method to logoff without having to use ctrl+c
quit();
break;
-
+ //Question 6a ii
case "#logoff": //allows the user to logoff from the server without exiting completely
try{closeConnection(); }
catch(IOException e) {}
break;
-
+ //Question 6a iii
case "#sethost": //allows the user to change the host (only available when not connected to a server)
if(!isConnected()){
try{
@@ -128,7 +161,7 @@ public void commandHelperMethod(String message){
System.out.println("You are currently connected to a server. You must first #logoff to change hosts");
}
break;
-
+ //Question 6a iv
case "#setport": //allows the user to change the port (only available when not connected to a server)
if(!isConnected()){
try{
@@ -142,10 +175,12 @@ public void commandHelperMethod(String message){
System.out.println("You are currently connected to a server. You must first #logoff to change ports");
}
break;
-
+ //Question 6a v
case "#login": //allows the user to log into a server (cannot be used when already connected)
if(!isConnected()){
- try{openConnection(); }
+ try{
+ openConnection();
+ }
catch(IOException e) {}
}
@@ -153,11 +188,11 @@ public void commandHelperMethod(String message){
System.out.println("You are already connected to a server.");
}
break;
-
+ //Question 6a vi
case "#gethost": //prints the host name
System.out.println("The host name is: "+getHost());
break;
-
+ //Question 6a v
case "#getport": // prints the port number
System.out.println("The port number is: "+Integer.toString(getPort()));
break;
@@ -180,6 +215,7 @@ public void commandHelperMethod(String message){
*/
public void handleMessageFromClientUI(String message)
{
+ //Question 6a
//Checks if the message is a command and redirects it to the helper method
if(message.charAt(0)=='#'){
commandHelperMethod(message);
From f9afe19e1112b020e4d8d35a1efcf248c19ee0c1 Mon Sep 17 00:00:00 2001
From: ielmie <65829854+ielmie@users.noreply.github.com>
Date: Sun, 31 May 2020 19:48:30 -0400
Subject: [PATCH 4/6] Actual Final Edit
---
code/simplechat1/ClientConsole.java | 5 ++---
code/simplechat1/EchoServer.java | 14 +++++++++-----
2 files changed, 11 insertions(+), 8 deletions(-)
diff --git a/code/simplechat1/ClientConsole.java b/code/simplechat1/ClientConsole.java
index d62d95e..5da272b 100644
--- a/code/simplechat1/ClientConsole.java
+++ b/code/simplechat1/ClientConsole.java
@@ -49,9 +49,8 @@ public ClientConsole(String clientId, String host, int port)
}
catch(IOException exception)
{
- System.out.println("Error: Can't setup connection!"
- + " Terminating client.");
- System.exit(1);
+ System.out.println("Cannot open connection."
+ + " Awaiting command.");
}
}
diff --git a/code/simplechat1/EchoServer.java b/code/simplechat1/EchoServer.java
index 0e11b6f..9554ace 100644
--- a/code/simplechat1/EchoServer.java
+++ b/code/simplechat1/EchoServer.java
@@ -2,7 +2,6 @@
// "Object Oriented Software Engineering" and is issued under the open-source
// license found at www.lloseng.com
-import common.*;
import java.io.*;
import ocsf.server.*;
@@ -69,8 +68,7 @@ synchronized protected void clientException(
//Question 5c
//prints a message when the client logs on.
protected void clientConnected(ConnectionToClient client) {
- System.out.println("Client has logged on");
-
+ System.out.println("A new client is attempting to connect to the server.");
}
/**
@@ -83,8 +81,10 @@ protected void clientConnected(ConnectionToClient client) {
//Question 5c
//prints a message when the client logs off
+ //changed to comply with the testcases
synchronized protected void clientDisconnected(ConnectionToClient client) {
- System.out.println("Client has logged off");
+ this.sendToAllClients(client.getInfo("loginId").toString() + " has logged off ");
+ System.out.println(client.getInfo("loginId").toString()+" has logged off");
}
@@ -121,6 +121,10 @@ synchronized protected void clientDisconnected(ConnectionToClient client) {
//Question 7ii
//identifies the client by adding the loginId to the user info hashmap.
client.setInfo("loginId", idArray[1]);
+ //Question 5c
+ //Message that tells all users when someone logs onto the server
+ this.sendToAllClients(client.getInfo("loginId").toString() + " has logged on ");
+ System.out.println(client.getInfo("loginId").toString()+" has logged on");
}
}
@@ -131,7 +135,7 @@ synchronized protected void clientDisconnected(ConnectionToClient client) {
String test = client.getInfo("loginId").toString();
//Question 7 c iii
//Prints message in server and sends the message out to all users with the loginId prepended.
- System.out.println("Message received: " + msg + " from " + client);
+ System.out.println("Message received: " + msg + " from " + client.getInfo("loginId").toString());
this.sendToAllClients(client.getInfo("loginId").toString() + " " + msg);
}
catch(Exception g){
From 7ec12edf4a68841e19f24027e5cbe6f97e65ca63 Mon Sep 17 00:00:00 2001
From: ielmie <65829854+ielmie@users.noreply.github.com>
Date: Sun, 31 May 2020 20:35:25 -0400
Subject: [PATCH 5/6] Create Testcases_Fortin_6338858.docx
---
code/Testcases_Fortin_6338858.docx | Bin 0 -> 278232 bytes
1 file changed, 0 insertions(+), 0 deletions(-)
create mode 100644 code/Testcases_Fortin_6338858.docx
diff --git a/code/Testcases_Fortin_6338858.docx b/code/Testcases_Fortin_6338858.docx
new file mode 100644
index 0000000000000000000000000000000000000000..1eb987a31692bb4f170c4663172ed4938f13f867
GIT binary patch
literal 278232
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 |