This question is in Java...

Modify the CapitalizeServer code to add the following functions

1. For the server, add the following functions:

a. The ability to terminate a client connection

b. The ability to send a message to one or more clients

c. The ability to start a client pool

2. For the client, add the following functions:

a. The ability for each client to send a heartbeat signal to the server on a timer interval of 1 second

b. The ability for each client to broadcast a heartbeat signal to all the other threads every 5 seconds

*** CapitalizeServer Code Below ***

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package capitalize;

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket;

/** * A server program which accepts requests from clients to * capitalize strings. When clients connect, a new thread is * started to handle an interactive dialog in which the client * sends in a string and the server thread sends back the * capitalized version of the string. * * The program is runs in an infinite loop, so shutdown in platform * dependent. If you ran it from a console window with the "java" * interpreter, Ctrl+C generally will shut it down. */ public class CapitalizeServer {

/** * Application method to run the server runs in an infinite loop * listening on port 9898. When a connection is requested, it * spawns a new thread to do the servicing and immediately returns * to listening. The server keeps a unique client number for each * client that connects just to show interesting logging * messages. It is certainly not necessary to do this. */ public static void main(String[] args) throws Exception { System.out.println("The capitalization server is running."); int clientNumber = 0; ServerSocket listener = new ServerSocket(9898); try { while (true) { new Capitalizer(listener.accept(), clientNumber++).start(); } } finally { listener.close(); } }

/** * A private thread to handle capitalization requests on a particular * socket. The client terminates the dialogue by sending a single line * containing only a period. */ private static class Capitalizer extends Thread { private Socket socket; private int clientNumber;

public Capitalizer(Socket socket, int clientNumber) { this.socket = socket; this.clientNumber = clientNumber; log("New connection with client# " + clientNumber + " at " + socket); }

/** * Services this thread's client by first sending the * client a welcome message then repeatedly reading strings * and sending back the capitalized version of the string. */ public void run() { try {

// Decorate the streams so we can send characters // and not just bytes. Ensure output is flushed // after every newline. BufferedReader in = new BufferedReader( new InputStreamReader(socket.getInputStream())); PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

// Send a welcome message to the client. out.println("Hello, you are client #" + clientNumber + "."); out.println("Enter a line with only a period to quit ");

// Get messages from the client, line by line; return them // capitalized while (true) { String input = in.readLine(); if (input == null || input.equals(".")) { break; } out.println(input.toUpperCase()); } } catch (IOException e) { log("Error handling client# " + clientNumber + ": " + e); } finally { try { socket.close(); } catch (IOException e) { log("Couldn't close a socket, what's going on?"); } log("Connection with client# " + clientNumber + " closed"); } }

/** * Logs a simple message. In this case we just write the * message to the server applications standard output. */ private void log(String message) { System.out.println(message); } } }

*** CapitalizeClient Code Below ***

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package capitalize;

import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket;

import javax.swing.JFrame; import javax.swing.JOptionPane; import javax.swing.JScrollPane; import javax.swing.JTextArea; import javax.swing.JTextField;

/** * A simple Swing-based client for the capitalization server. * It has a main frame window with a text field for entering * strings and a textarea to see the results of capitalizing * them. */ public class CapitalizeClient {

private BufferedReader in; private PrintWriter out; private JFrame frame = new JFrame("Capitalize Client"); private JTextField dataField = new JTextField(40); private JTextArea messageArea = new JTextArea(8, 60);

/** * Constructs the client by laying out the GUI and registering a * listener with the textfield so that pressing Enter in the * listener sends the textfield contents to the server. */ public CapitalizeClient() {

// Layout GUI messageArea.setEditable(false); frame.getContentPane().add(dataField, "North"); frame.getContentPane().add(new JScrollPane(messageArea), "Center");

// Add Listeners dataField.addActionListener(new ActionListener() { /** * Responds to pressing the enter key in the textfield * by sending the contents of the text field to the * server and displaying the response from the server * in the text area. If the response is "." we exit * the whole application, which closes all sockets, * streams and windows. */ public void actionPerformed(ActionEvent e) { out.println(dataField.getText()); String response; try { response = in.readLine(); if (response == null || response.equals("")) { System.exit(0); } } catch (IOException ex) { response = "Error: " + ex; } messageArea.append(response + " "); dataField.selectAll(); } }); }

/** * Implements the connection logic by prompting the end user for * the server's IP address, connecting, setting up streams, and * consuming the welcome messages from the server. The Capitalizer * protocol says that the server sends three lines of text to the * client immediately after establishing a connection. */ public void connectToServer() throws IOException {

// Get the server address from a dialog box. String serverAddress = JOptionPane.showInputDialog( frame, "Enter IP Address of the Server:", "Welcome to the Capitalization Program", JOptionPane.QUESTION_MESSAGE);

// Make connection and initialize streams Socket socket = new Socket(serverAddress, 9898); in = new BufferedReader( new InputStreamReader(socket.getInputStream())); out = new PrintWriter(socket.getOutputStream(), true);

// Consume the initial welcoming messages from the server for (int i = 0; i < 3; i++) { messageArea.append(in.readLine() + " "); } }

/** * Runs the client application. */ public static void main(String[] args) throws Exception { CapitalizeClient client = new CapitalizeClient(); client.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); client.frame.pack(); client.frame.setVisible(true); client.connectToServer(); } }