Add files via upload

Author: kochlisGit

src/servers/ClientConnection.java

@@ -0,0 +1,46 @@
+package servers;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class ClientConnection
+{
+    private Socket clientSocket;
+    private PrintWriter messageSender;
+    private BufferedReader messageReader;
+
+    private LinkedBlockingQueue<String> clientMessageList;
+
+    public ClientConnection(Socket clientSocket, LinkedBlockingQueue<String> clientMessageList) {
+        this.clientSocket = clientSocket;
+        this.clientMessageList = clientMessageList;
+
+        getIOStreams();
+        new Thread ( new ServerReceiver(clientSocket, messageReader, clientMessageList) ).start();
+    }
+
+    private void getIOStreams() {
+        try {
+            messageSender = new PrintWriter(clientSocket.getOutputStream(), true);
+            messageReader = new BufferedReader( new InputStreamReader( clientSocket.getInputStream() ) );
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Couldn't open Client Socket's IO Streams.");
+            e.printStackTrace();
+        }
+    }
+
+    public void sendMessage(String clientMessage)
+    {
+        try{
+            messageSender.println(clientMessage);
+        }
+        catch(Exception e) {
+            System.out.println("Couldn't write message to client. Perhaps He has disconnected.");
+            e.printStackTrace();
+        }
+    }
+}

src/servers/ServerListener.java

@@ -0,0 +1,79 @@
+package servers;
+
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class ServerListener implements Runnable
+{
+    private ServerSocket serverSocket;
+    private int port;
+    private int backlog;
+    private boolean serverIsRunning;
+
+    private ArrayList<ClientConnection> clientConnectionList;
+    private LinkedBlockingQueue<String> clientMessageList;
+
+    public ServerListener(int port, int backlog,
+                          ArrayList<ClientConnection> clientConnectionList,
+                          LinkedBlockingQueue<String> clientMessageList)
+    {
+        this.port = port;
+        this.backlog = backlog;
+        this.clientConnectionList = clientConnectionList;
+        this.clientMessageList = clientMessageList;
+    }
+
+    @Override
+    public void run()
+    {
+        openServerSocket();
+        while (serverIsRunning)
+            connectClients();
+        closeServerSocket();
+    }
+
+    private void openServerSocket()
+    {
+        try {
+            serverSocket = new ServerSocket( port, backlog, InetAddress.getLocalHost() );
+            serverIsRunning = true;
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Couldn't open ServerSocket with: " +
+                    "\nPort: " + String.valueOf(port) +
+                    "\nBacklog" + String.valueOf(backlog) +
+                    "\nIP Address: Local Host IP Address.\nThe program will now exit.");
+            e.printStackTrace();
+            System.exit(-1);
+        }
+    }
+
+    private void closeServerSocket() {
+        try {
+            serverSocket.close();
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Server's socket couldn't not be closed. It might still be in use.");
+            e.printStackTrace();
+        }
+    }
+
+    private void connectClients()
+    {
+        System.out.println("Waiting for a new connection...");
+
+        try {
+            Socket clientSocket = serverSocket.accept();
+            clientConnectionList.add( new ClientConnection(clientSocket, clientMessageList) );
+
+            System.out.println( "Started connection with client " + clientSocket.getLocalAddress() );
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Server couldn't accept a client.");
+            e.printStackTrace();
+        }
+    }
+}

src/servers/ServerReceiver.java

@@ -0,0 +1,80 @@
+package servers;
+
+import java.io.BufferedReader;
+import java.net.Socket;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class ServerReceiver implements Runnable
+{
+    private Socket clientSocket;
+    private BufferedReader messageReader;
+    LinkedBlockingQueue<String> clientMessageList;
+
+    public ServerReceiver(Socket clientSocket, BufferedReader messageReader, LinkedBlockingQueue<String> clientMessageList) {
+        this.clientSocket = clientSocket;
+        this.messageReader = messageReader;
+        this.clientMessageList = clientMessageList;
+    }
+
+    @Override
+    public void run()
+    {
+        String clientMessage;
+        while ( !clientSocket.isClosed() )
+        {
+            clientMessage = receiveClientMessage();
+            if ( clientMessage == null || clientMessage.equals("$") )
+            {
+                closeReader();
+                closeSocket();
+            }
+            else
+                pushMessageToQueue(clientMessage);
+        }
+    }
+
+    private String receiveClientMessage()
+    {
+        String clientMessage;
+        try {
+            clientMessage = messageReader.readLine();
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Couldn't receive Client's message. Maybe client has disconnected.");
+            e.printStackTrace();
+            return null;
+        }
+        return clientMessage;
+    }
+
+    private void pushMessageToQueue(String clientMessage) {
+        try {
+            clientMessageList.put(clientMessage);
+        } catch (InterruptedException e) {
+            System.out.println("ERROR: Couldn't put clientMessage to Server's Queue. Queue might be full.");
+            e.printStackTrace();
+        }
+    }
+
+    private void closeReader() {
+        try {
+            messageReader.close();
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Couldn't close BufferedReader. Maybe It's already closed.");
+            e.printStackTrace();
+        }
+    }
+    private void closeSocket() {
+        try {
+            clientSocket.close();
+            System.out.println("Connection with the client " +
+                    clientSocket.getLocalAddress().getHostAddress() +
+                    " has been terminated.");
+        }
+        catch (Exception e) {
+            System.out.println("ERROR: Couldn't close client's socket. Maybe It's already closed.");
+            e.printStackTrace();
+        }
+    }
+}

src/servers/ServerSender.java

@@ -0,0 +1,42 @@
+package servers;
+
+import java.util.ArrayList;
+import java.util.concurrent.LinkedBlockingQueue;
+
+public class ServerSender implements Runnable
+{
+    private ArrayList<ClientConnection> clientConnectionList;
+    private LinkedBlockingQueue<String> clientMessageList;
+
+    public ServerSender(ArrayList<ClientConnection> clientConnectionList,
+                        LinkedBlockingQueue<String> clientMessageList) {
+        this.clientConnectionList = clientConnectionList;
+        this.clientMessageList = clientMessageList;
+    }
+
+    @Override
+    public void run()
+    {
+        while (true)
+        {
+            if ( !clientMessageList.isEmpty() )
+            {
+                String clientMessage = getClientMessage();
+                if (clientMessage != null)
+                    for (ClientConnection client : clientConnectionList)
+                        client.sendMessage(clientMessage);
+            }
+        }
+    }
+
+    private String getClientMessage() {
+        String clientMessage = null;
+        try {
+            clientMessage = clientMessageList.take();
+        }
+        catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return clientMessage;
+    }
+}