server example

package G8R.app;

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.logging.*;

import G8R.serialization.*;
import N4M.serialization.*;
import N4M.app.N4MServer;

/**
 * G8RServer
 */
public class G8RServer {

	// G8R Logs
	private static String CONNECTIONLOG = "connections.log";

	/**
	 * getServerSocket
	 * Returns a TCP ServerSocket connected to the port if it can
	 * @param port Port number to connect, between 0 to 65535 inclusive
	 * @return ServerSocket connected to
	 * @throws IOException if I/O error when opening socket
	 */
	private static ServerSocket getServerSocket(int port) throws IOException {
		ServerSocket retSocket = null;
		try {
			retSocket = new ServerSocket(port);
		}
		catch(IOException e){
			System.err.println("ERROR: I/O error when opening socket");
			throw e;
		}
		catch(IllegalArgumentException e) {
			System.err.println(
					"ERROR: Port parameter outside of range [0,65535]");
			throw e;
		}
		return retSocket;
	}

	/**
	 * G8RServer implementation
	 * Runs TCP Poll application from Program 1
	 * Runs UDP Access Count application from Program 5
	 * @author Austin Lau
	 * @param args array arguments, args[0] = port, args[1] = numThreads
	 */
	public static void main(String[] args) throws IOException{
		// Confirm correct number of arguements
		if (args.length != 2) {
			throw new IllegalArgumentException(
					"Parameter(s): <Port> <NumThreads>");
		}

		// Port Number
		int serverPort = Integer.parseInt(args[0]);

		// Number of threads
		int numThreads = Integer.parseInt(args[1]);
		if (numThreads < 1) {
			throw new IllegalArgumentException(
					"Size of thread pool must be greater than 0");
		}

		// Create a TCP server socket to accept client connection requests
		ServerSocket serverSock = getServerSocket(serverPort);
		// Set to reuse addresses (See SO_REUSEADDR)
		serverSock.setReuseAddress(true);

		// G8R Logging Information
		final Logger g8rLogger = Logger.getLogger(CONNECTIONLOG);
		FileHandler g8rFH = new FileHandler(CONNECTIONLOG);
		g8rLogger.addHandler(g8rFH);
		g8rFH.setFormatter(new SimpleFormatter());

		System.out.println("Starting server on port " + args[0]);

		// N4M Server
		Thread n4mThread = new Thread() {
			public void run() {
				// Run forever
				for(;;) {
					try {
						// Establish the socket
						DatagramSocket socket = new DatagramSocket(serverPort);
						// Handle it somewhere else
						N4MServer.handleN4MServer(socket,serverPort,g8rLogger);
						// Close it
						socket.close();
					}
					catch (SocketException e) {
						e.printStackTrace();
					}
				}
			}
		};
		N4MServer.establishLogger();
		n4mThread.start();

		// G8R Server
		for(int i = 0; i < numThreads; i++) {
			Thread g8rThread = new Thread() {
				public void run() {
					for(;;) {
						try{
							// TCP Socket
							Socket clientSocket = serverSock.accept();
							// Obtain Socket MessageInput and MessageOutput
							MessageInput mIn = new MessageInput(
									clientSocket.getInputStream());
							MessageOutput mOut = new MessageOutput(
									clientSocket.getOutputStream());
							// Recieve the response, output, and log
							handleG8RServer(
									clientSocket,mIn,mOut,g8rLogger);
						}catch(IOException ex) {
							g8rLogger.log(Level.WARNING,
									"Client accept failed", ex);
						}
					}
				}
			};
			// Run the thread
			g8rThread.start();
		}
	}

	/**
	 * handleG8RServer
	 * Recieve input from input from the given socket
	 * Log the issues found
	 * Send a G8RRequest back to the client
	 * @param clientSocket The Socket connected to
	 * @param mIn MessageInput to read G8RRequest from
	 * @parma mOut MessageOutput to write G8RResponse to
	 * @param logger Log to record issues and warnings
	 */
	private static void handleG8RServer(
			Socket clientSocket, MessageInput mIn,
			MessageOutput mOut,Logger logger){
		G8RRequest req = null;
		G8RResponse res = null;
		String ending = "***client terminated";
		try{
			// Decode the G8RRequest from MessageInput
			req = (G8RRequest) G8RMessage.decode(mIn);
			// Generate a response from G8RRequest
			res = genG8RResponse(req);
			// Send the response to output
			res.encode(mOut);
			// Log the information
			ending = "[Recieved: " + req + "|Sent: " + res + "]";
		}
		catch(IOException ex) {
			System.err.println("IO in g8rserver");
			logger.log(Level.WARNING, "ERROR: IOException found", ex);
		}
		catch(ValidationException ex) {
			System.err.println("VE in g8rserver");
			logger.log(Level.WARNING,
					"ERROR: ValidationException on input", ex);
		}
		finally {
			try {
				clientSocket.close();
			}
			catch(IOException ex) {
			}
		}
		// Create the log
		logger.info(
				// Client Address
				clientSocket.getRemoteSocketAddress() + ":" +
				// Port
				clientSocket.getPort() + "-" +
				// Thread ID
				Thread.currentThread().getId() + " " +
				// Append the G8RRequest and Server or ending
				ending
				);
	}

	/**
	 * genG8RResponse
	 * Generate a G8RResponse given a G8RRequest
	 * @param req The given G8RRequest sent by client
	 * @return A G8RResponse to send back to the client
	 * @throws ValidationException if issue on the request sent
	 */
	private static G8RResponse genG8RResponse(G8RRequest req)
			throws ValidationException {
		G8RResponse res = null;
		// A cookie list for the return
		CookieList reqCookieList = new CookieList(req.getCookieList());
		// Response determination
		switch(req.getFunction()) {
			case "Poll":
				res = pollResponse(req);
				N4MServer.applicationHandler("Poll");
				break;
			case "NameStep":
				res = namestepResponse(req);
				N4MServer.applicationHandler("NameStep");
				break;
			case "FoodStep":
				res = foodstepResponse(req);
				N4MServer.applicationHandler("FoodStep");
				break;
			// Throw a validation exception
			default:
				System.err.println("VE 228 in g8rserver");
				throw new ValidationException(
						"ERROR: Cannot determine function",
						req.getFunction());
		}
		return res;
	}

	/**
	 * pollResponse
	 * Creates a response from poll function
	 * @param req G8RRequest sent from input
	 * @return G8RResponse for poll
	 * @throws ValidationException if issue in formatting of G8RResponse
	 */
	private static G8RResponse pollResponse(G8RRequest req)
			throws ValidationException {
		return new G8RResponse(
				"OK",
				"NameStep",
				"Name (First Last)>",
				req.getCookieList()
				);
	}

	/**
	 * namestepResponse
	 * Creates a response from NameStep function
	 * @param req G8RRequest sent from input
	 * @return G8RResponse for NameStep
	 * @throws ValidationException if issue in formatting of G8RResponse
	 */
	private static G8RResponse namestepResponse(G8RRequest req)
			throws ValidationException {
		CookieList reqCookieList = req.getCookieList();
		if (req.getParams().length != 2) {
			throw new ValidationException(
					"ERROR: Incorrect number of params",
					req.getParams().length + "");
		}
		// Obtain the first and last names and add to CookieList
		reqCookieList.add("FName",req.getParams()[0]);
		reqCookieList.add("LName",req.getParams()[1]);
		// Generate a response
		return new G8RResponse(
				"OK",
				"FoodStep",
				req.getParams()[0] + "'s Food mood>",
				reqCookieList
				);
	}

	/**
	 * foodstepResponse
	 * Creates a response from FoodStep function
	 * @param req G8RRequest sent from input
	 * @return G8RResponse for FoodStep
	 * @throws ValidationException if issue in formatting of G8RResponse
	 */
	private static G8RResponse foodstepResponse(G8RRequest req)
			throws ValidationException {
		if (req.getParams().length != 1) {
			throw new ValidationException(
				"ERROR: Incorrect num params",
				req.getParams().length + "");
		}
		String message = "No discount available";
		switch(req.getParams()[0]){
			case "Mexican":
				message = "20% off at Tacopia";
				break;
			case "Italian":
				message = "25% off at Pastastic";
				break;
			case "American":
				message = "Free fries with shake at McDanks";
				break;
		}
		return new G8RResponse(
				"OK",
				"NULL",
				message,
				req.getCookieList()
				);
	}


}