Solution for
Programming Exercise 10.4
THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to
the following exercise from this on-line
Java textbook.
Exercise 10.4:
For this exercise, you will write a network server program.
The program is a simple file server that makes a collection
of files available for transmission to clients. When the
server starts up, it needs to know the name of the
directory that contains the collection of files. This
information can be provided as a command-line argument. You can
assume that the directory contains only regular files (that is, it does not
contain any sub-directories). You can also assume that all the files are
text files.
When a client connects to the server, the server
first reads a one-line command from the client. The command
can be the string "index". In this case, the server responds by sending a
list of names of all the files that are available on the server.
Or the command can be of the form "get <file>", where
<file> is a file name. The server checks whether the
requested file actually exists. If so, it first sends
the word "ok" as a message to the client. Then it sends the contents of
the file and closes the connection. Otherwise, it sends
the word "error" to the client and closes the connection.
Ideally, your server should start a separate thread to handle
each connection request. However, if you don't want to deal with
threads you can just call a subroutine to handle the request.
See the DirectoryList example in
Section 10.2 for help with the problem of getting the list of
files in the directory.
Discussion
The sample program DateServe.java
shows the typical outline of a server program. For this exercise, the
processing of each connection request is more complicated, but the
basic outline of the program is the same.
My program begins by getting the directory name from the command
line. An object of type File is created which can be used
to check whether the specified directory exists and is in fact a
directory rather than a regular file. This allows for some basic
error checking before the server starts running:
if (args.length == 0) {
System.out.println("Usage: java FileServer <directory>");
return;
}
directory = new File(args[0]);
if ( ! directory.exists() ) {
System.out.println("Specified directory does not exist.");
return;
}
if (! directory.isDirectory() ) {
System.out.println("The specified file is not a directory.");
return;
}
The File object is needed later, in any case, for
reading the list of files in the directory.
The rest of the main() routine takes the typical form
for a server program. A listening socket is established. Then
the server accepts and processes connection requests in an infinite
loop. In this case, the processing is done by creating a thread
belonging to the class ConnectionHandler, which is a subclass
of the standard class, Thread. The actual communication with the
client is done in the run() method of this thread, which is
executed in parallel with the main() routine and with any
other ConnectionHandler threads that are created. This allows
the server to process more than one client simultaneously. Since it
can potentially take a long time to transmit a file, multithreading
is very desirable in this example.
The run() method of the thread implements the communication
protocol of the server in a straightforward way: It reads a line
from the client. If the line is "index", it sends a list of available
files. If the line starts with the string "get", it sends the requested
file. Finally, it closes the connection. (In fact, the connection
is closed in the finally clause of a try statement
to make sure that the connection is closed before the thread terminates.)
You should be able to follow all this in the solution that follows.
(My ConnectionHandler class is a static nested
class inside the FileServer class. Nested classes were covered in
Section 5.6. It's not essential in this example that
the class be nested. It could easily be a separate class.)
The Solution
/*
This program is a very simple network file server. The
server has a list of available text files that can be
downloaded by the client. The client can also download
the list of files. When the connection is opened, the
client sends one of two possible commands to the server:
"index" or "get <file-name>". The server replies to
the first command by sending the list of available files.
It responds to the second with a one-line message,
either "ok" or "error". If the message is "ok", it is
followed by the contents of the file with the specified
name. The "error" message indicates that the specified
file does not exist on the server. (The server can also
respond with the message "unknown command" if the command
it reads is not one of the two possible legal commands.)
The server program requires a command-line parameter
that specifies the directory that contains the files
that the server can serve. The files should all be
text files, but this is not checked. Also, the server
must have permission to read all the files.
This program uses the non-standard class, TextReader.
*/
import java.net.*;
import java.io.*;
public class FileServer {
static final int LISTENING_PORT = 3210;
public static void main(String[] args) {
File directory; // The directory from which the
// gets the files that it serves.
ServerSocket listener; // Listens for connection requests.
Socket connection; // A socket for communicating with
// a client.
/* Check that there is a command-line argument.
If not, print a usage message and end. */
if (args.length == 0) {
System.out.println("Usage: java FileServer <directory>");
return;
}
/* Get the directory name from the command line, and make
it into a file object. Check that the file exists and
is in fact a directory. */
directory = new File(args[0]);
if ( ! directory.exists() ) {
System.out.println("Specified directory does not exist.");
return;
}
if (! directory.isDirectory() ) {
System.out.println("The specified file is not a directory.");
return;
}
/* Listen for connection requests from clients. For
each connection, create a separate Thread of type
ConnectionHandler to process it. The ConnectionHandler
class is defined below. The server runs until the
program is terminated, for example by a CONTROL-C. */
try {
listener = new ServerSocket(LISTENING_PORT);
System.out.println("Listening on port " + LISTENING_PORT);
while (true) {
connection = listener.accept();
new ConnectionHandler(directory,connection);
}
}
catch (Exception e) {
System.out.println("Server shut down unexpectedly.");
System.out.println("Error: " + e);
return;
}
} // end main()
static class ConnectionHandler extends Thread {
// An object of this class is a thread that will
// process the connection with one client. The
// thread starts itself in the constructor.
File directory; // The directory from which files are served
Socket connection; // A connection to the client.
TextReader incoming; // For reading data from the client.
PrintWriter outgoing; // For transmitting data to the client.
ConnectionHandler(File dir, Socket conn) {
// Constructor. Record the connection and
// the directory and start the thread running.
directory = dir;
connection = conn;
start();
}
void sendIndex() throws Exception {
// This is called by the run() method in response
// to an "index" command. Send the list of files
// in the directory.
String[] fileList = directory.list();
for (int i = 0; i < fileList.length; i++)
outgoing.println(fileList[i]);
outgoing.flush();
outgoing.close();
if (outgoing.checkError())
throw new Exception("Error while transmitting data.");
}
void sendFile(String fileName) throws Exception {
// This is called by the run() command in response
// to "get <fileName>" command. If the file doesn't
// exist, send the message "error". Otherwise,
// send the message "ok" followed by the contents
// of the file.
File file = new File(directory,fileName);
if ( (! file.exists()) || file.isDirectory() ) {
// (Note: Don't try to send a directory, which
// shouldn't be there anyway.)
outgoing.println("error");
}
else {
outgoing.println("ok");
TextReader fileIn = new TextReader( new FileReader(file) );
while (fileIn.peek() != '\0') {
// Read and send lines from the file until
// an end-of-file is encountered.
String line = fileIn.getln();
outgoing.println(line);
}
}
outgoing.flush();
outgoing.close();
if (outgoing.checkError())
throw new Exception("Error while transmitting data.");
}
public void run() {
// This is the method that is executed by the thread.
// It creates streams for communicating with the client,
// reads a command from the client, and carries out that
// command. The connection is logged to standard output.
// An output beginning with ERROR indicates that a network
// error occurred. A line beginning with OK means that
// there was no network error, but does not imply that the
// command from the client was a legal command.
String command = "Command not read";
try {
incoming = new TextReader( connection.getInputStream() );
outgoing = new PrintWriter( connection.getOutputStream() );
command = incoming.getln();
if (command.equals("index")) {
sendIndex();
}
else if (command.startsWith("get")){
String fileName = command.substring(3).trim();
sendFile(fileName);
}
else {
outgoing.println("unknown command");
outgoing.flush();
}
System.out.println("OK " + connection.getInetAddress()
+ " " + command);
}
catch (Exception e) {
System.out.println("ERROR " + connection.getInetAddress()
+ " " + command + " " + e);
}
finally {
try {
connection.close();
}
catch (IOException e) {
}
}
}
} // end nested class ConnectionHandler
} //end class FileServer
[ Exercises
| Chapter Index
| Main Index
]
