package yoonforh.generic;
/*
 *	Copyright (c) 1996 Yoon Kyung Koo. All Rights Reserved.
 *
 *      GenericServer.java
 *      Author: Yoon Kyung Koo  (yoonforh@interpia.net,  http://interpia.net/~yoonforh)
 *      Date: 10/24/96
 *		VERSION HISTORY
 *			Last Update: 10/31/97
 *			Version: 1.00  (for JDK 1.02 API)
 *				added finally clause in run method
 *			Update: 10/25/96
 *			Version: 0.99  (for JDK 1.02 API)
 */

import java.net.*;
import java.io.*;
import java.util.Vector;
import java.util.Date;

public class GenericServer {

    private final static int	DEFAULT_PORT	= 6561;
	private	static int port = DEFAULT_PORT ;
	private ConnectionManager cm = null;       // 연결을 관리하는 쓰레드
	public static PrintStream	log = null;

	public static void main(String args[])
	{
	   
		int next = 0;
		String arg;
		while (true)
		{
			try
			{
				arg = args[next++].toLowerCase();
				if (arg.startsWith("-l"))		 // 로그 파일 지정
					log = new PrintStream(new FileOutputStream(args[next++]), true); /* autoflush on */
				else if (arg.startsWith("-p"))   // 포트 번호 지정
					port = Integer.parseInt(args[next++]);
			}
			catch (IOException i)
			{
				log = null;
				System.err.println("WARNING\tunable to create log file");
			}
			catch (NumberFormatException n)
			{
				port = DEFAULT_PORT;
				System.err.println("WARNING\tbad port number, using 6561");
			}
			catch (ArrayIndexOutOfBoundsException a) {break; }
		}

		new GenericServer();
	} /* end main() */

    GenericServer()
	{
		try
	    {
			if (log	== null)
				log = new PrintStream(System.out, true);
			log.println("GenericServer is initializing to port " + port);
	    }
	    catch (Exception i) {}

		cm = new ConnectionManager(port); 
		// 접속을 관리하는 쓰레드 생성.
		cm.start();
		// ConnectionManager의 run() 도구 호출
	}

}


/* ConnectionManager는 접속을 기다리다가 클라이언트가 연결해오면 해당 클라이언트를 처리할 ServerConnection 
쓰레드를 생성한다. 일종의 동기적인 멀티플렉싱이다. */
class ConnectionManager extends Thread
{
private static int port;
private static Vector my_threads = new Vector(5,2); 
/* 초기치 5, 증가치 2인 벡터를 생성한다. 이 벡터에는 소켓이 연결되면 생성되는 ServerConnection 쓰레
드 인스턴스들이 저장된다. */
private ServerSocket main_socket = null;

	public ConnectionManager(int portNo)
	{
		port = portNo;
	}
	public void run()
	{
		serveRequests();
		// 서버 소켓을 생성하여 무한 루프를 돌다가 클라이언트들이 접속해오면 연결을 생성하여
		// 각각의 연결에 하나의 쓰레드를 만들어주는 루틴이다.
	}
	private void serveRequests()
	{
		try {
			main_socket = new ServerSocket(port); // 서버 소켓 생성
		} catch(Exception e) {
			GenericServer.log.println("Exception ["+e+"] while binding to port ["+port+"]. exiting...");
			System.exit(1);
		}
		ServerConnection temp_sc = null;
		while (true)     // 무한 루프. 이 루프의 포트는 지정한 서버의 포트이다.
		{
			try {
				Socket this_connection = main_socket.accept();
				// 서버 소켓이 클라이언트를 기다렸다가 연결을 생성한다.
				// accept()의 반환값은 Socket 인스턴스이고 앞으로 연결된 클라이언트와
				// 대화는 이 인스턴스를 통해서 한다.
				temp_sc = new ServerConnection(this_connection);
				// 연결이 생성되면 이 Socket 인스턴스로 ServerConnection 쓰레드를 생성
				GenericServer.log.println("new Server Connection created");
				temp_sc.start();
				// ServerConnection 인스턴스의 run() 호출
				my_threads.addElement(temp_sc);
				// ServerConnection 인스턴스를 벡터에 추가
/* 벡터의 크기만큼 루프를 반복한다. 벡터에 저장되어 있는 각 ServerConnection 쓰레드가 실행 중인지 검사하고 
쓰레드가 종료하였으면 벡터에서 제거한다. ServerConnection 쓰레드는 소켓을 종료하면 실행을 중단한다. */
				for(int i=0; i<ConnectionManager.my_threads.size(); i++)
					if(!((ServerConnection)(my_threads.elementAt(i))).isAlive())
						my_threads.removeElementAt(i);
			} catch(Exception e) {
				GenericServer.log.println("Exception:\n" + e);
			}
		}
	}
}

class ServerConnection extends Thread // 연결이 생성된 후 실제 클라이언트와 대화를 하는 쓰레드
{
	private Socket mysocket;
//        private PrintStream output;
	private DataOutputStream output;
	private DataInputStream input;

	public ServerConnection(Socket s)
	{
		mysocket = s;  // 클라이언트와 연결이 된 소켓 인스턴스를 넘겨 받는다.
	}
    
	private synchronized void doServerWork()
	{
		String WorkType=null;
		GenericWork newWork=null;
		
		if ( (WorkType=GenericTool.getMessage(input, "WORKTYPE")) == null ) {
			GenericServer.log.println("WorkType info data receive error");
			return;
		}

		GenericServer.log.println("Type Message received from client: " + WorkType);

		// 소켓으로부터 넘겨 받은 ID 확인을 통해 invoke할 서버 작업 클래스를 찾는다.
		String className = WorkType + "Work";
		try {
		    newWork = (GenericWork) Class.forName(className).newInstance(); // 생성자 실행
			
			if ( !GenericTool.sendMessage(output, "RESPONSE", "ACCEPT") ) {
				GenericServer.log.println("send accept message error");
				return;
			}
			newWork.work(input, output);
		} catch (Exception e) {
			GenericTool.sendMessage(output, "RESPONSE", "ERROR");
		    GenericServer.log.println(e.toString());
			return;
		} finally {
			try {
				input.close();
				output.close();
		    	GenericServer.log.println("closing streams");
			} catch (IOException ie) {
		    	GenericServer.log.println(ie.toString()+" when closing streams");
			}
		}
	}

	public void run()
	{
		GenericServer.log.print("Connected to: " + (mysocket.getInetAddress()).getHostName() +":"+ mysocket.getPort());
		GenericServer.log.println(" at : " + new Date());
		// 연결된 소켓의 인터넷 주소와 포트를 표준 출력으로 출력한다.
		try {
//                        output = new PrintStream(mysocket.getOutputStream());
            output = new DataOutputStream( new BufferedOutputStream(mysocket.getOutputStream()) );
			/* 연결된 소켓의 출력 스트림으로 PrintStream을 생성한다. 소켓의 출력 스트림은
			 * 서버에서 클라이언트로 전달되는 스트림이다.
			 * 반대로 입력 스트림은 클라이언트에서 서버로 전달되는 스트림이다.
			 */
			input = new DataInputStream( new BufferedInputStream(mysocket.getInputStream()) ); // 입력 스트림을 얻는다.
			// 서버로서의 일을 한다.
			doServerWork();
		} catch ( Exception e ) {
			GenericServer.log.println( e.toString()+" and terminate socket work");
		} finally {
			// 작업이 끝나면 소켓을 종료한다.
			GenericServer.log.println("Disconnecting: " + (mysocket.getInetAddress()).getHostName() +":"+ mysocket.getPort());
			try {
				mysocket.close();
			} catch (IOException ie) {
				GenericServer.log.println( "Exception :["+ie.toString()+"] while closing socket.");
			}
		}
		stop();  // 쓰레드를 중단한다.
		/* 쓰레드의 stop() 도구는 ThreadDeath 객체 인스턴스를 목적 객체에게 던져 준다.
		 * ThreadDeath 객체는 Exception 클래스에서 파생된 것이 아니라 Error 클래스에서
		 * 파생되었다. 특별한 일이 없다면 catch를 할 필요가 없다.
		 * catch를 하지 않으면 중단된 쓰레드가 실제로 종료된다.
		 */
	}
}